def update_tracking(self, state):
if self.media_data.type == "Radio":
return
if self.history_id == 0 or state.state != PlayerState.Playing or current_time(
) - self.last_tracking_update < 5000:
return
if state.playing_for > state.length - (
state.length *
0.04) or state.length - state.playing_for < 10000:
if Settings.get_bool("slave"):
SlaveClientController.notify_master("update_watching_item",
self.history_id,
state.length, state.length,
current_time())
else:
Database().update_watching_item(self.history_id, state.length,
state.length, current_time())
else:
if Settings.get_bool("slave"):
SlaveClientController.notify_master("update_watching_item",
self.history_id,
state.playing_for,
state.length,
current_time())
else:
Database().update_watching_item(self.history_id,
state.playing_for,
state.length, current_time())
self.last_tracking_update = current_time()
def internal_start_master(self):
from Webserver.Controllers.AuthController import AuthController
from Webserver.Controllers.AccessController import AccessController
from Webserver.Controllers.MediaPlayer.MovieController import MovieController
from Webserver.Controllers.MediaPlayer.ShowController import ShowController
from Webserver.Controllers.MediaPlayer.PlayController import PlayController
from Webserver.Controllers.MediaPlayer.HDController import HDController
from Webserver.Controllers.MediaPlayer.RadioController import RadioController
from Webserver.Controllers.MediaPlayer.TorrentController import TorrentController
from Webserver.Controllers.MediaPlayer.YouTubeController import YouTubeController
from Webserver.Controllers.DataController import DataController
from Webserver.Controllers.Home.TradfriController import TradfriController
from Webserver.Controllers.Home.ToonController import ToonController
from Webserver.Controllers.UtilController import UtilController
from Webserver.Controllers.Home.RuleController import RuleController
from Webserver.Controllers.Websocket2.UIWebsocketController import UIWebsocketController
from Webserver.Controllers.Websocket2.SlaveWebsocketController import SlaveWebsocketController
self.ui_websocket_controller = UIWebsocketController("/UI")
self.slave_websocket_controller = SlaveWebsocketController("/Slave")
UIWebsocketController.init()
YouTubeController.init()
socketio.on_namespace(self.ui_websocket_controller)
socketio.on_namespace(self.slave_websocket_controller)
APIController.slaves.add_slave(
SlaveClient(1, Settings.get_string("name"), None))
socketio.run(app,
host='0.0.0.0',
port=int(Settings.get_string("api_port")),
log_output=True)
def __init__(self, peer, uri):
super().__init__(peer, "connection")
self.peer = peer
self.uri = uri
self.to_send_bytes = bytearray()
self.last_send = 0
self.connected_on = 0
self._last_communication = 0
self._peer_timeout = Settings.get_int("peer_timeout")
self._connection_timeout = Settings.get_int("connection_timeout") / 1000
self.connection = TcpClient(uri.hostname, uri.port, self._connection_timeout)
self.buffer = bytearray()
self.buffer_in_size = 0
self.buffer_out_size = 0
self._next_message_length = 1
self._buffer_position = 0
self._receive_state = ReceiveState.ReceiveLength
self._receive_buffer_size = 32768
self.in_thread = None
self.reading_handshake = True
def __init__(self, host, port):
self.host = host
self.port = port
self.last_announce = 0
self.transaction_id = 0
self.connection_id = 0
self.connection_id_retrieved = 0
self.connection = UdpClient(host, port, Settings.get_int("connection_timeout") / 1000)
self.tracker_peer_request_amount = Settings.get_int("tracker_peer_request_amount")
def __init__(self):
self.git_repo = "https://github.com/jkorf/MediaPi.git"
self.git_branch = "NewUI"
self.base_folder = Settings.get_string("base_folder")
self.update_folder = Settings.get_string("base_folder") + "Updates/"
self.ignore_directories = ("/Solution", "/UI/homebase", "/UI/Web")
self.copied_files = 0
self.last_version = Database().get_stat_string("CurrentGitVersion")
self.last_update = Database().get_stat("LastUpdate")
self.update_state = UpdateState(self.last_version, self.last_update)
def __init__(self, parent, name):
self._logging = Settings.get_bool("state_logging")
if self._logging:
parent_id = 0
if parent is not None:
parent_id = parent.log_tracker.id
self.log_tracker = LogItemTracker(parent_id, name)
def start_timing(self, name):
if not Settings.get_bool("state_logging"):
return
if name not in self.timings:
self.timings[name] = TimingData(name)
self.timings[name].start()
def start(self):
APIController.slaves = SlaveCollection()
log_verbosity = Settings.get_int("log_level")
if log_verbosity > 0:
flask_logger = logging.getLogger('werkzeug')
flask_logger.setLevel(logging.INFO)
if Settings.get_bool("slave"):
thread = CustomThread(self.internal_start_slave, "API controller",
[])
thread.start()
else:
thread = CustomThread(self.internal_start_master, "API controller",
[])
thread.start()
def __init__(self, torrent):
super().__init__(torrent, "download")
self.torrent = torrent
self.init = False
self.prio = False
self.last_get_result = 0, 0
self.last_get_time = 0
self.queue = []
self.slow_peer_piece_offset = 0
self._ticks = 0
self.start_piece = 0
self.end_piece = 0
self.stream_end_buffer_pieces = 0
self.stream_play_buffer_high_priority = 0
self.max_chunk_size = Settings.get_int("max_chunk_size")
self.download_mode = DownloadMode.Full
self.peers_per_piece = [(100, 2, 5), (95, 1, 2), (0, 1, 1)]
self._event_id_stopped = EventManager.register_event(
EventType.TorrentStopped, self.unregister)
self._event_id_torrent_state = EventManager.register_event(
EventType.TorrentStateChange, self.init_queue)
self.queue_log = ""
def get_by_id_internal(show_id):
Logger().write(LogVerbosity.Debug, "Get show by id " + show_id)
response = RequestFactory.make_request(ShowController.shows_api_path +
"show/" + show_id)
data = json.loads(response.decode('utf-8'))
seen_episodes = []
data['favorite'] = False
if not Settings.get_bool("slave"):
seen_episodes = Database().get_history_for_id(show_id)
data['favorite'] = show_id in [
x.id for x in Database().get_favorites()
]
for episode in data['episodes']:
seen = [
x for x in seen_episodes if episode['season'] == x.season
and episode['episode'] == x.episode
]
episode['seen'] = len(seen) != 0
if len(seen) == 0:
continue
seen = seen[-1]
episode['seen'] = True
episode['played_for'] = seen.played_for
episode['length'] = seen.length
return data
def __init__(self):
self.subtitle_sources = [
SubtitlesOpenSubtitles(),
]
self.sub_file_directory = Settings.get_string("base_folder") + "/subs/"
self.sub_files = []
self.file_size = 0
self.file_length = 0
self.file_name = None
self.first_64k = None
self.last_64k = None
# create subtitles directory
if not os.path.exists(self.sub_file_directory):
os.makedirs(self.sub_file_directory)
# remove old subtitles files
file_list = glob.glob(self.sub_file_directory + "*.srt")
for f in file_list:
os.remove(f)
EventManager.register_event(EventType.SearchSubtitles,
self.search_subtitles)
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)
def __init__(self):
self.media_data = MediaData()
self.torrent_data = TorrentData()
self.torrent = None
self.subtitle_provider = SubtitleProvider()
self.next_episode_manager = NextEpisodeManager()
self.play_position = 0
self.play_length = 0
self.history_id = 0
self.last_tracking_update = 0
self.dht_enabled = Settings.get_bool("dht")
if self.dht_enabled:
self.dht = DHTEngine()
self.dht.start()
EventManager.register_event(EventType.AbortingTorrent,
self.aborting_torrent)
EventManager.register_event(EventType.TorrentMediaSelectionRequired,
self.media_selection_required)
EventManager.register_event(EventType.TorrentMediaFileSet,
lambda x: self._start_playing_torrent())
EventManager.register_event(EventType.TorrentStopped,
lambda: self.on_torrent_stopped())
VLCPlayer().player_state.register_callback(self.player_state_change)
self.torrent_observer = CustomThread(self.observe_torrent,
"Torrent observer")
self.torrent_observer.start()
self.next_epi_thread = None
def connect():
SlaveClientController.running = True
Logger().write(LogVerbosity.Debug, "Connecting to master")
SlaveClientController.socket = SocketIO(Settings.get_string("master_ip"), port=int(Settings.get_string("api_port")))
SlaveClientController.slave_ns = SlaveClientController.socket.define(Handler, "/Slave")
while SlaveClientController.running:
SlaveClientController.socket.wait(1)
def __init__(self, peer):
super().__init__(peer, "meta")
self.peer = peer
self.handshake_send = False
self.handshake_successful = False
self.extension_handshake_send = False
self.bitfield_done = False
self.metadata_requested = False
self.pause_handled = False
self.port_send = False
self.last_peer_exchange = current_time()
self._low_peer_max_speed = Settings.get_int(
"low_peer_max_download_buffer") / 3
self._medium_peer_max_speed = Settings.get_int(
"medium_peer_max_download_buffer") / 3
def __init__(self):
self.state_data = StateData()
self.monitoring = sys.platform == "linux" or sys.platform == "linux2"
self.state_data.name = Settings.get_string("name")
self.watch_thread = CustomThread(self.update_state, "State observer")
self.watch_thread.start()
self.memory_thread = CustomThread(self.check_memory, "Memory observer")
self.memory_thread.start()
def get_log_files():
list_of_files = glob.glob(
Settings.get_string("base_folder") + "/Logs/*/*.txt")
latest_files = sorted(list_of_files,
key=os.path.getctime,
reverse=True)
return [(os.path.basename(x), x, os.path.getsize(x))
for x in latest_files]
def __init__(self, torrent):
super().__init__(torrent, "cache")
self.open_cache_files = []
self.piece_length = 0
self.total_length = 0
self.media_start_byte = 0
self.media_start_piece_offset = 0
self.path = Settings.get_string("base_folder") + "Solution/cache/"
self.bytes_written = 0
def get_instance_parameters():
params = [
"--verbose=" + str(Settings.get_int("vlc_log_level")),
"--network-caching=" + str(Settings.get_int("network_caching")),
"--ipv4-timeout=500", "--image-duration=-1"
]
if sys.platform == "linux" or sys.platform == "linux2":
log_path = Settings.get_string(
"base_folder") + "/Logs/" + datetime.datetime.now().strftime(
'%Y-%m-%d %H-%M-%S')
params.append(
"--logfile=" + log_path + '/vlc_' +
datetime.datetime.now().strftime('%Y-%m-%d %H-%M-%S') + ".txt")
params.append("--file-logging")
params.append("--file-caching=5000")
return params
def cleanup_logging(self):
try:
base_path = Settings.get_string("base_folder") + "/Logs/"
for f in os.listdir(base_path):
file_path = base_path + f
creation_time = os.stat(file_path).st_mtime
if (current_time() / 1000 - creation_time) >= 60 * 60 * 24 * 7:
shutil.rmtree(file_path, True)
except Exception as e:
self.write_error(e, "Log cleaning failed")
def __init__(self, peer):
super().__init__(peer, "download")
self.peer = peer
self.stopped = False
self.downloading = []
self._block_size = Settings.get_int("block_size")
self._low_peer_max_blocks = Settings.get_int(
"low_peer_max_download_buffer") // self._block_size
self._medium_peer_max_blocks = Settings.get_int(
"medium_peer_max_download_buffer") // self._block_size
self._fast_peer_max_blocks = Settings.get_int(
"fast_peer_max_download_buffer") // self._block_size
self.timed_out_blocks = 0
# Logging props
self.downloading_log = ""
def start_file(self, url, time):
actual_url = url
if Settings.get_bool("slave"):
actual_url = "http://" + Settings.get_string(
"master_ip") + ":50015/file/" + urllib.parse.quote(url)
self.stop_play()
VLCPlayer().play(actual_url, time)
if Settings.get_bool("slave"):
self.history_id, = SlaveClientController.request_master(
"add_watched_file", 5, url, current_time())
else:
self.history_id = Database().add_watched_file(url, current_time())
self.media_data.start_update()
self.media_data.type = "File"
self.media_data.title = os.path.basename(url)
self.media_data.url = url
self.media_data.image = None
self.media_data.stop_update()
TVManager().switch_input_to_pi()
def start_url(self, title, url):
self.stop_play()
VLCPlayer().play(url, 0)
if Settings.get_bool("slave"):
self.history_id, = SlaveClientController.request_master(
"add_watched_url", 5, url, current_time())
else:
self.history_id = Database().add_watched_url(url, current_time())
self.media_data.start_update()
self.media_data.type = "Url"
self.media_data.title = title
self.media_data.stop_update()
TVManager().switch_input_to_pi()
def __init__(self, base_path, file_name, print_to_output):
self.base_path = base_path
self.base_file_name = file_name
self.print_to_output = print_to_output
self.file = None
self.file_size = 0
self.file_number = 1
self.max_log_file_size = Settings.get_int("max_log_file_size")
self.running = True
self.process_thread = None
self.queue = []
self.queue_event = threading.Event()
def __init__(self, torrent):
super().__init__(torrent, "peers")
self.torrent = torrent
self.potential_peers = []
self.connecting_peers = []
self.connected_peers = []
self.disconnected_peers = []
self.cant_connect_peers = []
self.complete_peer_list = []
self.max_peers_connected = Settings.get_int("max_peers_connected")
self.max_peers_connecting = Settings.get_int("max_peers_connecting")
self._peer_request_interval = Settings.get_int("peer_request_interval")
self._peer_request_interval_no_potential = Settings.get_int(
"peer_request_interval_no_potential")
self.random = Random()
self.download_start = 0
self.start_time = current_time()
self.last_peer_request = 0
self.checked_no_peers = False
self._event_id_stopped = EventManager.register_event(
EventType.TorrentStopped, self.unregister)
self._event_id_torrent_change = EventManager.register_event(
EventType.TorrentStateChange, self.torrent_state_change)
self._event_id_peers_found = EventManager.register_event(
EventType.PeersFound, self.add_potential_peers)
self.high_speed_peers = 0
self.medium_speed_peers = 0
# Log properties
self.potential_peers_log = 0
self.connecting_peers_log = 0
self.connected_peers_log = 0
self.disconnected_peers_log = 0
self.cant_connect_peers_log = 0
def init_queue(self, old_state, new_state):
if not self.init and new_state == TorrentState.Downloading and self.torrent.media_file is not None:
self.init = True
self.start_piece = self.torrent.media_file.start_piece(
self.torrent.piece_length)
self.end_piece = self.torrent.media_file.end_piece(
self.torrent.piece_length)
self.stream_end_buffer_pieces = self.torrent.data_manager.get_piece_by_offset(
self.torrent.media_file.end_byte -
Settings.get_int("stream_end_buffer_tolerance")).index
self.stream_play_buffer_high_priority = max(
1500000 // self.torrent.piece_length, 2) # TODO setting
self.requeue(0)
def __init__(self, name, port, arg=None):
super().__init__(arg, name)
self.name = name
self.torrent = arg
self.port = port
self.thread = None
self.chunk_length = Settings.get_int("max_chunk_size")
self.server = StreamServer(self.name, port, self.handle_request)
self.sockets_writing_data = []
self.running = False
self.bytes_send = 0
self.id = 0
def __init__(self, torrent):
super().__init__(torrent, "data")
self.torrent = torrent
self._pieces = dict()
self.init_done = False
self.total_pieces = 0
self.piece_length = 0
self.bitfield = None
self.hashes = []
self.block_size = Settings.get_int("block_size")
self.broadcasted_hash_data = False
self._event_id_stopped = EventManager.register_event(
EventType.TorrentStopped, self.unregister)
self.blocks_done_length = 0
self.last_piece_index = 0
def _start_playing_torrent(self):
if Settings.get_bool("slave"):
self.history_id, = SlaveClientController.request_master(
"add_watched_torrent", 5, self.media_data.type,
self.media_data.title, self.media_data.id, self.torrent.uri,
self.torrent.media_file.path, self.media_data.image,
self.media_data.season, self.media_data.episode,
current_time())
else:
self.history_id = Database().add_watched_torrent(
self.media_data.type, self.media_data.title,
self.media_data.id, self.torrent.uri,
self.torrent.media_file.path, self.media_data.image,
self.media_data.season, self.media_data.episode,
current_time())
VLCPlayer().play("http://localhost:50009/torrent",
self.media_data.start_from)
def init():
if Settings.get_int("log_level") == 0:
import logging
logging.getLogger('requests').setLevel(logging.WARNING)
logging.basicConfig(level=logging.DEBUG)
from MediaPlayer.MediaManager import MediaManager
from MediaPlayer.Player.VLCPlayer import VLCPlayer
from Updater import Updater
from Shared.State import StateManager
from Shared.Stats import Stats
StateManager().state_data.register_callback(lambda old, new: SlaveClientController.broadcast("state", new))
VLCPlayer().player_state.register_callback(lambda old, new: SlaveClientController.broadcast("player", new))
MediaManager().media_data.register_callback(lambda old, new: SlaveClientController.broadcast("media", new))
MediaManager().torrent_data.register_callback(lambda old, new: SlaveClientController.broadcast("torrent", new))
Stats().cache.register_callback(lambda old, new: SlaveClientController.broadcast("stats", new))
Updater().update_state.register_callback(lambda old, new: SlaveClientController.broadcast("update", new))