from allmydata.interfaces import RIControlClient, IFileNode
from allmydata.util import fileutil, mathutil
from allmydata.immutable import upload
+from allmydata.mutable.publish import MutableData
from twisted.python import log
def get_memory_usage():
def remote_wait_for_client_connections(self, num_clients):
return self.parent.debug_wait_for_client_connections(num_clients)
- def remote_upload_from_file_to_uri(self, filename, convergence):
- uploader = self.parent.getServiceNamed("uploader")
- u = upload.FileName(filename, convergence=convergence)
- d = uploader.upload(u)
- d.addCallback(lambda results: results.uri)
- return d
-
- def remote_download_from_uri_to_file(self, uri, filename):
- filenode = self.parent.create_node_from_uri(uri, name=filename)
- if not IFileNode.providedBy(filenode):
- raise AssertionError("The URI does not reference a file.")
- c = FileWritingConsumer(filename)
- d = filenode.read(c)
- d.addCallback(lambda res: filename)
- return d
-
def remote_speed_test(self, count, size, mutable):
assert size > 8
log.msg("speed_test: count=%d, size=%d, mutable=%s" % (count, size,
# 300ms.
results = {}
sb = self.parent.get_storage_broker()
- everyone = sb.get_all_servers()
+ everyone = sb.get_connected_servers()
num_pings = int(mathutil.div_ceil(10, (len(everyone) * 0.3)))
everyone = list(everyone) * num_pings
d = self._do_one_ping(None, everyone, results)
def _do_one_ping(self, res, everyone_left, results):
if not everyone_left:
return results
- peerid, connection = everyone_left.pop(0)
+ server = everyone_left.pop(0)
+ server_name = server.get_longname()
+ connection = server.get_rref()
start = time.time()
d = connection.callRemote("get_buckets", "\x00"*16)
def _done(ignored):
stop = time.time()
elapsed = stop - start
- if peerid in results:
- results[peerid].append(elapsed)
+ if server_name in results:
+ results[server_name].append(elapsed)
else:
- results[peerid] = [elapsed]
+ results[server_name] = [elapsed]
d.addCallback(_done)
d.addCallback(self._do_one_ping, everyone_left, results)
def _average(res):
averaged = {}
- for peerid,times in results.iteritems():
- averaged[peerid] = sum(times) / len(times)
+ for server_name,times in results.iteritems():
+ averaged[server_name] = sum(times) / len(times)
return averaged
d.addCallback(_average)
return d
d1.addCallback(lambda n: n.get_uri())
elif self.mutable_mode == "upload":
data = open(fn,"rb").read()
- d1 = self._n.overwrite(data)
+ d1 = self._n.overwrite(MutableData(data))
d1.addCallback(lambda res: self._n.get_uri())
else:
up = upload.FileName(fn, convergence=None)
d1 = self.parent.upload(up)
- d1.addCallback(lambda results: results.uri)
+ d1.addCallback(lambda results: results.get_uri())
d1.addCallback(_record_uri, i)
d1.addCallback(_upload_one_file, i+1)
return d1