def __init__(self, url, username, password, app_name, legacy_auth,
api_version):
parsed = urlparse(url)
self.port = parsed.port if parsed.port else \
443 if parsed.scheme == 'https' else 80
base_url = parsed.scheme + '://' + parsed.hostname
self.connection = libsonic.Connection(base_url,
username,
password,
self.port,
parsed.path + '/rest',
appName=app_name,
legacyAuth=legacy_auth,
apiVersion=api_version)
self.url = url + '/rest'
self.username = username
self.password = password
logger.info(
'Connecting to subsonic server on url %s as user %s, API version %s'
% (url, username, api_version))
try:
self.connection.ping()
except Exception as e:
logger.error('Unable to reach subsonic server: %s' % e)
exit()
def __init__(self, hostname, port, username, password, ssl, context, legacy_auth):
super(SubsonicRemoteClient, self).__init__()
if not (hostname and port and username and password):
logger.error('Subsonic API settings are not fully defined: %s %s %s %s %s' % (hostname, port, username, password, ssl))
else:
self.api_hostname = hostname
self.api_port = port
self.api_user = username
self.api_pass = password
if ssl:
self.api_hostname = "https://" + hostname
else:
self.api_hostname = "http://" + hostname
if context:
self.api_context = context + "/rest"
else:
self.api_context = "/rest"
self.api = libsonic.Connection(self.api_hostname, self.api_user, self.api_pass, port=int(self.api_port), serverPath=self.api_context, legacyAuth=legacy_auth)
logger.info('Connecting to Subsonic library %s:%s as user %s', self.api_hostname, self.api_port, self.api_user)
try:
self.api.ping()
except Exception as e:
logger.error('Subsonic Authentication error: %s' % e)
exit()
def __init__(self, url, username, password, app_name, legacy_auth,
api_version):
parsed = urlparse(url)
self.port = (parsed.port if parsed.port else
443 if parsed.scheme == "https" else 80)
base_url = parsed.scheme + "://" + parsed.hostname
self.connection = libsonic.Connection(
base_url,
username,
password,
self.port,
parsed.path + "/rest",
appName=app_name,
legacyAuth=legacy_auth,
apiVersion=api_version,
)
self.url = url + "/rest"
self.username = username
self.password = password
logger.info(
f"Connecting to subsonic server on url {url} as user {username}, "
f"API version {api_version}")
try:
self.connection.ping()
except Exception as e:
logger.error("Unable to reach subsonic server: %s" % e)
exit()
def __init__(self, host, user, passwd, port=443):
self._host = host
self._user = user
self._port = port
self._salt = md5(os.urandom(100)).hexdigest()[:12]
self._token = md5(passwd + self._salt).hexdigest()
self._ssconn = libsonic.Connection(host, user, passwd, port=self._port)
def get_connection():
global connection
if connection == None:
connected = False
# Create connection
try:
connection = libsonic.Connection(
baseUrl=Addon().get_setting('subsonic_url'),
username=Addon().get_setting('username', convert=False),
password=Addon().get_setting('password', convert=False),
port=Addon().get_setting('port'),
apiVersion=Addon().get_setting('apiversion'),
insecure=Addon().get_setting('insecure'),
legacyAuth=Addon().get_setting('legacyauth'),
useGET=Addon().get_setting('useget'),
)
connected = connection.ping()
except:
pass
if connected == False:
popup('Connection error')
return False
return connection
def connect(self):
server = self.config['server'].get()
user = self.config['user'].get()
password = self.config['password'].get()
port = self.config['port'].get()
# We pass in the base url, the username, password, and port number
# Be sure to use https:// if this is an ssl connection!
conn = libsonic.Connection(server , user ,
password , port=port)
return conn
def __init__(self, server_info):
Service.__init__(self, server_info)
self._service_name = 'subsonic'
self.conn = libsonic.Connection(
baseUrl=self.service_config['url'],
username=self.service_config['user'],
password=self.service_config['password'],
port=self.service_config['port'],
appName=self.service_config['appname'],
apiVersion=self.service_config['api'],
serverPath=self.service_config['serverpath'])
self._connect_status = self._test_server_connection()
self._server_full_url = self._get_server_full_url()
self._resolved_status_mapping = self._map_connection_status()
self._img_base_url = self._build_external_img_path(
self._service_name) + 'cover='
def connect(self):
baseUrl = self.config['baseurl'].get()
apiPath = self.config['apipath'].get()
apiVersion = self.config['apiversion'].get()
user = self.config['user'].get()
password = self.config['password'].get()
port = self.config['port'].get()
# We pass in the base url, path, the username, password, port number and api version
# Be sure to use https:// if this is an ssl connection!
conn = libsonic.Connection(baseUrl=baseUrl,
port=port,
serverPath=apiPath,
apiVersion=apiVersion,
username=user,
password=password)
return conn
def __init__(self, config, audio):
super(SubsonicBackend, self).__init__()
self.config = config['subsonic']
self.hostname = self.config.get("hostname")
self.port = self.config.get("port")
self.username = self.config.get("username")
self.password = self.config.get("password")
if (self.config.get("ssl") == "yes"):
self.hostname = 'https://' + self.hostname
else:
self.hostname = 'http://' + self.hostname
self.library = SubsonicLibraryProvider(backend=self)
self.playback = SubsonicPlaybackProvider(backend=self, audio=audio)
self.playlists = None
self.uri_schemes = ['subsonic']
self.subsonic = libsonic.Connection(self.hostname, self.username,
self.password, self.port)
logger.info('Subsonic using %s:%d as server', self.hostname, self.port)
def __init__(self, *args, **kwargs):
self.client = libsonic.Connection(*args, **kwargs)
ls = []
ftp.retrlines('LIST', ls.append)
for line in ls:
if flag in line:
return True
return False
except Exception as e:
print e
return False
return True
def subsonic_test(server_info, (username, password, artist)):
try:
conn = libsonic.Connection(server_info, username, password)
test_str = conn.getArtists().__str__()
if artist in test_str:
return True
else:
return False
except Exception as e:
print e
return False
def minecraft_test(server_info, extra):
try:
server = MinecraftServer.lookup(server_info)
server.status()
return True
