def add_service(self, zeroconf, type, name):
self._logger.debug(
"Got a browsing result for Zeroconf resolution of {}, resolving...".format(
type
)
)
info = zeroconf.get_service_info(
type, name, timeout=resolve_timeout * 1000
)
if info:
def to_result(info, address):
n = info.name[: -(len(type) + 1)]
p = info.port
self._logger.debug(
"Resolved a result for Zeroconf resolution of {}: {} @ {}:{}".format(
type, n, address, p
)
)
return {
"name": n,
"host": address,
"port": p,
"txt_record": info.properties,
}
for address in map(lambda x: socket.inet_ntoa(x), info.addresses):
result.append(to_result(info, address))
def add_service(self, zeroconf, type, name):
if 'axcend.bridge' in name:
info = zeroconf.get_service_info(type, name)
if info:
address = "{}".format(socket.inet_ntoa(info.address))
print("Service %s added (%s)" % (name, address))
self.directory[name] = {'addr': address, 'port': info.port}
def add_service(self, zeroconf, type, name):
global scanner, sb
info = zeroconf.get_service_info(type, name)
# TODO: verify that info.rs = "eSCL"?
# TODO: verify that info.is = "platen"?
scanner = "http://%s:%d/eSCL/" % (info.server, info.port)
print("Found scanner '%s' at '%s'" % (info.name, info.server))
def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
addr = get_addr_from_info(info)
if addr not in self.found_devices:
dev = self.check_and_create_device(info, addr)
self.found_devices[addr] = dev
def add_service(self, zeroconf: "zeroconf.Zeroconf", type_: str, name: str) -> None:
"""Callback for discovery responses."""
info = zeroconf.get_service_info(type_, name)
addr = get_addr_from_info(info)
if addr not in self.found_devices:
dev = self.check_and_create_device(info, addr)
if dev is not None:
self.found_devices[addr] = dev
def on_service_state_change(zeroconf, service_type, name, state_change):
nonlocal services, handler_done
if state_change is Added:
info = zeroconf.get_service_info(service_type, name)
if name.startswith(service_name):
address = socket.inet_ntoa(info.address)
port = info.port
if get_many or len(services)==0:
services.append([name, address, port])
if not get_many:
handler_done.set()
def add_service(self, zeroconf, type, uuid):
service_info = zeroconf.get_service_info(type, uuid)
print("Service %s added, service info: %s" % (uuid, service_info))
# print("Found mDNS service for cast name {}".format(name))
device_friendly_name = self.get_device_friendly_name_of_uuid(uuid)
if device_friendly_name and device_friendly_name in self.devices:
cast = self.devices[device_friendly_name]
else:
cast = Kodi(service_info)
with self.lock:
self.devices[cast.device_friendly_name] = cast
cast.online = True
self.list_devices()
def on_service_state_change(zeroconf, service_type, name, state_change):
global selected_server
if state_change is ServiceStateChange.Added:
info = zeroconf.get_service_info(service_type, name)
#Don't sync to servers that are lower priority than us,
#we'll just continue using our local time.
try:
if info and sortkey(name)<sortkey(localserver_name):
#No excessive cache sizes
if len(local_ntp_servers)>8192:
local_ntp_servers.popitem(False)
local_ntp_servers[name]=(info.address,info.port,name)
s = local_ntp_servers[sorted(local_ntp_servers.keys(),key=sortkey)[0]]
selected_server = s
except:
logging.exception("")
def add_service(self, zeroconf, service_type, name):
"""Add a Mbed Linux Zeroconf service to a list of services.
Called when a new zeroconf service is discovered.
Ensure it's an 'mbed linux device', notify listeners if it is.
"""
info = zeroconf.get_service_info(service_type, name)
try:
info.properties[MBL_ID]
except KeyError:
return
else:
try:
inet_addr = socket.inet_ntoa(info.address)
except (OSError, TypeError):
inet_addr = info.address
new_dev = device.create_device(name, inet_addr)
if new_dev not in self.devices:
self.devices.append(new_dev)
name = name.split(".{}".format(service_type))
self.notify("{}: {}".format(name[0], new_dev.address))
def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
addr = ipaddress.ip_address(info.address)
print_info(f"{addr} {info.name} {info.server}")
def add_service(self, zeroconf, _type, name):
info = zeroconf.get_service_info(_type, name)
if info:
ident = name.partition(".")[0]
try:
remote_hostname = info.properties[b"hostname"].decode()
except KeyError:
logging.critical(
">>> Discovery: no hostname in service info properties. Is this an old version?"
)
return
remote_ips = util.IPAddresses.new_from_binary_list(info.addresses)
try:
# Check if this is a flush registration to reset the remote server's presence.
if info.properties[b"type"].decode() == "flush":
logging.debug(
">>> Discovery: received flush service info (ignoring): %s (%s:%d)"
% (remote_hostname, remote_ips, info.port))
return
except KeyError:
logging.warning(
"No type in service info properties, assuming this is a real connect attempt"
)
if ident == self.service_ident:
return
try:
api_version = info.properties[b"api-version"].decode()
auth_port = int(info.properties[b"auth-port"].decode())
except KeyError:
api_version = "1"
auth_port = 0
# FIXME: I'm not sure why we still get discovered by other networks in some cases -
# The Zeroconf object has a specific ip it is set to, what more do I need to do?
if not self.netmon.same_subnet(remote_ips):
if remote_ips != self.ips:
logging.debug(
">>> Discovery: service is not on this subnet, ignoring: %s (%s)"
% (remote_hostname, remote_ips))
return
try:
machine = self.remote_machines[ident]
machine.has_zc_presence = True
logging.debug(
">>> Discovery: existing remote: %s (%s:%d)" %
(machine.display_hostname, remote_ips, info.port))
# If the remote truly is the same one (our service info just dropped out
# momentarily), this will end up just retrieving the current cert again.
# If this was a real disconnect we didn't notice, we'll have the new cert
# which we'll need when our supposedly existing connection tries to continue
# pinging. It will fail out and restart the connection loop, and will need
# this updated one.
if not self.remote_registrar.register(
ident, remote_hostname, remote_ips, info.port,
auth_port,
api_version) or self.server_thread_keepalive.is_set():
logging.warning(
"Register failed, or the server was shutting down during registration, ignoring remote %s (%s:%d) auth port: %d"
% (remote_hostname, remote_ips, info.port, auth_port))
return
if machine.status == RemoteStatus.ONLINE:
logging.debug(
">>> Discovery: rejoining existing connect with %s (%s:%d)"
% (machine.display_hostname, remote_ips, info.port))
return
# Update our connect info if it changed.
machine.hostname = remote_hostname
machine.ips = remote_ips
machine.port = info.port
machine.api_version = api_version
except KeyError:
display_hostname = remote_hostname
i = 1
while True:
found = False
for key in self.remote_machines.keys():
remote_machine = self.remote_machines[key]
if remote_machine.display_hostname == display_hostname:
display_hostname = "%s[%d]" % (remote_hostname, i)
found = True
break
i += 1
if not found:
break
logging.debug(">>> Discovery: new remote: %s (%s:%d)" %
(display_hostname, remote_ips, info.port))
machine = remote.RemoteMachine(ident, remote_hostname,
display_hostname, remote_ips,
info.port, self.service_ident,
api_version)
if not self.remote_registrar.register(
ident, remote_hostname, remote_ips, info.port,
auth_port,
api_version) or self.server_thread_keepalive.is_set():
logging.warning(
"Register failed, or the server was shutting down during registration, ignoring remote %s (%s:%d) auth port: %d"
% (remote_hostname, remote_ips, info.port, auth_port))
return
self.remote_machines[ident] = machine
machine.connect("ops-changed", self.remote_ops_changed)
machine.connect("remote-status-changed",
self.remote_status_changed)
self.idle_emit("remote-machine-added", machine)
machine.has_zc_presence = True
machine.shutdown(
) # This does nothing if run more than once. It's here to make sure
# the previous start thread is complete before starting a new one.
# This is needed in the corner case where the remote has gone offline,
# and returns before our Ping loop times out and closes the thread
# itself.
machine.start_remote_thread()
def add_service(self, zeroconf, type, name):
zeroconf.get_service_info(type, name)
service_added.set()
def add_service(self, zeroconf, type, name):
if self.service_info is None:
self.service_info = zeroconf.get_service_info(type, name)
print("service found", self.service_info.name)
def remove_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
if self.server.cb_on_device_removed:
self.server.cb_on_device_removed(info)
def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
addr = str(ipaddress.ip_address(info.address))
if addr not in self.found_devices:
dev = self.check_and_create_device(info, addr)
self.found_devices[addr] = dev
def on_state_change(self, zeroconf, service_type, name, state_change):
info = zeroconf.get_service_info(service_type, name)
if info:
self.deviceDiscovered.emit(name, socket.inet_ntoa(info.address), info)
def on_state_change(self, zeroconf, service_type, name, state_change):
info = zeroconf.get_service_info(service_type, name)
if info:
for addr in info.parsed_addresses():
print(" Addresses: %s" % (addr))
self.deviceDiscovered.emit(name, addr, info)
def add_service(self, zeroconf, type, device):
info = zeroconf.get_service_info(type, device)
device = device.replace('._http._tcp.local.', '')
if info:
logger.trace(f"[Device Scan] found device: {device} added, IP address: {socket.inet_ntoa(info.addresses[0])}")
self.queue.put(Device(device, socket.inet_ntoa(info.addresses[0])))
def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
if info:
addresses = [("%s" % socket.inet_ntoa(a)) for a in info.addresses]
nm = name.split(info.type)[0].rstrip(".")
self.myservices[f"{nm}"] = {"addresses": addresses, "port": info.port, "server": info.server.rstrip("."), "type": info.type}
def update_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
print(f"ZeroConf: Update SERVICE {info}")
addresses = [("%s" % socket.inet_ntoa(a)) for a in info.addresses]
nm = name.split(info.type)[0].rstrip(".")
self.myservices[f"{nm}"] = {"addresses": addresses, "port": info.port, "server": info.server.rstrip("."), "type": info.type}
def add_service(self, zeroconf, type, name):
info = zeroconf.get_service_info(type, name)
if self.server.cb_on_device_added:
self.server.cb_on_device_added(info)
def update_record(self, zeroconf, now, record):
print("ZeroConf: Update DNS RECORD")
info = zeroconf.get_service_info(type, record.name)
addresses = [("%s" % socket.inet_ntoa(a)) for a in info.addresses]
nm = info.name.split(info.type)[0].rstrip(".")
self.myservices[f"{nm}"] = {"addresses": addresses, "port": info.port, "server": info.server.rstrip("."), "type": info.type}
def add_service(self, zeroconf, type, name):
zeroconf.get_service_info(type, name)
service_added.set()
def add_service(self, zeroconf, _type, name):
info = zeroconf.get_service_info(_type, name)
if info:
ident = name.partition(".")[0]
try:
remote_hostname = info.properties[b"hostname"].decode()
except KeyError:
logging.critical(
">>> Discovery: no hostname in service info properties. Is this an old version?"
)
return
remote_ip = socket.inet_ntoa(info.addresses[0])
if not util.same_subnet(remote_ip):
if remote_ip != self.ip_address:
logging.debug(
">>> Discovery: service is not on this subnet, ignoring: %s (%s)"
% (remote_hostname, remote_ip))
return
try:
# Check if this is a flush registration to reset the remote servier's presence.
if info.properties[b"type"].decode() == "flush":
logging.debug(
">>> Discovery: received flush service info (ignoring): %s (%s:%d)"
% (remote_hostname, remote_ip, info.port))
return
except KeyError:
logging.warning(
"No type in service info properties, assuming this is a real connect attempt"
)
if ident == self.service_ident:
return
def check_cert():
# This will block if the remote's warp udp port is closed, until either the port is unblocked
# or we tell the auth object to shutdown, in which case the request timer will cancel and return
# here immediately (with None)
got_cert = auth.get_singleton().retrieve_remote_cert(
ident, remote_hostname, remote_ip, info.port)
if not got_cert:
logging.critical(
">>> Discovery: unable to authenticate with %s (%s:%d)"
% (remote_hostname, remote_ip, info.port))
return False
return True
try:
machine = self.remote_machines[ident]
machine.has_zc_presence = True
logging.debug(">>> Discovery: existing remote: %s (%s:%d)" %
(machine.display_hostname, remote_ip, info.port))
# If the remote truly is the same one (our service info just dropped out
# momentarily), this will end up just retrieving the current cert again.
# If this was a real disconnect we didn't notice, we'll have the new cert
# which we'll need when our supposedly existing connection tries to continue
# pinging. It will fail out and restart the connection loop, and will need
# this updated one.
if not check_cert():
return
if machine.status == RemoteStatus.ONLINE:
logging.debug(
">>> Discovery: rejoining existing connect with %s (%s:%d)"
% (machine.display_hostname, remote_ip, info.port))
return
# Update our connect info if it changed.
machine.hostname = remote_hostname
machine.ip_address = remote_ip
machine.port = info.port
except KeyError:
if not check_cert():
return
display_hostname = remote_hostname
i = 1
while True:
found = False
for key in self.remote_machines.keys():
remote_machine = self.remote_machines[key]
if remote_machine.display_hostname == display_hostname:
display_hostname = "%s[%d]" % (remote_hostname, i)
found = True
break
i += 1
if not found:
break
logging.debug(">>> Discovery: new remote: %s (%s:%d)" %
(display_hostname, remote_ip, info.port))
machine = remote.RemoteMachine(ident, remote_hostname,
display_hostname, remote_ip,
info.port, self.service_ident)
self.remote_machines[ident] = machine
machine.connect("ops-changed", self.remote_ops_changed)
machine.connect("remote-status-changed",
self.remote_status_changed)
self.idle_emit("remote-machine-added", machine)
machine.has_zc_presence = True
logging.debug(
">>> Discovery: closing previous connection for %s (%s:%d)" %
(machine.display_hostname, remote_ip, info.port))
machine.shutdown(
) # This does nothing if run more than once. It's here to make sure
# the previous start thread is complete before starting a new one.
# This is needed in the corner case where the remote has gone offline,
# and returns before our Ping loop times out and closes the thread
# itself.
machine.start_remote_thread()
