def main(argv): try: opts, _ = getopt.getopt(argv, "p:", ["port"]) except getopt.GetoptError: sys.exit(1) global HTTP_PORT global devices global configurations global log_db global general_responses for opt, arg in opts: if opt in ("-p", "--port"): try: HTTP_PORT = int(arg) except ValueError: raise ValueError sys.exit(1) ticker = Ticker() try: logging.basicConfig(filename=LOG_FILE, \ level=logging.INFO, format='%(asctime)s %(message)s', datefmt='%d/%m/%Y %I:%M:%S %p') log_db = SqliteHelper() load_general_responses() server = MyServer(('', HTTP_PORT), RequestHandler) ticker.start() print "Http server stated at %d" % HTTP_PORT server.serve_forever() except KeyboardInterrupt: print '^C received, shutting down server' ticker.stop() server.socket.close()
def __init_ticker__(self): ticker = Ticker(None if not read_bustime_data_from_disk else 0) ticker.register(self.check_buses, self.between_checks) #TODO: only print new status on non-15-sec ticks if it hasn't changed ticker.register(self.broadcast_status, self.between_status_updates) ticker.global_error(self.__global_error__) ticker.start()
def ticker(self, conn): ticker = Ticker(conn) ticker.start()
class Server(asyncore.dispatcher): def __init__(self, parameters, is_standalone): self.parameters = parameters self.is_standalone = is_standalone asyncore.dispatcher.__init__(self) self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.set_reuse_addr() self.bind(("", config.port)) self.listen(5) self.login = config.login self.clients = [] self.games = [] if "admin_only" in parameters: self.nb_games_max = 1 self.nb_clients_max = 20 else: self.nb_games_max = 10 self.nb_clients_max = 40 next_id = 0 def get_next_id(self, increment=True): if increment: self.next_id += 1 return self.next_id else: return self.next_id + 1 def handle_connect(self): pass def handle_read(self): pass def handle_accept(self): ConnectionToClient(self, self.accept()) def _cleanup(self): for c in self.clients[:]: if c not in asyncore.socket_map.values(): self.clients.remove(c) if self.games and not self.clients: self.games = [] def log_status(self): self._cleanup() info("%s players (%s not playing), %s games", len(self.clients), len(self.players_not_playing()), len([g for g in self.games if g.started])) def _is_admin(self, client): return client.address[0] == "127.0.0.1" and client.login == self.login def remove_client(self, client): info("disconnect: %s" % client.login) client.is_disconnected = True if client in self.clients: # not anonymous self.clients.remove(client) for c in self.players_not_playing(): c.send_msg([client.login, 4259]) # ... has just disconnected self.update_menus() if isinstance(client.state, Playing): client.cmd_abort_game([]) if self._is_admin(client) and not self.is_standalone: info("the admin has disconnected => close the server") sys.exit() self.log_status() def handle_write(self): pass def handle_close(self): try: debug("Server.handle_close") except: pass sys.exit() def handle_error(self): try: debug("Server.handle_error %s", sys.exc_info()[0]) except: pass if sys.exc_info()[0] in [SystemExit, KeyboardInterrupt]: sys.exit() else: try: exception("Server.handle_error") except: pass def can_create(self, client): if "admin_only" in self.parameters: return self._is_admin(client) else: return len([g for g in self.games if g.started]) < self.nb_games_max def unregister(self): try: info("unregistering server...") s = urllib.urlopen(UNREGISTER_URL + "?ip=" + self.ip).read() except: s = "couldn't access to the metaserver" if s: warning("couldn't unregister from the metaserver (%s)", s[:80]) ip = "" def _get_ip_address(self): try: self.ip = urllib.urlopen(WHATISMYIP_URL).read().strip() if not re.match("^[0-9.]{7,40}$", self.ip): self.ip = "" except: self.ip = "" if not self.ip: warning("could not get my IP address from %s", WHATISMYIP_URL) _first_registration = True def _register(self): try: s = urllib.urlopen(REGISTER_URL + "?version=%s&login=%s&ip=%s&port=%s" % (compatibility_version(), self.login, self.ip, config.port)).read() except: s = "couldn't access to the metaserver" if s: warning("couldn't register to the metaserver (%s)", s[:80]) else: info("server registered") def register(self): if self._first_registration: self._get_ip_address() self._first_registration = False self._register() def _start_registering(self): self.ticker = Ticker(REGISTER_INTERVAL, self.register) self.ticker.start() def startup(self): if "no_metaserver" not in self.parameters: self._start_registering() info("server started") asyncore.loop() def update_menus(self): for c in self.clients: c.send_menu() def available_players(self): return [x for x in self.clients if isinstance(x.state, InTheLobby)] def game_admins(self): return [x for x in self.clients if isinstance(x.state, OrganizingAGame)] def players_not_playing(self): return [x for x in self.clients if not isinstance(x.state, Playing)] def get_client_by_login(self, login): for c in self.clients: if c.login == login: return c def get_game_by_id(self, ident): ident = int(ident) for o in self.games: if o.id == ident: return o
except ValueError: print "Warning: Unable to parse configuration file." else: # looks like no configuration exists -> create default one with open(conffile, 'w') as f: f.write(json.dumps(settings, sort_keys=True, indent=4) + "\n") nfc_broadcast = NFCBroadcast() controller = Controller(settings, nfc_broadcast) bluetooth_receiver = BluetoothReceiver( controller.bluetooth_available, controller.new_transaction_via_bluetooth) tx_monitor = TxMonitor(controller.new_transaction_received) ticker_settings = settings['exchange_rate_ticker'] ticker = Ticker(ticker_settings['source'], ticker_settings['currency'], ticker_settings['url'], ticker_settings['fields'], ticker_settings['interval'], controller.exchange_rate_updated) # start various threads nfc_broadcast.start() bluetooth_receiver.start() tx_monitor.start() ticker.start() # enter main event loop controller.run() # clean up - NFCBroadcast uses an external process, # which we need to terminate nfc_broadcast.shutdown()
'exchange_rate_ticker': { 'source': 'MtGox.com', 'url': 'https://mtgox.com/api/0/data/ticker.php', 'field': 'last', 'interval': 5 } } conffile = os.path.expanduser('~/.greenaddress-pos-tool') if os.path.isfile(conffile): try: with open(conffile, 'r') as f: settings = json.loads(f.read()) except ValueError: print "Warning: Unable to parse configuration file." else: # looks like no configuration exists -> create default one with open(conffile, 'w') as f: f.write(json.dumps(settings, sort_keys=True, indent=4) + "\n") controller = Controller(settings) green_address_check = GreenAddressCheck(settings['green_addresses'], controller.new_transaction_received) ticker_settings = settings['exchange_rate_ticker'] ticker = Ticker(ticker_settings['source'], ticker_settings['currency'], ticker_settings['url'], ticker_settings['fields'], ticker_settings['interval'], controller.exchange_rate_updated) green_address_check.start() ticker.start() controller.run()
class LCDFrontend(pykka.ThreadingActor, CoreListener): def __init__(self, config, core): super(LCDFrontend, self).__init__() self.lcd = RPi_I2C_driver.lcd() if config['lcd']['display_temperature']: bus = SMBus(config['lcd']['bme280_i2c_bus']) self.bme280 = BME280(i2c_dev=bus) else: self.bme280 = None self.ticker = Ticker(self.actor_ref, LCDFrontend.TICK_INTERVAL) self.ticker.start() self.stream_title = "" self.st_pos = 0 self.lifetime = 0 self.lcd_on = True self.volume = 0 def stream_title_changed(self, title): self.stream_title = title self.st_pos = 0 self.turn_on() def volume_changed(self, volume): self.volume = volume self.turn_on() def turn_on(self): self.lcd_on = True self.lifetime = 0 def turn_off(self): self.lcd.backlight(0) self.lcd_on = False def display(self): self.lcd.lcd_display_string( "%-16.16s" % (self.stream_title[self.st_pos:], ), LCDFrontend.LINE_1) self.st_pos = self.st_pos + 16 if self.st_pos + 16 < len( self.stream_title) else 0 change_time = (self.lifetime / LCDFrontend.CHANGE_DISPLAY_TIME) % 2 if change_time == 0 or self.bme280 is None: self.lcd.lcd_display_string("Volume: %-4d" % (self.volume, ), LCDFrontend.LINE_2) else: temp = self.bme280.get_temperature() self.lcd.lcd_display_string("Temp.: %-5.2f" % (temp, ), LCDFrontend.LINE_2) def tick(self): self.lifetime += LCDFrontend.TICK_INTERVAL if self.lifetime >= LCDFrontend.MAX_LIFETIME: self.turn_off() return self.display() def on_receive(self, message): if message.get(Ticker.TICK) and self.lcd_on: self.tick() LINE_1 = 1 LINE_2 = 2 TICK_INTERVAL = 2 MAX_LIFETIME = 600 CHANGE_DISPLAY_TIME = 6