def discover(self, timeout_secs=0.3, num_repeats=3):
self.initialize_socket(timeout_secs)
msg = GetService(BROADCAST_MAC, self.source_id, seq_num=0, payload={}, ack_requested=False, response_requested=True)
responses = []
addr_seen = []
num_devices_seen = 0
attempts = 0
while attempts < num_repeats:
sent = False
start_time = time()
timedout = False
while not timedout:
if not sent:
self.sock.sendto(msg.packed_message, (UDP_BROADCAST_IP, UDP_BROADCAST_PORT))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
response.ip_addr = ip_addr
if self.verbose:
print("RECV: " + str(response))
if type(response) == StateService and response.origin == 1 and response.source_id == self.source_id:
if response.target_addr not in addr_seen and response.target_addr != BROADCAST_MAC:
addr_seen.append(response.target_addr)
num_devices_seen += 1
responses.append(response)
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
self.close_socket()
return responses
def broadcast_with_resp(self,
msg_type,
response_type,
payload={},
timeout_secs=DEFAULT_TIMEOUT,
max_attempts=DEFAULT_ATTEMPTS):
self.initialize_socket(timeout_secs)
if response_type == Acknowledgement:
msg = msg_type(BROADCAST_MAC,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=True,
response_requested=False)
else:
msg = msg_type(BROADCAST_MAC,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=False,
response_requested=True)
responses = []
addr_seen = []
num_devices_seen = 0
attempts = 0
while (self.num_devices == None or num_devices_seen < self.num_devices
) and attempts < max_attempts:
sent = False
start_time = time()
timedout = False
while (self.num_devices == None
or num_devices_seen < self.num_devices) and not timedout:
if not sent:
for ip_addr in UDP_BROADCAST_IP_ADDRS:
self.sock.sendto(msg.packed_message,
(ip_addr, UDP_BROADCAST_PORT))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
response.ip_addr = ip_addr
if self.verbose:
print("RECV: " + str(response))
if type(
response
) == response_type and response.source_id == self.source_id:
if response.target_addr not in addr_seen and response.target_addr != BROADCAST_MAC:
addr_seen.append(response.target_addr)
num_devices_seen += 1
responses.append(response)
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
self.close_socket()
return responses
def req_with_resp(self,
msg_type,
response_type,
payload={},
timeout_secs=DEFAULT_TIMEOUT,
max_attempts=DEFAULT_ATTEMPTS):
success = False
device_response = None
self.initialize_socket(timeout_secs)
if response_type == Acknowledgement:
msg = msg_type(self.mac_addr,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=True,
response_requested=False)
else:
msg = msg_type(self.mac_addr,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=False,
response_requested=True)
response_seen = False
attempts = 0
while not response_seen and attempts < max_attempts:
sent = False
start_time = time()
timedout = False
while not response_seen and not timedout:
if not sent:
self.sock.sendto(msg.packed_message,
(UDP_BROADCAST_IP, self.port))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
if self.verbose:
print("RECV: " + str(response))
if type(response) == response_type:
if response.origin == 1 and response.source_id == self.source_id and response.target_addr == self.mac_addr:
response_seen = True
device_response = response
self.ip_addr = ip_addr
success = True
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
if not success:
raise IOError(
"WorkflowException: Did not receive {} in response to {}".
format(str(response_type), str(msg_type)))
self.close_socket()
return device_response
def req_with_resp(
self, msg_type, response_type, payload={}, timeout_secs=DEFAULT_TIMEOUT, max_attempts=DEFAULT_ATTEMPTS
):
success = False
device_response = None
self.initialize_socket(timeout_secs)
if response_type == Acknowledgement:
msg = msg_type(
self.mac_addr, self.source_id, seq_num=0, payload=payload, ack_requested=True, response_requested=False
)
else:
msg = msg_type(
self.mac_addr, self.source_id, seq_num=0, payload=payload, ack_requested=False, response_requested=True
)
response_seen = False
attempts = 0
while not response_seen and attempts < max_attempts:
sent = False
start_time = time()
timedout = False
while not response_seen and not timedout:
if not sent:
self.sock.sendto(msg.packed_message, (UDP_BROADCAST_IP, self.port))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
if self.verbose:
print("RECV: " + str(response))
if type(response) == response_type:
if (
response.origin == 1
and response.source_id == self.source_id
and response.target_addr == self.mac_addr
):
response_seen = True
device_response = response
self.ip_addr = ip_addr
success = True
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
if not success:
self.close_socket()
raise IOError(
"WorkflowException: Did not receive {} in response to {}".format(str(response_type), str(msg_type))
)
else:
self.close_socket()
return device_response
def broadcast_with_resp(self, msg_type, response_type, payload={}, timeout_secs=DEFAULT_TIMEOUT, max_attempts=DEFAULT_ATTEMPTS):
if self.lights == None:
self.get_lights()
success = False
self.initialize_socket(timeout_secs)
if response_type == Acknowledgement:
msg = msg_type(BROADCAST_MAC, self.source_id, seq_num=0, payload=payload, ack_requested=True, response_requested=False)
else:
msg = msg_type(BROADCAST_MAC, self.source_id, seq_num=0, payload=payload, ack_requested=False, response_requested=True)
responses = []
addr_seen = []
num_devices_seen = 0
attempts = 0
while num_devices_seen < self.num_devices and attempts < max_attempts:
sent = False
start_time = time()
timedout = False
while num_devices_seen < self.num_devices and not timedout:
if not sent:
self.sock.sendto(msg.packed_message, (UDP_BROADCAST_IP, UDP_BROADCAST_PORT))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
response.ip_addr = ip_addr
if self.verbose:
print("RECV: " + str(response))
if type(response) == response_type and response.origin == 1 and response.source_id == self.source_id:
if response.target_addr not in addr_seen and response.target_addr != BROADCAST_MAC:
addr_seen.append(response.target_addr)
num_devices_seen += 1
responses.append(response)
if num_devices_seen >= self.num_devices:
success = True
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
if success == False:
self.close_socket()
raise WorkflowException("Did not receive {} in response to {}".format(str(response_type), str(msg_type)))
else:
self.close_socket()
return responses
def discover(self, timeout_secs=0.3, num_repeats=3):
self.initialize_socket(timeout_secs)
msg = GetService(BROADCAST_MAC,
self.source_id,
seq_num=0,
payload={},
ack_requested=False,
response_requested=True)
responses = []
addr_seen = []
num_devices_seen = 0
attempts = 0
while attempts < num_repeats:
sent = False
start_time = time()
timedout = False
while not timedout:
if not sent:
self.sock.sendto(msg.packed_message,
(UDP_BROADCAST_IP, UDP_BROADCAST_PORT))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
response.ip_addr = ip_addr
if self.verbose:
print("RECV: " + str(response))
if type(
response
) == StateService and response.origin == 1 and response.source_id == self.source_id:
if response.target_addr not in addr_seen and response.target_addr != BROADCAST_MAC:
addr_seen.append(response.target_addr)
num_devices_seen += 1
responses.append(response)
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
self.close_socket()
return responses
def broadcast_with_resp(self,
msg_type,
response_type,
payload={},
timeout_secs=DEFAULT_TIMEOUT,
max_attempts=DEFAULT_ATTEMPTS):
if self.lights == None:
self.get_lights()
success = False
self.initialize_socket(timeout_secs)
if response_type == Acknowledgement:
msg = msg_type(BROADCAST_MAC,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=True,
response_requested=False)
else:
msg = msg_type(BROADCAST_MAC,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=False,
response_requested=True)
responses = []
addr_seen = []
num_devices_seen = 0
attempts = 0
while num_devices_seen < self.num_devices and attempts < max_attempts:
sent = False
start_time = time()
timedout = False
while num_devices_seen < self.num_devices and not timedout:
if not sent:
self.sock.sendto(msg.packed_message,
(self._broadcast_ip, UDP_BROADCAST_PORT))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = self.sock.recvfrom(1024)
response = unpack_lifx_message(data)
response.ip_addr = ip_addr
if self.verbose:
print("RECV: " + str(response))
if type(
response
) == response_type and response.origin == 1 and response.source_id == self.source_id:
if response.target_addr not in addr_seen and response.target_addr != BROADCAST_MAC:
addr_seen.append(response.target_addr)
num_devices_seen += 1
responses.append(response)
if num_devices_seen >= self.num_devices:
success = True
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
if success == False:
raise WorkflowException(
"Did not receive {} in response to {}".format(
str(response_type), str(msg_type)))
self.close_socket()
return responses
def req_with_resp(self,
msg_type,
response_type,
payload={},
timeout_secs=DEFAULT_TIMEOUT,
max_attempts=DEFAULT_ATTEMPTS):
# Need to put error checking here for aguments
if type(response_type) != type([]):
response_type = [response_type]
success = False
device_response = None
socket_id = self.initialize_socket(timeout_secs)
sock = self.socket_table[socket_id]
if len(response_type) == 1 and Acknowledgement in response_type:
msg = msg_type(self.mac_addr,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=True,
response_requested=False)
else:
msg = msg_type(self.mac_addr,
self.source_id,
seq_num=0,
payload=payload,
ack_requested=False,
response_requested=True)
response_seen = False
attempts = 0
while not response_seen and attempts < max_attempts:
sent = False
start_time = time()
timedout = False
while not response_seen and not timedout:
if not sent:
if self.ip_addr:
sock.sendto(msg.packed_message,
(self.ip_addr, self.port))
else:
for ip_addr in UDP_BROADCAST_IP_ADDRS:
sock.sendto(msg.packed_message,
(ip_addr, self.port))
sent = True
if self.verbose:
print("SEND: " + str(msg))
try:
data, (ip_addr, port) = sock.recvfrom(1024)
response = unpack_lifx_message(data)
if self.verbose:
print("RECV: " + str(response))
if type(response) in response_type:
if response.source_id == self.source_id and (
response.target_addr == self.mac_addr
or response.target_addr == BROADCAST_MAC):
response_seen = True
device_response = response
self.ip_addr = ip_addr
success = True
except timeout:
pass
elapsed_time = time() - start_time
timedout = True if elapsed_time > timeout_secs else False
attempts += 1
if not success:
self.close_socket(socket_id)
raise WorkflowException(
"WorkflowException: Did not receive {} from {} (Name: {}) in response to {}"
.format(str(response_type), str(self.mac_addr),
str(self.label), str(msg_type)))
else:
self.close_socket(socket_id)
return device_response
