main.py

import manager as m
import afkstreamer
import time
import listener
from multiprocessing.managers import BaseManager
import bootstrap
from bootstrap import Switch
import config
import logging
import threading
import os


class StatusUpdate(object):
    __metaclass__ = bootstrap.Singleton

    def __init__(self):
        object.__init__(self)

        # Start streamstatus updater
        m.start_updater()

        self.mode = None

        self.status = m.Status()
        self.status.add_handler(self)
        self.streamer = afkstreamer.Streamer(config.icecast_attributes())
        self.listener = None
        self.switching = False

    def switch_dj(self, force=False):
        if (force):
            self.switching = Switch(True)
        else:
            np = m.NP()
            self.switching = Switch(True, (np.length - np.position) + 15)
        # Call shutdown
        self.streamer.shutdown(force)

    def __call__(self, info):
        """
        If info does not contain anything, then the call to the master server
        failed, and hence there is no mountpoint or DJ active.
        info is a dictionary from streamstatus.get_status(server_name)
        """
        if (not info['Online']):
            self.debug(
                "No mountpoint for {server} found.".format(
                    server=config.master_server))
            if not self.streamer.connected:
                # no streamer up, and no mountpoint
                self.debug("Streamer is not connected")
                # only allow hanyuu to stream if she is set as DJ first!
                if m.DJ().user == u"AFK" and (not self.switching):
                    logging.debug("Streaming trying to connect")
                    self.streamer.connect()
                elif m.DJ().user != u"AFK":
                    logging.debug('Not allowed to connect')
        elif (not self.streamer.connected):
            self.debug(
                "{server} is active and we aren't streaming; assume DJ".format(
                    server=config.master_server))
            # No streamer is active, there is a DJ streaming
            if (not self.listener):
                self.debug("Listener isn't active, starting it")
                # There is no listener active, create one
                self.listener = listener.start()
            elif (not self.listener.active):
                # The listener died restart it
                self.debug("Listener isn't active anymore, restarting it")
                self.listener.shutdown()
                self.listener = listener.start()

    def debug(self, mode):
        if mode != self.mode:
            self.mode = mode
            logging.debug(mode)


class StreamManager(BaseManager):
    pass

StreamManager.register("stats", bootstrap.stats)
StreamManager.register("Stream", StatusUpdate)


def connect():
    global manager, stream
    manager = StreamManager(
        address=config.manager_stream,
        authkey=config.authkey)
    manager.connect()
    stream = manager.Stream()
    return stream


def start():
    s = StatusUpdate()
    manager = StreamManager(
        address=config.manager_stream,
        authkey=config.authkey)
    server = manager.get_server()
    server.serve_forever()


def launch_server():
    import os
    try:
        os.remove('/tmp/hanyuu_stream')
    except:
        pass
    manager = StreamManager(
        address=config.manager_stream,
        authkey=config.authkey)
    manager.start()
    global _unrelated_
    _unrelated_ = manager.Stream()
    return manager


def main():
    global manager
    t = threading.Thread(target=start)
    t.daemon = True
    t.name = "Streamer Manager Thread"
    t.start()

if __name__ == "__main__":
    main()