コード例 #1
0
ファイル: AuthController.py プロジェクト: JKorf/MediaPi
    def validate(client_id, p, ip, user_agent):
        if APIController.get_salted(p) == SecureSettings.get_string(
                "api_password"):
            client_key = APIController.get_salted(client_id)
            session_key = AuthController.generate_session_key()
            Database().add_client(client_key, session_key, ip, user_agent)
            return True, session_key

        return False, None
コード例 #2
0
 def restart_device():
     instance = int(request.args.get("instance"))
     if instance == 1:
         os.system('sudo reboot')
     else:
         APIController().slave_command(instance, "system", "restart_device")
     return "OK"
コード例 #3
0
ファイル: NextEpisodeManager.py プロジェクト: JKorf/MediaPi
 def notify_next_episode(self, callback):
     if self.next_type is not None:
         Logger().write(
             LogVerbosity.Info,
             "Can continue with next episode: " + self.next_title)
         APIController().ui_request("SelectNextEpisode", callback, 60 * 60,
                                    self.next_title)
コード例 #4
0
    def on_init(client_name, key):
        Logger().write(LogVerbosity.Info, "Init slave: " + client_name)
        if key != SecureSettings.get_string("master_key"):
            Logger().write(LogVerbosity.Info, "Slave authentication failed")
            disconnect()
            return False

        slave = APIController.slaves.get_slave(client_name)
        if slave is not None:
            if slave.connected:
                Logger().write(
                    LogVerbosity.Info,
                    "Slave " + str(client_name) + " connected twice?")
                disconnect()
                return False
            else:
                Logger().write(LogVerbosity.Info,
                               "Slave " + str(client_name) + " reconnected")
                slave.reconnect(request.sid)
                APIController.slaves.changed()
                return True

        client = WebsocketClient(request.sid, current_time())
        client.authenticated = True
        APIController.slaves.add_slave(
            SlaveClient(APIController.next_id(), client_name, client))
        return client.authenticated
コード例 #5
0
    def media_selection_required(self, files):
        if Settings.get_bool("slave"):
            data, = SlaveClientController.request_master(
                "get_history_for_url", 5, self.torrent.uri)
            if data:
                history = [
                    History(x['id'], x['imdb_id'], x['type'], x['title'],
                            x['image'], x['watched_at'], x['season'],
                            x['episode'], x['url'], x['media_file'],
                            x['played_for'], x['length'])
                    for x in json.loads(data)
                ]
            else:
                history = []
        else:
            history = Database().get_history_for_url(self.torrent.uri)

        for file in files:
            seen = [x for x in history if x.media_file == file.path]
            file.seen = len(seen) > 0
            if file.seen:
                seen = seen[-1]
                file.played_for = seen.played_for
                file.play_length = seen.length

        APIController().ui_request("SelectMediaFile", self.set_media_file,
                                   60 * 30, files)
コード例 #6
0
 def _send_ui_request(topic, data, timeout):
     Logger().write(LogVerbosity.Debug, "Sending ui request: " + topic + ", data: " + str(data))
     request_id = APIController().next_id()
     request = Request(request_id, topic, data, None, SlaveClientController._complete_request)
     SlaveClientController.requests.append(request)
     SlaveClientController.slave_ns.emit("ui_request", request_id, topic, data, timeout)
     return request
コード例 #7
0
 def update():
     instance = int(request.args.get("instance"))
     if instance == 1:
         Updater().update()
     else:
         APIController().slave_command(instance, "updater", "update")
     return "OK"
コード例 #8
0
 def _send_request(self, topic, data, room):
     Logger().write(LogVerbosity.Debug, "Sending request: " + topic + ", data: " + str(data))
     request_id = APIController().next_id()
     request_message = Request(request_id, topic, data, room, self._complete_request)
     self.requests.append(request_message)
     data = to_JSON(data)
     self.emit("request", (request_id, topic, data), room=room)
     return request_message
コード例 #9
0
 def close_application():
     instance = int(request.args.get("instance"))
     if instance == 1:
         sys.exit()
     else:
         APIController().slave_command(instance, "system",
                                       "close_application")
     return "OK"
コード例 #10
0
 def restart_application():
     instance = int(request.args.get("instance"))
     if instance == 1:
         python = sys.executable
         os.execl(python, python, *sys.argv)
     else:
         APIController().slave_command(instance, "system",
                                       "restart_application")
     return "OK"
コード例 #11
0
    def stop_player():
        instance = int(request.args.get("instance"))
        Logger().write(LogVerbosity.Info, "Stop playing on " + str(instance))

        if instance == 1:
            MediaManager().stop_play()
        else:
            APIController().slave_command(instance, "media", "stop_play")
        return "OK"
コード例 #12
0
    def pause_resume_player():
        instance = int(request.args.get("instance"))
        Logger().write(LogVerbosity.Info, "Pause/resume on " + str(instance))

        if instance == 1:
            MediaManager().pause_resume()
        else:
            APIController().slave_command(instance, "media", "pause_resume")
        return "OK"
コード例 #13
0
    def seek():
        instance = int(request.args.get("instance"))
        position = int(request.args.get("position"))
        Logger().write(LogVerbosity.Info,
                       "Seek " + str(instance) + " to " + str(position))

        if instance == 1:
            MediaManager().seek(position)
        else:
            APIController().slave_command(instance, "media", "seek", position)
        return "OK"
コード例 #14
0
 def get_update():
     instance = int(request.args.get("instance"))
     if instance == 1:
         return to_JSON(
             UpdateAvailable(Updater().check_version(),
                             Updater().last_version))
     else:
         result = APIController().slave_request(instance,
                                                "get_last_version", 10)
         if result is None:
             return to_JSON(UpdateAvailable(False, ""))
         return to_JSON(UpdateAvailable(result[0], result[1]))
コード例 #15
0
    def change_audio():
        instance = int(request.args.get("instance"))
        track = int(request.args.get("track"))
        Logger().write(LogVerbosity.Info,
                       "Set audio on " + str(instance) + " to " + str(track))

        if instance == 1:
            MediaManager().change_audio(track)
        else:
            APIController().slave_command(instance, "media", "change_audio",
                                          track)
        return "OK"
コード例 #16
0
    def change_volume():
        instance = int(request.args.get("instance"))
        volume = int(request.args.get("volume"))
        Logger().write(LogVerbosity.Info,
                       "Set volume on " + str(instance) + " to " + str(volume))

        if instance == 1:
            MediaManager().change_volume(volume)
        else:
            APIController().slave_command(instance, "media", "change_volume",
                                          volume)
        return "OK"
コード例 #17
0
    def play_radio():
        radio_id = int(request.args.get("id"))
        radio = [x for x in Database().get_radios() if x.id == radio_id][0]
        instance = int(request.args.get("instance"))

        Logger().write(LogVerbosity.Info,
                       "Play radio " + radio.title + " on " + str(instance))
        if instance == 1:
            MediaManager().start_radio(radio.title, radio.url)
        else:
            APIController().slave_command(instance, "media", "start_radio",
                                          radio.title, radio.url)
        return "OK"
コード例 #18
0
    def on_init(client_id, session_key):
        Logger().write(LogVerbosity.Info, "Init UI: " + client_id)
        client = [
            x for x in UIWebsocketController.clients if x.sid == request.sid
        ][0]

        client_key = APIController.get_salted(client_id)
        client.authenticated = Database().check_session_key(
            client_key, session_key)
        if not client.authenticated:
            Logger().write(LogVerbosity.Debug, "UI invalid client/session key")

        return client.authenticated
コード例 #19
0
    def change_sub_delay():
        instance = int(request.args.get("instance"))
        delay = int(request.args.get("delay"))
        Logger().write(
            LogVerbosity.Info,
            "Set sub delay on " + str(instance) + " to " + str(delay))

        if instance == 1:
            MediaManager().change_subtitle_delay(delay)
        else:
            APIController().slave_command(instance, "media",
                                          "change_subtitle_delay", delay)
        return "OK"
コード例 #20
0
    def play_youtube():
        instance = int(request.args.get("instance"))
        title = urllib.parse.unquote(request.args.get("title"))
        url = urllib.parse.unquote(request.args.get("url"))
        position = int(request.args.get("position"))

        Logger().write(LogVerbosity.Info,
                       "Play youtube " + title + " on " + str(instance))
        if instance == 1:
            MediaManager().start_youtube(title, url, position)
        else:
            APIController().slave_command(instance, "media", "start_youtube",
                                          title, url, position)
        return "OK"
コード例 #21
0
    def on_ui_request(request_id, topic, data, timeout):
        slave = APIController.slaves.get_slave_by_sid(request.sid)
        if slave is None:
            Logger().write(LogVerbosity.Debug,
                           "Slave ui request for not initialized slave")
            disconnect()
            return

        Logger().write(LogVerbosity.Debug,
                       "Slave ui request " + topic + ": " + data)
        slave = APIController.slaves.get_slave_by_sid(request.sid)
        APIController().ui_request(
            topic,
            lambda *x: SlaveWebsocketController.slave_ui_request_callback(
                request_id, slave, x), timeout, json.loads(data))
コード例 #22
0
    def play_file():
        instance = int(request.args.get("instance"))
        position = int(request.args.get("position"))
        file = urllib.parse.unquote(request.args.get("path"))
        if sys.platform == "win32":
            file = "C:" + file

        Logger().write(LogVerbosity.Info,
                       "Play file " + file + " on " + str(instance))

        if instance == 1:
            MediaManager().start_file(file, position)
        else:
            APIController().slave_command(instance, "media", "start_file",
                                          file, position)
        return "OK"
コード例 #23
0
    def on_get_current_requests():
        authenticated = [
            x for x in UIWebsocketController.clients if x.sid == request.sid
        ][0].authenticated
        if not authenticated:
            Logger().write(
                LogVerbosity.Info,
                "Unauthenticated socket request for current requests")
            return

        for client_request in APIController().ui_websocket_controller.requests:
            socketio.emit("request",
                          (client_request.request_id, client_request.topic,
                           to_JSON(client_request.data)),
                          namespace="/UI",
                          room=request.sid)
コード例 #24
0
    def play_url():
        instance = int(request.args.get("instance"))
        title = urllib.parse.unquote(request.args.get("title"))
        url = urllib.parse.unquote(request.args.get("url"))
        Logger().write(
            LogVerbosity.Info,
            "Play url " + title + "(" + url + ") on " + str(instance))

        if instance == 1:
            if url.startswith("magnet:"):
                MediaManager().start_torrent(title, url, None)
            else:
                MediaManager().start_url(title, url)
        else:
            APIController().slave_command(instance, "media", "start_url",
                                          title, url)
        return "OK"
コード例 #25
0
ファイル: AuthController.py プロジェクト: JKorf/MediaPi
    def login():
        client_id = request.headers.get('Client-ID', None)
        p = request.args.get('p')
        ip_addr = request.headers.get('HTTP_X_FORWARDED_FOR',
                                      None) or request.remote_addr
        user_agent = request.user_agent.string
        success, key = AuthController.validate(client_id, p, ip_addr,
                                               user_agent)

        Logger().write(LogVerbosity.Info,
                       str(client_id) + " log on result: " + str(success))

        status = 200
        if not success:
            Database().add_login_attempt(APIController.get_salted(client_id),
                                         ip_addr, user_agent, "Login")
            status = 401
        return to_JSON(AuthResult(success, key)), status
コード例 #26
0
    def play_torrent():
        instance = int(request.args.get("instance"))
        title = urllib.parse.unquote(request.args.get("title"))
        url = urllib.parse.unquote(request.args.get("url"))
        magnet_uri = TorrentController.get_magnet_url(url)
        if magnet_uri is None:
            Logger().write(LogVerbosity.Error,
                           "Failed to find torrent magnet uri")
            return "OK"

        Logger().write(LogVerbosity.Info,
                       "Play torrent " + title + " on " + str(instance))
        if instance == 1:
            MediaManager().start_torrent(title, magnet_uri)
        else:
            APIController().slave_command(instance, "media", "start_torrent",
                                          title, magnet_uri)
        return "OK"
コード例 #27
0
    def play_episode():
        instance = int(request.args.get("instance"))
        title = urllib.parse.unquote(request.args.get("title"))
        movie_id = request.args.get("id")
        url = urllib.parse.unquote(request.args.get("url"))
        img = urllib.parse.unquote(request.args.get("img"))
        position = int(request.args.get("position"))
        season = int(request.args.get("season"))
        episode = int(request.args.get("episode"))

        Logger().write(LogVerbosity.Info,
                       "Play episode " + title + " on " + str(instance))
        if instance == 1:
            MediaManager().start_episode(movie_id, season, episode, title, url,
                                         img, position)
        else:
            APIController().slave_command(instance, "media", "start_episode",
                                          movie_id, season, episode, title,
                                          url, img, position)
        return "OK"
コード例 #28
0
ファイル: AuthController.py プロジェクト: JKorf/MediaPi
    def refresh():
        client_id = request.headers.get('Client-ID', None)
        client_key = APIController.get_salted(client_id)
        client_known = Database().client_known(client_key)
        ip_addr = request.headers.get('HTTP_X_FORWARDED_FOR',
                                      None) or request.remote_addr
        user_agent = request.user_agent.string

        if not client_known:
            Logger().write(LogVerbosity.Info,
                           str(client_id) + " failed to refresh")
            Database().add_login_attempt(client_key, ip_addr, user_agent,
                                         "Refresh")
            return to_JSON(AuthResult(False, None)), 401

        session_key = AuthController.generate_session_key()
        Database().refresh_session_key(client_key, session_key, ip_addr,
                                       user_agent)
        Logger().write(LogVerbosity.Debug,
                       str(client_id) + " successfully refreshed")
        return to_JSON(AuthResult(True, session_key)), 200
コード例 #29
0
 def aborting_torrent(self, reason):
     APIController().ui_message("Aborting torrent", reason)
     self.stop_play()
コード例 #30
0
 def on_ui_message(title, message):
     APIController().ui_message(title, message)