# -*- coding: utf-8 -*-
from __future__ import division, absolute_import, print_function, unicode_literals
#################################################################################################
import json
import socket
from datetime import datetime
from operator import itemgetter
import traceback
import urllib3
from ..helper import LazyLogger
from .credentials import Credentials
from .api import API
#################################################################################################
LOG = LazyLogger(__name__)
CONNECTION_STATE = {
"Unavailable": 0,
"ServerSelection": 1,
"ServerSignIn": 2,
"SignedIn": 3,
}
#################################################################################################
class ConnectionManager(object):
user = {}
server_id = None
def __init__(self, client):
LOG.debug("ConnectionManager initializing...")
self.client = client
self.config = client.config
self.credentials = Credentials()
self.API = API(client)
def revoke_token(self):
LOG.info("revoking token")
self["server"]["AccessToken"] = None
self.credentials.set_credentials(self.credentials.get())
self.config.data["auth.token"] = None
def get_available_servers(self):
LOG.info("Begin getAvailableServers")
# Clone the credentials
credentials = self.credentials.get()
found_servers = self.process_found_servers(self._server_discovery())
if (
not found_servers and not credentials["Servers"]
): # back out right away, no point in continuing
LOG.info("Found no servers")
return list()
servers = list(credentials["Servers"])
# Merges servers we already knew with newly found ones
for found_server in found_servers:
try:
self.credentials.add_update_server(servers, found_server)
except KeyError:
continue
servers.sort(key=itemgetter("DateLastAccessed"), reverse=True)
credentials["Servers"] = servers
self.credentials.set(credentials)
return servers
def login(self, server_url, username, password=None):
if not username:
raise AttributeError("username cannot be empty")
if not server_url:
raise AttributeError("server url cannot be empty")
data = self.API.login(
server_url, username, password
) # returns empty dict on failure
if not data:
LOG.info("Failed to login as `" + username + "`")
return {}
LOG.info("Successfully logged in as %s" % (username))
# TODO Change when moving to database storage of server details
credentials = self.credentials.get()
self.config.data["auth.user_id"] = data["User"]["Id"]
self.config.data["auth.token"] = data["AccessToken"]
for server in credentials["Servers"]:
if server["Id"] == data["ServerId"]:
found_server = server
break
else:
return {} # No server found
found_server["DateLastAccessed"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
found_server["UserId"] = data["User"]["Id"]
found_server["AccessToken"] = data["AccessToken"]
self.credentials.add_update_server(credentials["Servers"], found_server)
info = {"Id": data["User"]["Id"], "IsSignedInOffline": True}
self.credentials.add_update_user(server, info)
self.credentials.set_credentials(credentials)
return data
def connect_to_address(self, address, options={}):
if not address:
return False
address = self._normalize_address(address)
try:
response_url = self.API.check_redirect(address)
if address != response_url:
address = response_url
LOG.info("connectToAddress %s succeeded", address)
server = {
"address": address,
}
server = self.connect_to_server(server, options)
if server is False:
LOG.error("connectToAddress %s failed", address)
return {"State": CONNECTION_STATE["Unavailable"]}
return server
except Exception as error:
LOG.exception(error)
LOG.error("connectToAddress %s failed", address)
return {"State": CONNECTION_STATE["Unavailable"]}
def connect_to_server(self, server, options={}):
LOG.info("begin connectToServer")
try:
result = self.API.get_public_info(server.get("address"))
if not result:
LOG.error("Failed to connect to server: %s" % server.get("address"))
return {"State": CONNECTION_STATE["Unavailable"]}
LOG.info(
"calling onSuccessfulConnection with server %s", server.get("Name")
)
self._update_server_info(server, result)
credentials = self.credentials.get()
return self._after_connect_validated(
server, credentials, result, True, options
)
except Exception as e:
LOG.error(traceback.format_exc())
LOG.error("Failing server connection. ERROR msg: {}".format(e))
return {"State": CONNECTION_STATE["Unavailable"]}
def connect(self, options={}):
LOG.info("Begin connect")
servers = self.get_available_servers()
LOG.info("connect has %s servers", len(servers))
if not (len(servers)): # No servers provided
return {"State": ["ServerSelection"]}
result = self.connect_to_server(servers[0], options)
LOG.debug("resolving connect with result: %s", result)
return result
def jellyfin_token(self): # Called once monitor.py#163
return self.get_server_info(self.server_id)["AccessToken"]
def get_server_info(self, server_id):
if server_id is None:
LOG.info("server_id is empty")
return {}
servers = self.credentials.get()["Servers"]
for server in servers:
if server["Id"] == server_id:
return server
def get_server_address(self, server_id):
return self.get_server_info(server_id or self.server_id).get("address")
def get_public_users(self):
return self.client.jellyfin.get_public_users()
def _server_discovery(self):
MULTI_GROUP = ("<broadcast>", 7359)
MESSAGE = b"who is JellyfinServer?"
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(1.0) # This controls the socket.timeout exception
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
LOG.debug("MultiGroup : %s", str(MULTI_GROUP))
LOG.debug("Sending UDP Data: %s", MESSAGE)
servers = []
try:
sock.sendto(MESSAGE, MULTI_GROUP)
except Exception as error:
LOG.exception(traceback.format_exc())
LOG.exception(error)
return servers
while True:
data = None
addr = None
try:
data, addr = sock.recvfrom(1024) # buffer size
servers.append(json.loads(data))
except socket.timeout:
LOG.info("Found Servers: %s", servers)
return servers
except json.JSONDecodeError:
LOG.warning("Unable to decode %r from %r.", data, addr)
except Exception as e:
LOG.error(traceback.format_exc())
LOG.exception("Error trying to find servers: %s", e)
return servers
def process_found_servers(self, found_servers):
servers = []
for found_server in found_servers:
server = self._convert_endpoint_address_to_manual_address(found_server)
info = {
"Id": found_server["Id"],
"address": server or found_server["Address"],
"Name": found_server["Name"],
}
servers.append(info)
return servers
# TODO: Make IPv6 compatible
def _convert_endpoint_address_to_manual_address(self, info):
if info.get("Address") and info.get("EndpointAddress"):
address = info["EndpointAddress"].split(":")[0]
# Determine the port, if any
parts = info["Address"].split(":")
if len(parts) > 1:
port_string = parts[len(parts) - 1]
try:
address += ":%s" % int(port_string)
return self._normalize_address(address)
except ValueError:
pass
return None
def _normalize_address(self, address):
# TODO: Try HTTPS first, then HTTP if that fails.
if "://" not in address:
address = "http://" + address
# Attempt to correct bad input
url = urllib3.util.parse_url(address.strip())
if url.scheme is None:
url = url._replace(scheme="http")
if url.scheme == "http" and url.port == 80:
url = url._replace(port=None)
if url.scheme == "https" and url.port == 443:
url = url._replace(port=None)
return url.url
def _after_connect_validated(
self, server, credentials, system_info, verify_authentication, options
):
if options.get("enableAutoLogin") is False:
self.config.data["auth.user_id"] = server.pop("UserId", None)
self.config.data["auth.token"] = server.pop("AccessToken", None)
elif verify_authentication and server.get("AccessToken"):
system_info = self.API.validate_authentication_token(server)
if "Status_Code" not in system_info:
self._update_server_info(server, system_info)
self.config.data["auth.user_id"] = server["UserId"]
self.config.data["auth.token"] = server["AccessToken"]
system_info["Status_Code"] = 200
return self._after_connect_validated(
server, credentials, system_info, False, options
)
server["UserId"] = None
server["AccessToken"] = None
system_info["State"] = CONNECTION_STATE["Unavailable"]
return system_info
self._update_server_info(server, system_info)
server["DateLastAccessed"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
self.credentials.add_update_server(credentials["Servers"], server)
self.credentials.set(credentials)
self.server_id = server["Id"]
# Update configs
self.config.data["auth.server"] = server["address"]
self.config.data["auth.server-name"] = server["Name"]
self.config.data["auth.server=id"] = server["Id"]
self.config.data["auth.ssl"] = options.get("ssl", self.config.data["auth.ssl"])
# Connected
return {
"Servers": [server],
"State": (
CONNECTION_STATE["SignedIn"]
if server.get("AccessToken")
else CONNECTION_STATE["ServerSignIn"]
),
}
def _update_server_info(self, server, system_info):
if server is None or system_info is None:
return
server["Name"] = system_info["ServerName"]
server["Id"] = system_info["Id"]
if system_info.get("address"):
server["address"] = system_info["address"]