def setUp(self, num_nodes=4): assert (num_nodes >= 3), ("num_nodes(%s) must be at least 3." % num_nodes) # clean out any old docker fixtures docker_containers = docker_client.containers.list( all=True, filters={"name": "ramcloud-node-*"}) try: for dc in docker_containers: print("removing container:", dc.name) dc.remove(force=True) docker_network = docker_client.networks.get("ramcloud-net") print("removing network:", docker_network) docker_network.remove() except docker.errors.NotFound as nf: # NotFound is ignored because we're trying to remove the network whether it's there or not pass self.ramcloud_network = make_docker_network('ramcloud-net', '10.0.0.0/16') self.node_image = get_node_image() self.rc_client = ramcloud.RAMCloud() self.node_containers = {} self.ensemble = { i: '10.0.1.{}'.format(i) for i in range(1, num_nodes + 1) } zk_servers = ensemble_servers_string(self.ensemble) external_storage = 'zk:' + external_storage_string(self.ensemble) for i in range(1, num_nodes + 1): hostname = 'ramcloud-node-{}'.format(i) self.node_containers[self.ensemble[i]] = launch_node( 'main', hostname, zk_servers, external_storage, i, self.ensemble[i], self.node_image, self.ramcloud_network) self.rc_client.connect(external_storage, 'main')
def run_ramcloud(): c = ramcloud.RAMCloud() c.connect('basic+udp:host=127.0.0.1,port=11000', 'main') c.create_table(self.schema) t = c.get_table_id(self.schema) try: for i in range(self.operation_count): operation_type = get_operation_type() if operation_type == 'read': k = random.choice(self.keys_tuple) t1 = time() v = c.read(t, k)[0] self.read_time_acc += (time() - t1) self.read_op_acc += 1 if self.keys_vals[k] != v: raise Exception else: k = random.choice(self.keys_tuple) v = random_chars(self.field_length_in_bytes) t1 = time() c.write(t, k, v) self.update_time_acc += (time() - t1) self.update_op_acc += 1 self.keys_vals[k] = v # print operation_type, k, v except Exception as e: print repr(e)
def load_ramcloud(): c = ramcloud.RAMCloud() c.connect('basic+udp:host=127.0.0.1,port=11000', 'main') c.drop_table(self.schema) c.create_table(self.schema) t = c.get_table_id(self.schema) try: for k, v in self.keys_vals.items(): c.write(t, k, v) except Exception as e: print repr(e)
def __init__(self): default_file = "/library/arequests.py" self.afile = default_file self.serverlocator = open("/action/serverlocator", 'r+').read() self.c = ramcloud.RAMCloud() self.SLEEP_TIME = 3 self.header_list = [ "Content-Length", "X-Object-Meta-name", "Content-Disposition", "Content-Encoding", "X-Delete-At", "X-Object-Manifest", "Last-Modified", "ETag", "X-Timestamp", "X-Trans-Id", "X-Openstack-Request-Id", "Date", "X-Static-Large-Object", "X-Symlink-Target", "X-Symlink-Target-Account" ]
def __enter__(self): self.last_unused_port = 12247 import random self.clusterName = ''.join( [chr(random.choice(range(ord('a'), ord('z')))) for c in range(8)]) self.num_hosts = 8 require_hosts(self.num_hosts) self.servers = [] self.cluster = cluster.Cluster() #self.cluster.verbose = True self.cluster.log_level = 'DEBUG' self.cluster.transport = 'infrc' self.cluster.__enter__() try: self.cluster.start_coordinator(hosts[0]) # Hack below allows running with an existing coordinator #self.cluster.coordinator_host = hosts[0] #self.cluster.coordinator_locator = cluster.coord_locator(self.cluster.transport, # self.cluster.coordinator_host) syncArgs = '' if hasattr(getattr(self, self._testMethodName), 'sync'): syncArgs = '--sync' for host in hosts[:self.num_hosts]: self.servers.append( self.cluster.start_server(host, args='--clusterName=%s %s' % (self.clusterName, syncArgs))) # Hack below can be used to use different ports for all servers #self.servers.append( # self.cluster.start_server(host, # port=self.last_unused_port, # args='--clusterName=%s' % self.clusterName)) #self.last_unused_port += 1 self.cluster.ensure_servers() self.rc = ramcloud.RAMCloud() print('%s ... ' % self.cluster.log_subdir, end='', file=sys.stderr) self.rc.set_log_file( os.path.join(self.cluster.log_subdir, 'client.log')) self.rc.connect(self.cluster.coordinator_locator) except: self.cluster.__exit__() raise return self
def setUp(self, num_nodes=4): assert (num_nodes >= 3), ("num_nodes(%s) must be at least 3." % num_nodes) self.ramcloud_network = make_docker_network('ramcloud-net', '10.0.0.0/16') self.node_image = get_node_image() self.rc_client = ramcloud.RAMCloud() self.node_containers = {} self.ensemble = { i: '10.0.1.{}'.format(i) for i in range(1, num_nodes + 1) } zk_servers = ensemble_servers_string(self.ensemble) external_storage = 'zk:' + external_storage_string(self.ensemble) for i in range(1, num_nodes + 1): hostname = 'ramcloud-node-{}'.format(i) self.node_containers[self.ensemble[i]] = launch_node( 'main', hostname, zk_servers, external_storage, i, self.ensemble[i], self.node_image, self.ramcloud_network) self.rc_client.connect(external_storage, 'main')
def main(): parser = optparse.OptionParser() parser.add_option('-n', '--number', dest='smacks', default=10000, type=int) parser.add_option('-C', '--coordinator', dest='coordinatorLocator', default='fast+udp:ip=127.0.0.1,port=12242', type=str) (options, args) = parser.parse_args() smacks = options.smacks print 'Connecting to %s' % options.coordinatorLocator print "Using %d iterations/test" % smacks c = ramcloud.RAMCloud() c.connect(options.coordinatorLocator) c.create_table("test") print "Running cleaner consistency smack" cleaner_consistency_smack(c, smacks) print "Running version smack" version_smack(c, smacks) print "Running rewrite smack" rewrite_smack(c, smacks) print "Running delete smack" delete_smack(c, smacks) print "Running random rewrite/delete smack p = 0.3" rewrite_delete_smack(c, smacks, 0.3) print "Running random rewrite/delete smack p = 0.5" rewrite_delete_smack(c, smacks, 0.5) print "Running random rewrite/delete smack p = 0.8" rewrite_delete_smack(c, smacks, 0.8)
def thread_write(table_id, object_id): print "writing object: {} to table: {}".format(object_id, table_id) rc.write(table_id, object_id, sample_value) print "successfully written!" def thread_delete(table_id, object_id): print "deleting object: {} of table: {}".format(object_id, table_id) rc.delete(table_id, object_id) print "successfully deleted!" if __name__ == "__main__": sample_value = "\0" * 1024 * 1024 rc = ramcloud.RAMCloud() rc.connect(serverLocator='tcp:host={},port=8001'.format(sys.argv[1])) rc.create_table("table1") table_id = rc.get_table_id("table1") timeout = 10 i = 0 while True: i += 1 object_id = "object{}".format(i) t = threading.Thread(target=thread_write, args=(table_id, object_id)) t.start() t.join(timeout=timeout) if t.is_alive(): print "Thread {} timed out!".format(i) break time.sleep(2)
def initialize(self, db_ip, db_port, **args): self.client = ramcloud.RAMCloud() self.service_locator = 'fast+udp:host=' + db_ip \ + ',port=' + str(db_port) + '' self.client.connect(self.service_locator, self.db_name)
def drop_tables(ensemble, table_names): r = ramcloud.RAMCloud() external_storage = 'zk:' + external_storage_string(ensemble) r.connect(external_storage, 'main') for table_name in table_names: r.drop_table(table_name)
def setUp(self): self.ramcloud_network = ctu.make_docker_network( 'ramcloud-net', '10.0.0.0/16') self.node_image = ctu.get_node_image() self.rc_client = ramcloud.RAMCloud() self.node_containers = {}