def __init__(self, address, *args, address_size=4, counter_size=3, meta=None, buffer_size=10, **kwargs):
self.meta = meta
self.address = address
self.address_size = address_size
self.promiscuous_address = bytes(address_size)
self.address_scheme = attr("address", address_size, type="b")
self.id_address_scheme = attr("sender_address", address_size, type="b")
self.counter_scheme = attr("counter", counter_size, type=INT)
self.orchestrator = None
self.scheduler = None
self.channel_id = None
self.immediate_send = None
self.immediate_recv = None
self.counter = False
self.identified = False
self.ack = False
self.counter_send_index = None
self.counter_recv_index = None
self.packet_id = None
self.ack_request_index = None
self.ack_await_index = None
self.send_ack = RingBuffer(buffer_size)
self.next_ack_id = None
self.ack_callback = None
def __init__(self, address, routing_table, address_size=4, meta=None, buffer_size=10):
super().__init__(address, address_size=address_size, meta=meta, buffer_size=buffer_size)
self.routing_table = routing_table
self.channel = None
self.headers = (attr("intermediate_address", self.address_size, type="b"),
attr("dest_address", self.address_size, type="b"),
attr("origin_address", self.address_size, type="b")
)
def __init__(self,
address,
state,
default_data,
flagged_attributes,
i_min,
i_max,
is_consistent_callback,
update,
*args,
redundancy_const=1,
versioning=True,
version_id_size=2,
meta=None,
buffer_size=10,
**kwargs):
super().__init__(address,
*args,
meta=meta,
buffer_size=buffer_size,
**kwargs)
self.last_flagged_data = None
self.state = state # State supplied which can be modified (not reassigned)
self.default_data = default_data # The default packet data sent
self.flagged_attributes = flagged_attributes # The parts of the packet which are observed for change
self.I_MIN = i_min / 1000
self.I_MAX = i_max / 1000
self.REDUNDANCY_CONST = redundancy_const
self.is_consistent_callback = is_consistent_callback # Callback to test data consistency
self.update = update # Callback to update the default data
self.interval_length = None
self.transmit_time = None
self.counter = None
self.versioning = versioning
self.version_id_size = version_id_size
self.version_id_scheme = attr("version_id", version_id_size, type=INT)
self.version_id = 0
self.interval_alarm = None
self.transmit_alarm = None
self.cancel_flag = threading.Event()
self.uplink_arg = None
self.downlink_arg = None
self.channel = None
def __init__(self, target, enc_key, dec_key, *args, **kwargs):
super().__init__(target, *args, **kwargs)
self.target = target
self.enc_key = enc_key
self.dec_key = dec_key
self.digest_mode = sha256
# TODO: configure mac size according to digest mode
self.mac_size = 32
self.hmac_attr_scheme = attr("hmac", self.mac_size)
self.encoding_scheme = None
def __init__(self, target, enc_key, dec_key, *args, **kwargs):
super().__init__(target, *args, **kwargs)
# Account for addition of initialization vector
self.target = target
self.enc_key = enc_key
self.dec_key = dec_key
self.iv_layer = max(target)
self.encoding_scheme = None
self.decoding_scheme = None
self.ctr_scheme = attr("ctr", 16)
def init_connection(
self,
socket,
channel_id,
serializer,
orchestrator,
scheduler,
*args,
identified=False,
ack=False,
ack_callback=None,
counter=False,
channel=None,
mode=None,
schedule_callback=None,
recv_buffer_size=None,
**kwargs
):
self.orchestrator = orchestrator
self.scheduler = scheduler
self.channel_id = channel_id
self.counter = counter
self.identified = identified
self.ack = ack
if counter:
self.identified = True
serializer.add_layer(headers=[self.counter_scheme])
self.counter_send_index = {0: 0}
self.counter_recv_index = {0: 0}
if ack:
self.identified = True
self.ack_await_index = {}
self.ack_callback = ack_callback
ack_type_scheme = attr("ack_type", 1, type=INT)
packet_id_scheme = attr("packet_id", 1, type=INT)
id_await_scheme = attr("ack_await_id", 1, type=INT)
serializer.add_layer(headers=[packet_id_scheme, ack_type_scheme, id_await_scheme])
# Generate starting id value
self.packet_id = int.from_bytes(os.urandom(1), "big")
if ack | counter | identified:
serializer.add_layer(headers=[self.id_address_scheme])
immediate_transmit = self.scheduler.set_connection_parameters(
socket,
channel_id,
*args,
mode=mode,
schedule_callback=schedule_callback,
recv_buffer_size=recv_buffer_size,
**kwargs
)
(self.immediate_send, self.immediate_recv) = immediate_transmit if immediate_transmit else (None, None)