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
