def build(keys, hostname='localhost', port=8123, tls=False):
m = messages.Command()
m.header.messageType = messages.Command.PEER2PEERPUSH
m.body.p2pOperation.peer.hostname = hostname
m.body.p2pOperation.peer.port = port
m.body.p2pOperation.peer.tls = tls
operations = []
for k in keys:
op = None
if isinstance(k, str):
op = messages.Command.P2POperation.Operation(key=k)
elif isinstance(k, common.P2pOp):
op = messages.Command.P2POperation.Operation(key=k.key)
if k.version:
op.version = k.version
if k.newKey:
op.newKey = k.newKey
if k.force:
op.force = k.force
operations.append(op)
m.body.p2pOperation.operation.extend(operations)
return (m, None)
def build(firmware):
m = messages.Command()
m.header.messageType = messages.Command.SETUP
m.body.setup.firmwareDownload = True
return (m, firmware)
def network_recv(self):
"""
Receives a raw Kinetic message from the network.
return: the message received
"""
(m, value) = self._recv_delimited_v2()
if self.debug:
print m
if m.authType == messages.Message.HMACAUTH:
if m.hmacAuth.identity == self.identity:
hmac = calculate_hmac(self.secret, m.commandBytes)
if not hmac == m.hmacAuth.hmac:
raise Exception('Hmac does not match')
else:
raise Exception('Wrong identity received!')
resp = messages.Command()
resp.ParseFromString(m.commandBytes)
if self.debug:
print resp
# update connectionId to whatever the drive said.
if resp.header.connectionID:
self.connection_id = resp.header.connectionID
return (m, resp, value)
def _network_recv(self):
"""
Receive Kinetic message, response, and value from network (Kinetic device).
Args:
Returns:
Message (message header), Command (proto response), String (Value)
"""
msg = self._fast_read(9)
magic, proto_ln, value_ln = struct.unpack_from(">bii", buffer(msg))
# read proto message
raw_proto = self._fast_read(proto_ln)
value = ''
if value_ln > 0:
value = self._fast_read(value_ln)
msg = kinetic_pb2.Message()
msg.ParseFromString(str(raw_proto))
cmd = kinetic_pb2.Command()
cmd.ParseFromString(msg.commandBytes)
# update connectionId to whatever the drive said.
if cmd.header.connectionID:
self._connection_id = cmd.header.connectionID
return msg, cmd, value
def build(version):
m = messages.Command()
m.header.messageType = messages.Command.SETUP
m.body.setup.newClusterVersion = version
return (m, None)
def _buildMessage(messageType, key, data=None, version='', new_version='',
force=False, tag=None, algorithm=None, synchronization=None):
m = messages.Command()
m.header.messageType = messageType
if len(key) > common.MAX_KEY_SIZE: raise common.KineticClientException("Key exceeds maximum size of {0} bytes.".format(common.MAX_KEY_SIZE))
m.body.keyValue.key = key
if data:
if len(data) > common.MAX_VALUE_SIZE: raise common.KineticClientException("Value exceeds maximum size of {0} bytes.".format(common.MAX_VALUE_SIZE))
if tag and algorithm:
m.body.keyValue.tag = tag
m.body.keyValue.algorithm = algorithm
elif messageType == messages.Command.PUT:
m.body.keyValue.tag = 'l337'
m.body.keyValue.algorithm = 1 # nacho: should be change to a value over 100
if synchronization:
m.body.keyValue.synchronization = synchronization
if version:
m.body.keyValue.dbVersion = version
if new_version:
m.body.keyValue.newVersion = new_version
if force:
m.body.keyValue.force = True
return (m,data)
def _client_error_callback(self, status_code, status_msg):
msg = kinetic_pb2.Message()
msg.authType = kinetic_pb2.Message.INVALID_AUTH_TYPE
cmd = kinetic_pb2.Command()
cmd.status.statusMessage = "client reported."+status_msg
cmd.status.code = status_code
cmd.header.messageType = kinetic_pb2.Command.INVALID_MESSAGE_TYPE
self._on_response(msg, cmd, "")
def build():
m = messages.Command()
m.header.messageType = messages.Command.PINOP
m.body.pinOp.pinOpType = messages.Command.PinOperation.SECURE_ERASE_PINOP
return (m, None)
def check_connection(self, *args, **kwargs):
if not self.is_connected and self.auto_reconnect_count < 1:
self._client_error_callback(kinetic_pb2.Command.Status.NOT_ATTEMPTED, "call connect() before the operation")
else:
self._queue_semaphore.acquire()
command_start_time = time.time()
cmd = kinetic_pb2.Command()
value, message_build_time = func(self, cmd=cmd, *args, **kwargs)
self._network_send(None, cmd, value, command_start_time, message_build_time)
def build(types, device=None):
m = messages.Command()
m.header.messageType = messages.Command.GETLOG
log = m.body.getLog
log.types.extend(types) #type is actually a repeatable field
if device:
log.device.name = device
return (m, None)
def build(keys, hostname='localhost', port=8123, **kwargs):
m = messages.Command()
m.header.messageType = messages.Command.PEER2PEERPUSH
m.body.p2pOperation.peer.hostname = hostname
m.body.p2pOperation.peer.port = port
m.body.p2pOperation.operation.extend([
messages.Command.P2POperation.Operation(key=key) for key in keys
])
return (m, None)
def build(keys, targets):
m = messages.Command()
m.header.messageType = messages.Command.PEER2PEERPUSH
m.body.p2pOperation.peer.hostname = targets[0].hostname
m.body.p2pOperation.peer.port = targets[0].port
if targets[0].tls:
m.body.p2pOperation.peer.tls = targets[0].tls
def rec(targets, op):
if len(targets) > 0:
target = targets[0]
op.p2pop.peer.hostname = target.hostname
op.p2pop.peer.port = target.port
if target.tls:
op.p2pop.peer.tls = target.tls
innerop = messages.Command.P2POperation.Operation(key=op.key)
if op.version:
innerop.version = op.version
if op.force:
innerop.force = op.force
rec(targets[1:],innerop)
op.p2pop.operation.extend([innerop])
warn_newKey = False
operations = []
for k in keys:
op = None
if isinstance(k, str):
op = messages.Command.P2POperation.Operation(key=k)
elif isinstance(k, common.P2pOp):
op = messages.Command.P2POperation.Operation(key=k.key)
if k.version:
op.version = k.version
if k.newKey:
warn_newKey = True
if k.force:
op.force = k.force
rec(targets[1:],op)
operations.append(op)
if warn_newKey:
LOG.warn("Setting new key on piped push is not currently supported.")
m.body.p2pOperation.operation.extend(operations)
return (m, None)
def pin_operation(pin=None, **kwargs):
"""
PIN AUTH operations
Args:
pin(str): Pin for the pin based commands.
"""
if not self.is_connected and self.auto_reconnect_count < 1:
self._client_error_callback(kinetic_pb2.Command.Status.NOT_ATTEMPTED, "call connect() before the operation")
else:
self._queue_semaphore.acquire()
command_start_time = time.time()
m = kinetic_pb2.Message()
m.authType = kinetic_pb2.Message.PINAUTH
if pin is not None:
m.pinAuth.pin = pin
cmd = kinetic_pb2.Command()
cmd, _, message_build_time = self._build_message(cmd, kinetic_pb2.Command.PINOP, **kwargs)
cmd.body.pinOp.pinOpType = pin_operation.__number__
self._network_send(m, cmd, "", command_start_time, message_build_time)
def build(startKey=None, endKey=None, startKeyInclusive=True, endKeyInclusive=True, maxReturned=200):
if not startKey:
startKey = ''
if not endKey:
endKey = '\xFF' * common.MAX_KEY_SIZE
if len(startKey) > common.MAX_KEY_SIZE: raise common.KineticClientException("Start key exceeds maximum size of {0} bytes.".format(common.MAX_KEY_SIZE))
if len(endKey) > common.MAX_KEY_SIZE: raise common.KineticClientException("End key exceeds maximum size of {0} bytes.".format(common.MAX_KEY_SIZE))
m = messages.Command()
m.header.messageType = messages.Command.GETKEYRANGE
kr = m.body.range
kr.startKey = startKey
kr.endKey = endKey
kr.startKeyInclusive = startKeyInclusive
kr.endKeyInclusive = endKeyInclusive
kr.maxReturned = maxReturned
return (m, None)
def build(acls=None, old_erase_pin=None, new_erase_pin=None, old_lock_pin=None, new_lock_pin=None):
m = messages.Command()
m.header.messageType = messages.Command.SECURITY
op = m.body.security
if acls:
proto_acls = []
for acl in acls:
proto_acl = messages.Command.Security.ACL(identity=acl.identity,
key=acl.key,
hmacAlgorithm=acl.hmacAlgorithm,
maxPriority=acl.max_priority)
proto_domains = []
for domain in acl.domains:
proto_d = messages.Command.Security.ACL.Scope(
TlsRequired=domain.tlsRequired)
proto_d.permission.extend(domain.roles)
if domain.offset:
proto_d.offset = domain.offset
if domain.value:
proto_d.value = domain.value
proto_domains.append(proto_d)
proto_acl.scope.extend(proto_domains)
proto_acls.append(proto_acl)
op.acl.extend(proto_acls)
if not old_lock_pin is None: op.oldLockPIN = old_lock_pin
if not new_lock_pin is None: op.newLockPIN = new_lock_pin
if not old_erase_pin is None: op.oldErasePIN = old_erase_pin
if not new_erase_pin is None: op.newErasePIN = new_erase_pin
return (m, None)
def proto_operation(key=None, value=None, batch_flag=False, **kwargs):
"""
HMAC AUTH operations.
Args:
key(str): Entry key of kinetic object.
value(str): The value, during a put operation, that is being sent over.
The kinetic message and the value are sent in different packets.
batch_flag(bool): Flag that denotes if a command is a batch command or not.
Also used to indicate to the client whether to wait for a response or not for a START_BATCH, END_BATCH,
or ABORT_BATCH.
"""
if not self.is_connected and self.auto_reconnect_count < 1:
self._client_error_callback(kinetic_pb2.Command.Status.NOT_ATTEMPTED, "call connect() before the operation")
else:
if not batch_flag:
self._queue_semaphore.acquire()
command_start_time = time.time()
cmd = kinetic_pb2.Command()
cmd, value, message_build_time = \
self._build_message(cmd, proto_operation.__number__, key=key, value=value, **kwargs)
self._network_send(None, cmd, value, command_start_time, message_build_time, batch_flag)
def build(self, *args, **kwargs):
self.m = messages.Command()
if 'timeout' in kwargs:
self.m.header.timeout = kwargs['timeout']
del kwargs['timeout']
if 'priority' in kwargs:
self.m.header.priority = kwargs['priority']
del kwargs['priority']
if 'early_exit' in kwargs:
self.m.header.earlyExit = kwargs['early_exit']
del kwargs['early_exit']
if 'time_quanta' in kwargs:
self.m.header.TimeQuanta = kwargs['time_quanta']
del kwargs['time_quanta']
if 'batch_id' in kwargs:
self.m.header.batchID = kwargs['batch_id']
del kwargs['batch_id']
return self._build(*args, **kwargs)
def build():
m = messages.Command()
m.header.messageType = messages.Command.NOOP
return (m, None)
def build():
m = messages.Command()
m.header.messageType = messages.Command.FLUSHALLDATA
return (m, None)
