def __init__(self, path, fallback=None, format="json"):
if os.path.exists(path):
os.unlink(path)
if fallback:
start_daemon_thread(self.run_fallback_thread, fallback)
super(UnixServer, self).__init__(format, SocketServer.ThreadingUnixStreamServer, path)
def add_handler(self, name, handler):
queue = self.queue_factory(name)
self.record_fanout.add_queue(queue)
start_daemon_thread(functools.partial(self._handler_thread, name, handler, queue))
self.handlers[name] = handler
self.queues[name] = queue
def run_task(self, task):
with self.workers_lock:
if not (self.busy_workers < self.total_workers):
logger.info("Starting worker #%d", self.total_workers)
start_daemon_thread(self._worker)
self.total_workers += 1
task_id = uuid.uuid1()
self.queue.put((task_id, task, traceback.format_stack()))
return task_id
def _on_peer_resolved(self, service):
if service.name == self.my_name:
return
if service.name in self.peers:
logger.info("Connection with peer %s already exists", service.name)
return
peer = Peer(self, service.url, service.url.replace("http://", "ws://"))
peer.possessions = {"objects": {},
"routines": {}}
self.peers[service.name] = peer
start_daemon_thread(self._peer_connection_thread, service.name)
def _on_start(self):
if hasattr(self, "poll"):
self.logger.debug("Starting poll")
start_daemon_thread(self._poll_loop)
for name, pad in self._input_pads.iteritems():
if pad["has_initial_value"]:
self.__container.worker_pool.run_task(functools.partial(pad["receiver"], pad["initial_value"]))
for name, pad in self._output_pads.iteritems():
generator = pad.get("generator")
if generator:
self.logger.debug("Starting output pad %s generator", name)
start_daemon_thread(self._output_pad_loop, name, generator)
def __init__(self, format, server_factory, server_address):
self.logger = logger.getChild("%r" % (server_address,))
self.format = format
try:
self.parse = {
"json": lambda address, text: parse_json(text),
"text": lambda address, text: parse_plaintext(text, default_application=address, default_logger="root"),
}[self.format]
except KeyError:
raise Exception("Unknown format: '%s'" % format)
self.server = server_factory(server_address, StreamSocketServerHandler)
self.server.queue = Queue()
start_daemon_thread(self.server.serve_forever)
def __init__(self):
self.hotkeys = defaultdict(list)
context = pyudev.Context()
self.input_devices = {}
for device in context.list_devices(subsystem="input"):
if device.device_node is not None:
self._add_input_device(device)
start_daemon_thread(self._input_devices_thread)
self.pyudev_monitor = pyudev.Monitor.from_netlink(context)
self.pyudev_monitor.filter_by("input")
self.pyudev_observer = pyudev.MonitorObserver(self.pyudev_monitor, self._on_new_input_device_event)
self.pyudev_observer.start()
def setup_server(my_name, bus, config):
container = Container()
container.local_database = Database(os.path.join(USER_DATA_DIR, "local_database.json"))
container.shared_database = Database(os.path.join(USER_DATA_DIR, "shared_database.json"))
container.imported_promises_manager = ImportedPromisesManager()
container.exported_promises_manager = ExportedPromisesManager()
container.worker_pool = WorkerPool()
container.peer_manager = PeerManager(container, my_name, bus)
container.object_manager = ObjectManager(container)
container.routine_manager = RoutineManager(container)
container.hotkey_manager = HotkeyManager(container, get_hotkey_provider(config))
container.remote_hotkey_manager = RemoteHotkeyManager(container)
container.web_server = WebServer(container, "0.0.0.0", 46408)
container.event_transceiver = EventTransceiver(container)
container.exported_promises_manager.add_exported_promises_observer(container.event_transceiver)
container.object_manager.add_object_error_observer(container.event_transceiver)
container.object_manager.add_object_signal_observer(container.event_transceiver)
container.object_manager.add_object_property_observer(container.event_transceiver)
container.object_manager.add_object_pad_connection_observer(container.event_transceiver)
container.object_manager.add_object_pad_value_observer(container.event_transceiver)
themylog = get_themylog(config)
if themylog:
themylog_publisher = ThemylogPublisher(*themylog)
container.object_manager.add_object_signal_observer(themylog_publisher)
container.object_manager.add_object_property_observer(themylog_publisher)
objects = {
name: create_object(name, desc.cls, container, desc.args) for name, desc in get_objects(config).iteritems()
}
objects["_%s" % my_name] = create_object("_%s" % my_name, Me, container, {})
container.object_manager.set_objects(objects)
setup_ons(config, container)
setup_routines(config, container)
start_daemon_thread(container.web_server.serve_forever)
def __init__(self, address_family, address_type, address):
self.address_family = address_family
self.address_type = address_type
self.address = address
self.queue = Queue()
start_daemon_thread(self._pub_thread)
from smarthome.server import setup_server
from smarthome.zeroconf.service import ZeroconfService
from themyutils.threading import start_daemon_thread
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG, format="%(levelname)s %(asctime)s [%(name)s] %(message)s")
logging.getLogger("geventwebsocket.handler").setLevel(logging.INFO)
logging.getLogger("smarthome.server.web_server.event_transceiver.object_pad_value").setLevel(logging.INFO)
logging.getLogger("smarthome.zeroconf.discoverer").setLevel(logging.INFO)
GObject.threads_init()
dbus.mainloop.glib.threads_init()
name = platform.node()
dbus_loop = dbus.mainloop.glib.DBusGMainLoop()
bus = dbus.SystemBus(mainloop=dbus_loop)
config = etree.parse(open(os.path.join(os.path.dirname(__file__), "../config_%s.xml" % name)))
etree.strip_tags(config, etree.Comment)
setup_server(name, bus, config)
zeroconf_service = ZeroconfService(name, bus)
start_daemon_thread(Gtk.main)
while True:
time.sleep(1)
args = parser.parse_args(sys.argv[1:])
logging.basicConfig(level=args.level, format=DEFAULT_PROCESS_LOG_FMT)
logger = logging.getLogger(__name__)
config = read_config(args.config or find_config())
record_fanout = Fanout()
handler_manager = HandlerManager(record_fanout, create_persistent_queue)
logger.info("Creating receivers")
receivers = create_receivers(config)
for receiver in receivers:
start_daemon_thread(functools.partial(receiver_thread, receiver, record_fanout))
logger.info("Creating handlers")
handlers = create_handlers(config)
handlers_name_counters = defaultdict(lambda: itertools.count(1))
for handler in handlers:
name = "handler-%s-%d" % (handler.__class__.__name__, handlers_name_counters[handler.__class__.__name__].next())
handler_manager.add_handler(name, handler)
logger.info("Starting heartbeat")
heartbeats = []
start_daemon_thread(functools.partial(heartbeat_thread, heartbeats))
def init(self):
start_daemon_thread(self._pika_thread)
self.expected_guests = [g for g in self.expected_guests if g != title]
def say(self, phrase):
requests.post("%s/control" % self.smarthome_api, data=json.dumps({"command": "call_method",
"args": {"object": "hall_speech_synthesizer",
"method": "say",
"args": {"phrase": phrase}}}))
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="guests announcer")
parser.add_argument("--guests-api", required=True, help="Guests API URL")
parser.add_argument("--smarthome-api", required=True, help="Smarthome API URL")
args = parser.parse_args()
guests_watcher = GuestsWatcher(args.guests_api, args.smarthome_api)
start_daemon_thread(guests_watcher.watch)
while True:
try:
mq_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
mq_channel = mq_connection.channel()
mq_channel.exchange_declare(exchange="themylog", type="topic")
result = mq_channel.queue_declare(exclusive=True)
queue_name = result.method.queue
mq_channel.queue_bind(exchange="themylog", queue=queue_name, routing_key=b"smarthome.front_door.closed")
mq_channel.basic_consume(lambda *args, **kwargs: guests_watcher.on_front_door_closed, queue=queue_name, no_ack=True)
mq_channel.start_consuming()
def thread(self, *args, **kwargs):
return start_daemon_thread(*args, **kwargs)
def start(self):
if self._try_init():
self._on_start()
else:
self.logger.info("Unable to init object, forking initialization loop")
start_daemon_thread(self._init_loop)
def __init__(self, handler_manager):
self.handler_manager = handler_manager
start_daemon_thread(self._poll_queues)