GNUnet  0.11.x
gnunet_testing.py
Go to the documentation of this file.
1 #!/home/buildbot/bb-worker/sandbox/bin/python3
2 # This file is part of GNUnet.
3 # (C) 2010, 2017, 2018 Christian Grothoff (and other contributing authors)
4 #
5 # GNUnet is free software: you can redistribute it and/or modify it
6 # under the terms of the GNU Affero General Public License as published
7 # by the Free Software Foundation, either version 3 of the License,
8 # or (at your option) any later version.
9 #
10 # GNUnet is distributed in the hope that it will be useful, but
11 # WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 # Affero General Public License for more details.
14 #
15 # You should have received a copy of the GNU Affero General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
17 #
18 # SPDX-License-Identifier: AGPL3.0-or-later
19 #
20 # Functions for integration testing
21 
22 import os
23 import subprocess
24 import sys
25 import shutil
26 import time
27 from gnunet_pyexpect import pexpect
28 import logging
29 
30 logger = logging.getLogger()
31 handler = logging.StreamHandler()
32 formatter = logging.Formatter(
33  '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'
34 )
35 handler.setFormatter(formatter)
36 logger.addHandler(handler)
37 logger.setLevel(logging.DEBUG)
38 
39 
40 class Check(object):
41  def __init__(self, test):
42  self.fulfilled = False
43  self.conditions = list()
44  self.test = test
45 
46  def add(self, condition):
47  self.conditions.append(condition)
48 
49  def run(self):
50  fulfilled = True
51  pos = 0
52  neg = 0
53  for c in self.conditions:
54  if (False == c.check()):
55  fulfilled = False
56  neg += 1
57  else:
58  pos += 1
59  return fulfilled
60 
61  def run_blocking(self, timeout, pos_cont, neg_cont):
62  execs = 0
63  res = False
64  while ((False == res) and (execs < timeout)):
65  res = self.run()
66  time.sleep(1)
67  execs += 1
68  if ((False == res) and (execs >= timeout)):
69  logger.debug('Check had timeout after %s seconds', str(timeout))
70  neg_cont(self)
71  elif ((False == res) and (execs < timeout)):
72  if (None != neg_cont):
73  neg_cont(self)
74  else:
75  if (None != pos_cont):
76  pos_cont(self)
77  return res
78 
79  def run_once(self, pos_cont, neg_cont):
80  execs = 0
81  res = False
82  res = self.run()
83  if ((res == False) and (neg_cont != None)):
84  neg_cont(self)
85  if ((res == True) and (pos_cont != None)):
86  pos_cont(self)
87  return res
88 
89  def evaluate(self, failed_only):
90  pos = 0
91  neg = 0
92  for c in self.conditions:
93  if (False == c.evaluate(failed_only)):
94  neg += 1
95  else:
96  pos += 1
97  logger.debug(
98  '%s out of %s conditions fulfilled', str(pos), str(pos + neg)
99  )
100  return self.fulfilled
101 
102  def reset(self):
103  self.fulfilled = False
104  for c in self.conditions:
105  c.fulfilled = False
106 
107 
108 class Condition(object):
109  def __init__(self):
110  self.fulfilled = False
111  self.type = 'generic'
112 
113  def __init__(self, type):
114  self.fulfilled = False
115  self.type = type
116 
117  def check(self):
118  return False
119 
120  def evaluate(self, failed_only):
121  if ((self.fulfilled == False) and (failed_only == True)):
122  logger.debug(
123  '%s condition for was %s', str(self.type), str(self.fulfilled)
124  )
125  elif (failed_only == False):
126  logger.debug(
127  '%s condition for was %s', str(self.type), str(self.fulfilled)
128  )
129  return self.fulfilled
130 
131 
133  def __init__(self, file):
134  self.fulfilled = False
135  self.type = 'file'
136  self.file = file
137 
138  def check(self):
139  if (self.fulfilled == False):
140  res = os.path.isfile(self.file)
141  if (res == True):
142  self.fulfilled = True
143  return True
144  else:
145  return False
146  else:
147  return True
148 
149  def evaluate(self, failed_only):
150  if ((self.fulfilled == False) and (failed_only == True)):
151  logger.debug(
152  '%s confition for file %s was %s', str(self.type), self.file,
153  str(self.fulfilled)
154  )
155  elif (failed_only == False):
156  logger.debug(
157  '%s confition for file %s was %s', str(self.type), self.file,
158  str(self.fulfilled)
159  )
160  return self.fulfilled
161 
162 
164  def __init__(self, peer, subsystem, name, value):
165  self.fulfilled = False
166  self.type = 'statistics'
167  self.peer = peer
168  self.subsystem = subsystem
169  self.name = name
170  self.value = str(value)
171  self.result = -1
172 
173  def check(self):
174  if (self.fulfilled == False):
175  self.result = self.peer.get_statistics_value(
176  self.subsystem, self.name
177  )
178  if (self.result == self.value):
179  self.fulfilled = True
180  return True
181  else:
182  return False
183  else:
184  return True
185 
186  def evaluate(self, failed_only):
187  if (self.fulfilled == False):
188  fail = " FAIL!"
189  op = " != "
190  else:
191  fail = ""
192  op = " == "
193  if (((self.fulfilled == False) and (failed_only == True))
194  or (failed_only == False)):
195  logger.debug(
196  '%s %s condition in subsystem %s: %s: (expected/real value) %s %s %s %s',
197  self.peer.id[:4].decode("utf-8"), self.peer.cfg,
198  self.subsystem.ljust(12), self.name.ljust(30), self.value, op,
199  self.result, fail
200  )
201  return self.fulfilled
202 
203 
204 # Specify two statistic values and check if they are equal
206  def __init__(self, peer, subsystem, name, peer2, subsystem2, name2):
207  self.fulfilled = False
208  self.type = 'equalstatistics'
209  self.peer = peer
210  self.subsystem = subsystem
211  self.name = name
212  self.result = -1
213  self.peer2 = peer2
214  self.subsystem2 = subsystem2
215  self.name2 = name2
216  self.result2 = -1
217 
218  def check(self):
219  if (self.fulfilled == False):
220  self.result = self.peer.get_statistics_value(
221  self.subsystem, self.name
222  )
223  self.result2 = self.peer2.get_statistics_value(
224  self.subsystem2, self.name2
225  )
226  if (self.result == self.result2):
227  self.fulfilled = True
228  return True
229  else:
230  return False
231  else:
232  return True
233 
234  def evaluate(self, failed_only):
235  if (((self.fulfilled == False) and (failed_only == True))
236  or (failed_only == False)):
237  logger.debug(
238  '%s %s %s == %s %s %s %s %s', self.peer.id[:4],
239  self.subsystem.ljust(12), self.name.ljust(30), self.result,
240  self.peer2.id[:4], self.subsystem2.ljust(12),
241  self.name2.ljust(30), self.result2
242  )
243  return self.fulfilled
244 
245 
246 class Test(object):
247  def __init__(self, testname, verbose):
248  self.peers = list()
249  self.verbose = verbose
250  self.name = testname
251  srcdir = "../.."
252  gnunet_pyexpect_dir = os.path.join(srcdir, "contrib/scripts")
253  if gnunet_pyexpect_dir not in sys.path:
254  sys.path.append(gnunet_pyexpect_dir)
255  self.gnunetarm = ''
257  if os.name == 'posix':
258  self.gnunetarm = 'gnunet-arm'
259  self.gnunetstatistics = 'gnunet-statistics'
260  self.gnunetpeerinfo = 'gnunet-peerinfo'
261  elif os.name == 'nt':
262  self.gnunetarm = 'gnunet-arm.exe'
263  self.gnunetstatistics = 'gnunet-statistics.exe'
264  self.gnunetpeerinfo = 'gnunet-peerinfo.exe'
265  if os.name == "nt":
266  shutil.rmtree(os.path.join(os.getenv("TEMP"), testname), True)
267  else:
268  shutil.rmtree("/tmp/" + testname, True)
269 
270  def add_peer(self, peer):
271  self.peers.append(peer)
272 
273  def p(self, msg):
274  if (self.verbose == True):
275  print(msg)
276 
277 
278 class Peer(object):
279  def __init__(self, test, cfg_file):
280  if (False == os.path.isfile(cfg_file)):
281  # print(("Peer cfg " + cfg_file + ": FILE NOT FOUND"))
282  logger.debug('Peer cfg %s : FILE NOT FOUND', cfg_file)
283  self.id = "<NaN>"
284  self.test = test
285  self.started = False
286  self.cfg = cfg_file
287 
288  def __del__(self):
289  if (self.started == True):
290  # print('ERROR! Peer using cfg ' + self.cfg + ' was not stopped')
291  logger.debug('ERROR! Peer using cfg %s was not stopped', self.cfg)
292  ret = self.stop()
293  if (False == ret):
294  # print('ERROR! Peer using cfg ' +
295  # self.cfg +
296  # ' could not be stopped')
297  logger.debug(
298  'ERROR! Peer using cfg %s could not be stopped', self.cfg
299  )
300  self.started = False
301  return ret
302  else:
303  return False
304 
305  def start(self):
306  os.unsetenv("XDG_CONFIG_HOME")
307  os.unsetenv("XDG_DATA_HOME")
308  os.unsetenv("XDG_CACHE_HOME")
309  self.test.p("Starting peer using cfg " + self.cfg)
310  try:
311  server = subprocess.Popen([
312  self.test.gnunetarm, '-sq', '-c', self.cfg
313  ])
314  server.communicate()
315  except OSError:
316  # print("Can not start peer")
317  logger.debug('Can not start peer')
318  self.started = False
319  return False
320  self.started = True
321  test = ''
322  try:
323  server = pexpect()
324  server.spawn(
325  None, [self.test.gnunetpeerinfo, '-c', self.cfg, '-s'],
326  stdout=subprocess.PIPE,
327  stderr=subprocess.STDOUT
328  )
329  test = server.read("stdout", 1024)
330  except OSError:
331  # print("Can not get peer identity")
332  logger.debug('Can not get peer identity')
333  test = (test.split(b'`')[1])
334  self.id = test.split(b'\'')[0]
335  return True
336 
337  def stop(self):
338  if (self.started == False):
339  return False
340  self.test.p("Stopping peer using cfg " + self.cfg)
341  try:
342  server = subprocess.Popen([
343  self.test.gnunetarm, '-eq', '-c', self.cfg
344  ])
345  server.communicate()
346  except OSError:
347  # print("Can not stop peer")
348  logger.debug('Can not stop peer')
349  return False
350  self.started = False
351  return True
352 
353  def get_statistics_value(self, subsystem, name):
354  server = pexpect()
355  server.spawn(
356  None, [
357  self.test.gnunetstatistics, '-c', self.cfg, '-q', '-n', name,
358  '-s', subsystem
359  ],
360  stdout=subprocess.PIPE,
361  stderr=subprocess.STDOUT
362  )
363  # server.expect ("stdout", re.compile (r""))
364  test = server.read("stdout", 10240)
365  tests = test.partition(b'\n')
366  # On W32 GNUnet outputs with \r\n, rather than \n
367  if os.name == 'nt' and tests[1] == b'\n' and tests[0][-1] == b'\r':
368  tests = (tests[0][:-1], tests[1], tests[2])
369  tests = tests[0]
370  result = tests.decode("utf-8").strip()
371  logger.debug(
372  'running gnunet-statistics %s for %s "/" %s yields %s', self.cfg,
373  name, subsystem, result
374  )
375  if (result.isdigit() == True):
376  return result
377  else:
378  logger.debug(
379  'Invalid statistics value: %s is not a number!', result
380  )
381  return -1
def add_peer(self, peer)
def run_blocking(self, timeout, pos_cont, neg_cont)
def evaluate(self, failed_only)
def evaluate(self, failed_only)
def evaluate(self, failed_only)
def __init__(self, peer, subsystem, name, peer2, subsystem2, name2)
def evaluate(self, failed_only)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
def __init__(self, test, cfg_file)
def __init__(self, peer, subsystem, name, value)
def get_statistics_value(self, subsystem, name)
def add(self, condition)
def p(self, msg)
def __init__(self, testname, verbose)
def __init__(self, test)
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69
def run_once(self, pos_cont, neg_cont)