gnunet_testing.py

Go to the documentation of this file.

#!/home/buildbot/bb-worker/sandbox/bin/python
#    This file is part of GNUnet.
#    (C) 2010, 2017, 2018 Christian Grothoff (and other contributing authors)
#
#    GNUnet is free software: you can redistribute it and/or modify it
#    under the terms of the GNU Affero General Public License as published
#    by the Free Software Foundation, either version 3 of the License,
#    or (at your option) any later version.
#
#    GNUnet is distributed in the hope that it will be useful, but
#    WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#    Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#    SPDX-License-Identifier: AGPL3.0-or-later
#
# Functions for integration testing
 
import os
import subprocess
import sys
import shutil
import time
from gnunet_pyexpect import pexpect
import logging
 
logger = logging.getLogger()
handler = logging.StreamHandler()
formatter = logging.Formatter(
    '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'
)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
 
 
class Check(object):
    def __init__(self, test):
        self.fulfilledfulfilled = False
        self.conditionsconditions = list()
        self.testtest = test
 
    def add(self, condition):
        self.conditionsconditions.append(condition)
 
    def run(self):
        fulfilled = True
        pos = 0
        neg = 0
        for c in self.conditionsconditions:
            if (False == c.check()):
                fulfilled = False
                neg += 1
            else:
                pos += 1
        return fulfilled
 
    def run_blocking(self, timeout, pos_cont, neg_cont):
        execs = 0
        res = False
        while ((False == res) and (execs < timeout)):
            res = self.runrun()
            time.sleep(1)
            execs += 1
        if ((False == res) and (execs >= timeout)):
            logger.debug('Check had timeout after %s seconds', str(timeout))
            neg_cont(self)
        elif ((False == res) and (execs < timeout)):
            if (None != neg_cont):
                neg_cont(self)
        else:
            if (None != pos_cont):
                pos_cont(self)
        return res
 
    def run_once(self, pos_cont, neg_cont):
        execs = 0
        res = False
        res = self.runrun()
        if ((res == False) and (neg_cont != None)):
            neg_cont(self)
        if ((res == True) and (pos_cont != None)):
            pos_cont(self)
        return res
 
    def evaluate(self, failed_only):
        pos = 0
        neg = 0
        for c in self.conditionsconditions:
            if (False == c.evaluate(failed_only)):
                neg += 1
            else:
                pos += 1
        logger.debug(
            '%s out of %s conditions fulfilled', str(pos), str(pos + neg)
        )
        return self.fulfilledfulfilled
 
    def reset(self):
        self.fulfilledfulfilled = False
        for c in self.conditionsconditions:
            c.fulfilled = False
 
 
class Condition(object):
    def __init__(self):
        self.fulfilledfulfilled = False
        self.typetype = 'generic'
 
    def __init__(self, type):
        self.fulfilledfulfilled = False
        self.typetype = type
 
    def check(self):
        return False
 
    def evaluate(self, failed_only):
        if ((self.fulfilledfulfilled == False) and (failed_only == True)):
            logger.debug(
                '%s condition for was %s', str(self.typetype), str(self.fulfilledfulfilled)
            )
        elif (failed_only == False):
            logger.debug(
                '%s condition for was %s', str(self.typetype), str(self.fulfilledfulfilled)
            )
        return self.fulfilledfulfilled
 
 
class FileExistCondition(Condition):
    def __init__(self, file):
        self.fulfilledfulfilledfulfilled = False
        self.typetypetype = 'file'
        self.filefile = file
 
    def check(self):
        if (self.fulfilledfulfilledfulfilled == False):
            res = os.path.isfile(self.filefile)
            if (res == True):
                self.fulfilledfulfilledfulfilled = True
                return True
            else:
                return False
        else:
            return True
 
    def evaluate(self, failed_only):
        if ((self.fulfilledfulfilledfulfilled == False) and (failed_only == True)):
            logger.debug(
                '%s confition for file %s was %s', str(self.typetypetype), self.filefile,
                str(self.fulfilledfulfilledfulfilled)
            )
        elif (failed_only == False):
            logger.debug(
                '%s confition for file %s was %s', str(self.typetypetype), self.filefile,
                str(self.fulfilledfulfilledfulfilled)
            )
        return self.fulfilledfulfilledfulfilled
 
 
class StatisticsCondition(Condition):
    def __init__(self, peer, subsystem, name, value):
        self.fulfilledfulfilledfulfilled = False
        self.typetypetype = 'statistics'
        self.peerpeer = peer
        self.subsystemsubsystem = subsystem
        self.namename = name
        self.valuevalue = str(value)
        self.resultresult = -1
 
    def check(self):
        if (self.fulfilledfulfilledfulfilled == False):
            self.resultresult = self.peerpeer.get_statistics_value(
                self.subsystemsubsystem, self.namename
            )
            if (self.resultresult == self.valuevalue):
                self.fulfilledfulfilledfulfilled = True
                return True
            else:
                return False
        else:
            return True
 
    def evaluate(self, failed_only):
        if (self.fulfilledfulfilledfulfilled == False):
            fail = " FAIL!"
            op = " != "
        else:
            fail = ""
            op = " == "
        if (((self.fulfilledfulfilledfulfilled == False) and (failed_only == True))
            or (failed_only == False)):
            logger.debug(
                '%s %s condition in subsystem %s: %s: (expected/real value) %s %s %s %s',
                self.peerpeer.id[:4].decode("utf-8"), self.peerpeer.cfg,
                self.subsystemsubsystem.ljust(12), self.namename.ljust(30), self.valuevalue, op,
                self.resultresult, fail
            )
        return self.fulfilledfulfilledfulfilled
 
 
# Specify two statistic values and check if they are equal
class EqualStatisticsCondition(Condition):
    def __init__(self, peer, subsystem, name, peer2, subsystem2, name2):
        self.fulfilledfulfilledfulfilled = False
        self.typetypetype = 'equalstatistics'
        self.peerpeer = peer
        self.subsystemsubsystem = subsystem
        self.namename = name
        self.resultresult = -1
        self.peer2peer2 = peer2
        self.subsystem2subsystem2 = subsystem2
        self.name2name2 = name2
        self.result2result2 = -1
 
    def check(self):
        if (self.fulfilledfulfilledfulfilled == False):
            self.resultresult = self.peerpeer.get_statistics_value(
                self.subsystemsubsystem, self.namename
            )
            self.result2result2 = self.peer2peer2.get_statistics_value(
                self.subsystem2subsystem2, self.name2name2
            )
            if (self.resultresult == self.result2result2):
                self.fulfilledfulfilledfulfilled = True
                return True
            else:
                return False
        else:
            return True
 
    def evaluate(self, failed_only):
        if (((self.fulfilledfulfilledfulfilled == False) and (failed_only == True))
            or (failed_only == False)):
            logger.debug(
                '%s %s %s == %s %s %s %s %s', self.peerpeer.id[:4],
                self.subsystemsubsystem.ljust(12), self.namename.ljust(30), self.resultresult,
                self.peer2peer2.id[:4], self.subsystem2subsystem2.ljust(12),
                self.name2name2.ljust(30), self.result2result2
            )
        return self.fulfilledfulfilledfulfilled
 
 
class Test(object):
    def __init__(self, testname, verbose):
        self.peerspeers = list()
        self.verboseverbose = verbose
        self.namename = testname
        srcdir = "../.."
        gnunet_pyexpect_dir = os.path.join(srcdir, "contrib/scripts")
        if gnunet_pyexpect_dir not in sys.path:
            sys.path.append(gnunet_pyexpect_dir)
        self.gnunetarmgnunetarm = ''
        self.gnunetstatisticsgnunetstatistics = ''
        if os.name == 'posix':
            self.gnunetarmgnunetarm = 'gnunet-arm'
            self.gnunetstatisticsgnunetstatistics = 'gnunet-statistics'
            self.gnunetpeerinfognunetpeerinfo = 'gnunet-peerinfo'
        elif os.name == 'nt':
            self.gnunetarmgnunetarm = 'gnunet-arm.exe'
            self.gnunetstatisticsgnunetstatistics = 'gnunet-statistics.exe'
            self.gnunetpeerinfognunetpeerinfo = 'gnunet-peerinfo.exe'
        if os.name == "nt":
            shutil.rmtree(os.path.join(os.getenv("TEMP"), testname), True)
        else:
            shutil.rmtree("/tmp/" + testname, True)
 
    def add_peer(self, peer):
        self.peerspeers.append(peer)
 
    def p(self, msg):
        if (self.verboseverbose == True):
            print(msg)
 
 
class Peer(object):
    def __init__(self, test, cfg_file):
        if (False == os.path.isfile(cfg_file)):
            # print(("Peer cfg " + cfg_file + ": FILE NOT FOUND"))
            logger.debug('Peer cfg %s : FILE NOT FOUND', cfg_file)
        self.idid = "<NaN>"
        self.testtest = test
        self.startedstarted = False
        self.cfgcfg = cfg_file
 
    def __del__(self):
        if (self.startedstarted == True):
            # print('ERROR! Peer using cfg ' + self.cfg + ' was not stopped')
            logger.debug('ERROR! Peer using cfg %s was not stopped', self.cfgcfg)
            ret = self.stopstop()
            if (False == ret):
                # print('ERROR! Peer using cfg ' +
                #       self.cfg +
                #       ' could not be stopped')
                logger.debug(
                    'ERROR! Peer using cfg %s could not be stopped', self.cfgcfg
                )
                self.startedstarted = False
            return ret
        else:
            return False
 
    def start(self):
        os.unsetenv("XDG_CONFIG_HOME")
        os.unsetenv("XDG_DATA_HOME")
        os.unsetenv("XDG_CACHE_HOME")
        self.testtest.p("Starting peer using cfg " + self.cfgcfg)
        try:
            server = subprocess.Popen([
                self.testtest.gnunetarm, '-sq', '-c', self.cfgcfg
            ])
            server.communicate()
        except OSError:
            # print("Can not start peer")
            logger.debug('Can not start peer')
            self.startedstarted = False
            return False
        self.startedstarted = True
        test = ''
        try:
            server = pexpect()
            server.spawn(
                None, [self.testtest.gnunetpeerinfo, '-c', self.cfgcfg, '-s'],
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT
            )
            test = server.read("stdout", 1024)
        except OSError:
            # print("Can not get peer identity")
            logger.debug('Can not get peer identity')
        test = (test.split(b'`')[1])
        self.idid = test.split(b'\'')[0]
        return True
 
    def stop(self):
        if (self.startedstarted == False):
            return False
        self.testtest.p("Stopping peer using cfg " + self.cfgcfg)
        try:
            server = subprocess.Popen([
                self.testtest.gnunetarm, '-eq', '-c', self.cfgcfg
            ])
            server.communicate()
        except OSError:
            # print("Can not stop peer")
            logger.debug('Can not stop peer')
            return False
        self.startedstarted = False
        return True
 
    def get_statistics_value(self, subsystem, name):
        server = pexpect()
        server.spawn(
            None, [
                self.testtest.gnunetstatistics, '-c', self.cfgcfg, '-q', '-n', name,
                '-s', subsystem
            ],
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT
        )
        # server.expect ("stdout", re.compile (r""))
        test = server.read("stdout", 10240)
        tests = test.partition(b'\n')
        # On W32 GNUnet outputs with \r\n, rather than \n
        if os.name == 'nt' and tests[1] == b'\n' and tests[0][-1] == b'\r':
            tests = (tests[0][:-1], tests[1], tests[2])
        tests = tests[0]
        result = tests.decode("utf-8").strip()
        logger.debug(
            'running gnunet-statistics %s for %s "/" %s yields %s', self.cfgcfg,
            name, subsystem, result
        )
        if (result.isdigit() == True):
            return result
        else:
            logger.debug(
                'Invalid statistics value: %s is not a number!', result
            )
            return -1