def test_gdm(plex):
gdm = GDM()
gdm_enabled = plex.settings.get("GdmEnabled")
gdm.scan(timeout=2)
if gdm_enabled:
assert len(gdm.entries)
else:
assert not len(gdm.entries)
async def async_setup(hass, config):
"""Set up the Plex component."""
hass.data.setdefault(
PLEX_DOMAIN,
{
SERVERS: {},
DISPATCHERS: {},
WEBSOCKETS: {},
PLATFORMS_COMPLETED: {}
},
)
await async_setup_services(hass)
gdm = hass.data[PLEX_DOMAIN][GDM_SCANNER] = GDM()
hass.data[PLEX_DOMAIN][GDM_DEBOUNCER] = Debouncer(
hass,
_LOGGER,
cooldown=10,
immediate=True,
function=partial(gdm.scan, scan_for_clients=True),
).async_call
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up the Plex component."""
hass.data.setdefault(
PLEX_DOMAIN,
{
SERVERS: {},
DISPATCHERS: {},
WEBSOCKETS: {},
PLATFORMS_COMPLETED: {}
},
)
await async_setup_services(hass)
gdm = hass.data[PLEX_DOMAIN][GDM_SCANNER] = GDM()
def gdm_scan():
_LOGGER.debug("Scanning for GDM clients")
gdm.scan(scan_for_clients=True)
hass.data[PLEX_DOMAIN][GDM_DEBOUNCER] = Debouncer(
hass,
_LOGGER,
cooldown=10,
immediate=True,
function=gdm_scan,
).async_call
return True
async def async_discover(hass):
"""Scan for available Plex servers."""
gdm = GDM()
await hass.async_add_executor_job(gdm.scan)
for server_data in gdm.entries:
await hass.config_entries.flow.async_init(
DOMAIN,
context={CONF_SOURCE: config_entries.SOURCE_INTEGRATION_DISCOVERY},
data=server_data,
)
def __init__(self):
self._monitor = Monitor()
self._gdm = GDM()
self._servers = {}
self._start()
class DiscoveryService:
"""Class that handles discovery of Plex servers on the local network"""
def __init__(self):
self._monitor = Monitor()
self._gdm = GDM()
self._servers = {}
self._start()
def _discover(self):
"""Uses plexapi's GDM class to discover servers"""
servers = self._gdm.find_by_content_type('plex/media-server')
for server in servers:
plexServer = PlexServer.fromData(server)
if plexServer:
self._addServer(plexServer)
def _addServer(self, server: PlexServer):
"""Add a discovered PMS server as a MediaProvider to the Kodi mediaimport system
:param server: The discovered PlexServer to add into the Kodi mediaimport system
:type server: :class:`PlexServer`
"""
registerServer = False
# check if the server is already known
if server.id not in self._servers:
self._servers[server.id] = server
registerServer = True
else:
# check if the server has already been registered or if some of its properties have changed
if (not self._servers[server.id].registered
or self._servers[server.id].name != server.name
or self._servers[server.id].address != server.address):
self._servers[server.id] = server
registerServer = True
else:
# simply update the server's last seen property
self._servers[server.id].lastseen = server.lastseen
# if the server doesn't need to be registered there's nothing else to do
if not registerServer:
return
providerId = Server.BuildProviderId(server.id)
providerIconUrl = getIcon()
provider = xbmcmediaimport.MediaProvider(
providerId, server.name, providerIconUrl,
plex.constants.SUPPORTED_MEDIA_TYPES)
# store local authentication in settings
providerSettings = provider.prepareSettings()
if not providerSettings:
return
ProviderSettings.SetUrl(providerSettings, server.address)
ProviderSettings.SetAuthenticationMethod(providerSettings, \
plex.constants.SETTINGS_PROVIDER_AUTHENTICATION_OPTION_LOCAL)
providerSettings.save()
if xbmcmediaimport.addAndActivateProvider(provider):
self._servers[server.id].registered = True
log(
f"Plex Media Server {mediaProvider2str(provider)} successfully added and activated",
xbmc.LOGINFO)
else:
self._servers[server.id].registered = False
log(
f"failed to add and/or activate Plex Media Server {mediaProvider2str(provider)}",
xbmc.LOGINFO)
def _expireServers(self):
"""Check registered Plex servers against timeout and expire any inactive ones"""
for serverId, server in iteritems(self._servers):
if not server.isExpired(10):
continue
server.registered = False
xbmcmediaimport.deactivateProvider(serverId)
log(
f"Plex Media Server '{server.name}' ({server.id}) deactivated due to inactivity",
xbmc.LOGINFO)
def _start(self):
"""Start the discovery and registration process"""
log('Looking for Plex Media Servers...')
while not self._monitor.abortRequested():
# try to discover Plex media servers
self._discover()
# expire Plex media servers that haven't responded for a while
self._expireServers()
if self._monitor.waitForAbort(1):
break
