def start_zeroconf(self):
try:
logging.info("Using bundled zeroconf v%s" % zeroconf_.__version__)
except:
logging.info("Using system zeroconf v%s" % zeroconf.__version__)
self.zeroconf = Zeroconf()
self.service_ident = auth.get_singleton().get_ident()
self.service_name = "%s.%s" % (self.service_ident, SERVICE_TYPE)
# If this process is killed (either kill ot logout), the service
# never gets unregistered, which will prevent remotes from seeing us
# when we come back. Our first service info is to get us back on
# momentarily, and the unregister properly, so remotes get notified.
# Then we'll do it again without the flush property for the real
# connection.
init_info = ServiceInfo(SERVICE_TYPE,
self.service_name,
port=prefs.get_port(),
addresses=[socket.inet_aton(util.get_ip())],
properties={
'hostname': util.get_hostname(),
'type': 'flush'
})
self.zeroconf.register_service(init_info)
time.sleep(3)
self.zeroconf.unregister_service(init_info)
time.sleep(3)
self.info = ServiceInfo(SERVICE_TYPE,
self.service_name,
port=prefs.get_port(),
addresses=[socket.inet_aton(util.get_ip())],
properties={
'hostname': util.get_hostname(),
'type': 'real'
})
self.zeroconf.register_service(self.info)
self.browser = ServiceBrowser(self.zeroconf, SERVICE_TYPE, self)
return False
def run(self):
logging.debug("Server: starting server")
util.initialize_rpc_threadpool()
self.server = grpc.server(futures.ThreadPoolExecutor(
max_workers=prefs.get_server_pool_max_threads()),
options=None)
warp_pb2_grpc.add_WarpServicer_to_server(self, self.server)
pair = auth.get_singleton().get_server_creds()
server_credentials = grpc.ssl_server_credentials((pair, ))
self.server.add_secure_port('[::]:%d' % prefs.get_port(),
server_credentials)
self.server.start()
auth.get_singleton().restart_cert_server()
self.start_zeroconf()
self.server_thread_keepalive.clear()
self.idle_emit("server-started")
# **** RUNNING ****
while not self.server_thread_keepalive.is_set():
self.server_thread_keepalive.wait(10)
# **** STOPPING ****
logging.debug("Server: stopping server")
remote_machines = list(self.remote_machines.values())
for remote in remote_machines:
self.idle_emit("remote-machine-removed", remote)
logging.debug(
"Server: Closing connection to remote machine %s (%s:%d)" %
(remote.display_hostname, remote.ip_address, remote.port))
remote.shutdown()
remote_machines = None
logging.debug("Server: stopping authentication server")
auth.get_singleton().shutdown()
logging.debug("Server: stopping discovery and advertisement")
self.zeroconf.close()
logging.debug("Server: terminating server")
self.server.stop(grace=2).wait()
self.idle_emit("shutdown-complete")
self.server = None
util.global_rpc_threadpool.shutdown(wait=True)
logging.debug("Server: server stopped")
def __init__(self, peers, service_name, app_nick, app_ip, save_location):
super(WarpServer, self).__init__()
self.app_ip = app_ip
self.service_name = service_name
self.port = prefs.get_port()
self.peer_list = peers
self.file_receiver = transfers.FileReceiver(save_location)
self.set_prefs(app_nick, save_location)
self.permission_requests = []
self.serve_forever()
def start_zeroconf(self):
self.zeroconf = Zeroconf()
self.service_ident = auth.get_singleton().get_ident()
self.service_name = "%s.%s" % (self.service_ident, SERVICE_TYPE)
self.info = ServiceInfo(SERVICE_TYPE,
self.service_name,
socket.inet_aton(util.get_ip()),
prefs.get_port(),
properties={'hostname': util.get_hostname()})
self.zeroconf.register_service(self.info)
return False
def start_server(self):
self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
options=None)
warp_pb2_grpc.add_WarpServicer_to_server(self, self.server)
self.server.add_insecure_port('[::]:%d' % prefs.get_port())
self.server.start()
self.emit_server_started()
self.start_discovery_services()
with self.server_runlock:
print("Server running")
self.server_runlock.wait()
print("Server stopping")
self.server.stop(grace=2).wait()
self.emit_shutdown_complete()
self.server = None
def __init__(self):
self.service_name = "warp.__%s__.__%s__._http._tcp.local." % (
util.get_ip(), util.get_hostname())
super(LocalMachine, self).__init__()
GObject.Object.__init__(self)
self.ip_address = util.get_ip()
self.port = prefs.get_port()
self.remote_machines = {}
self.server_runlock = threading.Condition()
self.browser = None
self.zeroconf = None
self.zeroconf = None
self.info = None
self.display_name = GLib.get_real_name()
self.start_server()
def serve_cert_thread(self):
try:
server_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_sock.settimeout(1.0)
server_sock.bind((util.get_ip(), prefs.get_port()))
except socket.error as e:
logging.critical("Could not create udp socket for cert requests: %s" % str(e))
return
while True:
try:
data, address = server_sock.recvfrom(2000)
if data == REQUEST:
cert_data = get_singleton().get_encoded_server_cert()
server_sock.sendto(cert_data, address)
except socket.timeout as e:
if self.exit:
server_sock.close()
break
def on_prefs_changed(self, settings, key, data=None):
new_main_port = prefs.get_port()
new_auth_port = prefs.get_auth_port()
new_iface = prefs.get_preferred_iface()
emit = False
if self.device == None or self.device.get_iface() != new_iface:
self.reload_state()
return
if self.main_port != new_main_port:
self.main_port = new_main_port
emit = True
if self.auth_port != new_auth_port:
self.auth_port = new_auth_port
emit = True
if emit:
self.emit_details_changed()
def __init__(self):
super(Server, self).__init__()
GObject.Object.__init__(self)
self.service_name = None
self.service_ident = None
self.ip_address = util.get_ip()
self.port = prefs.get_port()
self.remote_machines = {}
self.server_runlock = threading.Condition()
self.server = None
self.browser = None
self.zeroconf = None
self.zeroconf = None
self.info = None
self.display_name = GLib.get_real_name()
self.start_server()
def reload_state(self):
if self.nm_client == None:
return
old_online = self.online
new_device = None
new_iface = self.get_preferred_or_default_iface()
if self.device != None:
if new_iface == self.device.get_iface():
return
if new_iface:
new_device = self.nm_client.get_device_by_iface(new_iface)
need_restart = False
if new_device == None or new_iface == None:
self.device = None
self.current_iface = None
self.online = False
need_restart = True
elif new_device != self.device or new_iface != self.current_iface:
self.device = new_device
self.current_iface = new_iface
self.online = self.check_online()
need_restart = True
self.main_port = prefs.get_port()
self.auth_port = prefs.get_auth_port()
if self.initing:
return
if need_restart:
self.emit_state_changed()
logging.debug("Current network changed (%s), connectivity: %s" %
(prefs.get_preferred_iface(), str(self.online)))
def __init__(self):
threading.Thread.__init__(self, name="server-thread")
super(Server, self).__init__()
GObject.Object.__init__(self)
self.service_name = None
self.service_ident = None
self.ip_address = util.get_ip()
self.port = prefs.get_port()
self.remote_machines = {}
self.server_thread_keepalive = threading.Event()
self.server = None
self.browser = None
self.zeroconf = None
self.zeroconf = None
self.info = None
self.display_name = GLib.get_real_name()
self.start()
def start_server(self):
self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
options=None)
warp_pb2_grpc.add_WarpServicer_to_server(self, self.server)
pair = auth.get_singleton().get_server_creds()
server_credentials = grpc.ssl_server_credentials((pair, ))
self.server.add_secure_port('[::]:%d' % prefs.get_port(),
server_credentials)
self.server.start()
auth.get_singleton().restart_cert_server()
self.emit_server_started()
self.start_discovery_services()
with self.server_runlock:
print("Server running")
self.server_runlock.wait()
print("Server stopping")
self.server.stop(grace=2).wait()
self.emit_shutdown_complete()
self.server = None
def start_zeroconf(self):
self.zeroconf = Zeroconf()
self.info = ServiceInfo("_http._tcp.local.", self.service_name,
socket.inet_aton(util.get_ip()),
prefs.get_port(), 0, 0, {}, "somehost.local.")
self.zeroconf.register_service(self.info)
