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 = {}
