def _query_routing(self, key, port):
key_request = KeyAddressRequest()
key_request.response_address = self.ut.get_key_address_connect_addr()
key_request.keys.append(key)
key_request.request_id = self._get_request_id()
dst_addr = 'tcp://' + self.elb_addr + ':' + str(port)
send_sock = self.pusher_cache.get(dst_addr)
send_request(key_request, send_sock)
response = recv_response([key_request.request_id],
self.key_address_puller,
KeyAddressResponse)[0]
if response.error != 0:
return []
result = []
for t in response.addresses:
if t.key == key:
for a in t.ips:
result.append(a)
return result
def put_all(self, key, value):
worker_addresses = self._get_worker_address(key, False)
if not worker_addresses:
return False
req, tup = self._prepare_data_request(key)
req.type = PUT
tup.payload, tup.lattice_type = self._serialize(value)
tup.timestamp = 0
req_ids = []
for address in worker_addresses:
req.request_id = self._get_request_id()
send_sock = self.pusher_cache.get(address)
send_request(req, send_sock)
req_ids.append(req.request_id)
responses = recv_response(req_ids, self.response_puller, KeyResponse)
for resp in responses:
tup = resp.tuples[0]
if tup.invalidate:
# reissue the request
self._invalidate_cache(tup.key)
return self.durable_put(key, value)
if tup.error != NO_ERROR:
return False
return True
def put(self, keys, values):
print("Starting put...")
request_ids = []
if type(keys) != list:
keys = [keys]
if type(values) != list:
values = [values]
for key, value in zip(keys, values):
worker_address = self._get_worker_address(key)
if not worker_address:
return False
send_sock = self.pusher_cache.get(worker_address)
print(worker_address)
print(send_sock)
# We pass in a list because the data request preparation can prepare
# multiple tuples
req, tup = self._prepare_data_request([key])
req.type = PUT
request_ids.append(req.request_id)
# PUT only supports one key operations, we only ever have to look at
# the first KeyTuple returned.
tup = tup[0]
tup.payload, tup.lattice_type = self._serialize(value)
print(req)
send_request(req, send_sock)
print("Waiting for put respose...")
responses = recv_response(request_ids, self.response_puller,
KeyResponse)
print("Got a response...")
results = {}
for response in responses:
tup = response.tuples[0]
if tup.invalidate:
self._invalidate_cache(tup.key)
results[tup.key] = (tup.error == NO_ERROR)
return results
def get_all(self, keys):
if type(keys) != list:
keys = [keys]
raise ValueError('`get_all` currently only supports single key' +
' GETs.')
worker_addresses = {}
for key in keys:
worker_addresses[key] = self._get_worker_address(key, False)
# Initialize all KV pairs to 0. Only change a value if we get a valid
# response from the server.
kv_pairs = {}
for key in keys:
kv_pairs[key] = None
for key in keys:
if worker_addresses[key]:
req, _ = self._prepare_data_request(key)
req.type = GET
req_ids = []
for address in worker_addresses[key]:
req.request_id = self._get_request_id()
send_sock = self.pusher_cache.get(address)
send_request(req, send_sock)
req_ids.append(req.request_id)
responses = recv_response(req_ids, self.response_puller, KeyResponse)
for resp in responses:
for tup in resp.tuples:
if tup.invalidate:
self._invalidate_cache(tup.key)
if tup.error == NO_ERROR:
val = self._deserialize(tup)
if kv_pairs[tup.key]:
kv_pairs[tup.key].merge(val)
else:
kv_pairs[tup.key] = val
return kv_pairs
def get(self, keys):
print("Starting get...")
if type(keys) != list:
keys = [keys]
worker_addresses = {}
for key in keys:
worker_addresses[key] = (self._get_worker_address(key))
# Initialize all KV pairs to 0. Only change a value if we get a valid
# response from the server.
kv_pairs = {}
for key in keys:
kv_pairs[key] = None
request_ids = []
for key in worker_addresses:
if worker_addresses[key]:
send_sock = self.pusher_cache.get(worker_addresses[key])
req, _ = self._prepare_data_request([key])
req.type = GET
send_request(req, send_sock)
request_ids.append(req.request_id)
# Wait for all responses to return.
responses = recv_response(request_ids, self.response_puller,
KeyResponse)
for response in responses:
for tup in response.tuples:
if tup.invalidate:
self._invalidate_cache(tup.key)
if tup.error == NO_ERROR:
kv_pairs[tup.key] = self._deserialize(tup)
return kv_pairs