7
from dbus.mainloop.glib import DBusGMainLoop
8
from shutil import rmtree
13
from socket import socket
15
CARBON_SERVER = '192.168.1.20'
18
def format_speed_value(value):
19
units = ('bps', 'kbps', 'Mbps', 'Gbps')
25
return "%d %s" % (value, unit)
27
def format_size_value(value):
28
units = ('b', 'KiB', 'MiB', 'GiB', 'TiB')
34
return "%d %s" % (value, unit)
36
def setup_logging(filename=None):
37
root_formatter = logging.Formatter(
38
fmt="%(asctime)s %(process)d: %(message)s")
41
root_handler = logging.FileHandler(filename)
43
root_handler = logging.StreamHandler(sys.stdout)
45
root_handler.setFormatter(root_formatter)
47
instance = logging.getLogger('testing')
48
instance.propagate = False
49
instance.addHandler(root_handler)
50
instance.setLevel(logging.INFO)
53
class SDPerfTest(object):
10
from dbus.mainloop.glib import DBusGMainLoop
11
from shutil import rmtree
13
from u1perftest import PerfTest
14
from u1perftest.util import (format_speed_value,
15
format_size_value, setup_logging)
17
STATSD_SERVER = '192.168.1.20'
19
TESTDIR="syncdaemon-perftest-tmp"
21
class SDPerfTest(PerfTest):
54
22
def __init__(self):
55
23
self.state = 'INIT'
61
self.file_count = None
63
self.bm_upload_timeout = False
65
27
# "namespace" for benchmarking
66
28
self.bm_temp_files = {}
164
126
if 'error' in info and info['error']:
165
127
self.logger.warn("Warning: Upload of %s did not complete properly", path)
166
self.write_result("upload_error", 1)
167
self.write_result("upload_speed", 0)
128
self.metrics.increment("upload_error")
170
131
entry = self.bm_temp_files[path]
179
140
format_size_value(entry['size']), delta,
180
141
format_speed_value(speed))
182
self.write_result("upload_speed", speed)
144
self.metrics.gauge('upload_speed', speed)
184
146
def run(self, options):
185
147
self.logger = setup_logging(options.log)
186
self.result_filename = options.result
187
self.graph_prefix = options.graph_prefix
188
148
self.file_count = int(options.file_count)
189
149
self.file_size = int(options.file_size)
150
self.track_speed = options.track_speed
151
self.track_queues = options.track_queues
153
self._setup_metrics(STATSD_SERVER, STATSD_PORT, options.graph_prefix)
190
155
if options.timeout:
191
156
self.timeout = int(options.timeout)
222
188
def handle_CONNECTED(self):
223
189
self.state = 'PRECLEANUP'
224
if os.path.exists(os.path.join(self.root, "a")):
190
if os.path.exists(os.path.join(self.root, TESTDIR)):
225
191
self.logger.info("Found old test directory. Cleaning up")
226
192
self.cleanup_files()
231
197
def handle_TIMEOUT(self):
232
198
self.state = "ERROR"
233
self.bm_upload_timeout = True
234
199
self.logger.warn("Upload timeout, exiting")
235
self.write_result("timeout_error", 1)
236
self.write_result("upload", 0)
200
self.metrics.increment("error", 1)
237
202
self.quit(error=True)
239
204
def handle_PRECLEANUP_COMPLETED(self):
240
205
self.state = 'UPLOADING'
241
206
self.logger.info("Creating files")
243
path_to_file = 'a/b/c/d/e/f'
208
path_to_file = TESTDIR
244
210
current_path = self.root
247
212
for node in path_to_file.split('/'):
248
213
current_path = os.path.join(current_path, node)
249
214
os.mkdir(current_path)
275
242
self.bm_files_created = time.time()
276
243
self.logger.info("Files created")
278
245
def cleanup_files(self):
279
246
self.logger.info("Moving existing test folder to trash")
281
#paths = self.bm_temp_files.keys()
282
#paths.sort(reverse=True)
285
# logger.debug("Removing %s", entry)
286
# if os.path.isdir(entry):
291
# We will cheat a bit, moving the "a" folder out of Ubuntu One
292
old = os.path.join(self.root, "a")
248
old = os.path.join(self.root, TESTDIR)
293
249
new = os.path.join(self.root, "..", "trash")
295
251
if os.path.exists(new):
312
268
# how much time did it take?
313
269
delta = time.time() - self.bm_files_created
314
self.write_result("upload", delta)
315
self.logger.info("Queue completed in %d seconds", delta)
270
rate = self.file_count / delta
271
if self.track_queues:
272
self.metrics.gauge('meta_queue', rate)
274
self.logger.info("Queue completed in %d seconds (%d requests/s)",
317
277
self.state = 'CLEANUP'
318
278
self.bm_clenup_started = time.time()
324
284
test_delta = time.time() - self.bm_test_started
325
285
cleanup_delta = time.time() - self.bm_clenup_started
326
286
self.logger.info("Cleanup took %d seconds", cleanup_delta)
327
self.write_result("cleanup", cleanup_delta)
287
self.metrics.gauge('cleanup', cleanup_delta)
328
288
self.logger.info("End-to-end test took %d seconds", test_delta)
337
def write_result(self, operation, delta):
341
sock.connect( (CARBON_SERVER,CARBON_PORT) )
343
line = "%s.%s %s %d\n" % (self.graph_prefix,
344
operation, delta, int(time.time()))
347
self.logger.warn("Error writing to graphite: %s", e)
349
fh = open(self.result_filename, "a")
350
fh.write("%s: %s\n" % (operation, delta))
353
297
if __name__ == "__main__":
355
298
parser = optparse.OptionParser(usage="%prog options")
356
299
parser.add_option("--log", dest="log", default=None,
357
300
help="Log file to write to")
358
parser.add_option("--result", dest="result",
359
default="/tmp/result.txt",
360
help="File to write benchmark results to")
361
302
parser.add_option("--graph-prefix", dest="graph_prefix",
362
303
default="e2eperftest",
363
304
help="Prefix for Graphite")
364
306
parser.add_option("--file-size", dest="file_size",
366
308
help="Size of the files created")
367
310
parser.add_option("--file-count", dest="file_count",
369
312
help="Amount of the files to create")
314
parser.add_option("--track-speed", dest="track_speed",
315
default=False, action="store_true",
316
help="Calculate transfer speed info")
317
parser.add_option("--track-queues", dest="track_queues",
318
default=False, action="store_true",
319
help="Calculate queue processing speed")
370
321
parser.add_option("--timeout", dest="timeout",
372
323
help="Test times out after this number of seconds.")