def run(self): "Start the server" # Just redirects every message logged to the application status object # in order to make it available through the web interface self.logger.addHandler(PushHandler(self.status.push_log)) if self.work_queue.use_dfs: self.info("Starting Distributed Filesystem") self.work_queue.fs.start() self.info("Server started on http://%s:%d" % self.addrinfo) self.hb_thread.start() Server.run(self)
def application(interface): mac = config.get_config('mac') server = config.get_config('address') place = config.get_config('place') chipid = config.get_config('chipid') # Temperature sensor device import ds18b20 as sensor # Now add some configuration params for pin in [12, 0, 2]: sensor.sensor = sensor.TempSensor(pin=pin, place=place, server=server, chipid=chipid, mac=mac) if sensor.sensor.present: print('Found sensor @', pin) break from register import Register rurl = config.get_config('register') auth = config.get_config('authorization') register = Register(rurl, auth) # http Server from httpserver import Server server = Server(title=place) # construct server object server.activate(8805) # server activate with port # now we introduce the sleep concept sleep = config.get_config('sleep') try: sleep = int(sleep) / 10 except: sleep = 0 startime = time.time() while True: # activate and run for a while if returns True we go to sleep server.wait_connections(interface) T = sensor.sensor.status() display.display(T['temp']) delta = abs(time.time() - startime) if sleep and delta > sleep: register.http_post(T) from gotosleep import gotosleep gotosleep(int(sleep)) elif delta > 300: register.http_post(T) startime = time.time()
def application(): # Temperature sensor device from ds18b20 import sensor, TempSensor sensor = TempSensor() from register import register, Register rurl = config.get_config('register') auth = config.get_config('authorization') if rurl: register = Register(rurl, auth) # Pir device from pir import pir, PirDevice pir = PirDevice() # Relaye device from relay import relay, Relay pin = config.get_config('relay-pin') try: p = int(pin) except: p = 14 relay = Relay(p) # The range application from ranges import ranges, Ranges ranges = Ranges() r = config.get_config('ranges') if r: ranges.set(r) # The control from control import control, Control timeout = config.get_config('timeout') if not timeout: timeout = 20 control = Control(timeout) # Http Server from httpserver import Server server = Server() # construct server object server.activate(8805) # server activate with try: server.wait_connections(interface, 0) # activate and run for a while control.loop() except KeyboardInterrupt: pass except Exception as e: sys.print_exception(e) print(e)
def main(): # Enable automatic garbage collector gc.enable() config.read_config() # Get defaults ssid = config.get_config('ssid') pwd = config.get_config('pwd') # Connect to Network and save if sta_if = do_connect(ssid, pwd) chipid = hexlify(machine.unique_id()) config.set_config('chipid', chipid) # Turn on Access Point only if AP PWD is present apssid = 'YoT-%s' % bytes.decode(chipid) appwd = config.get_config('appwd') do_accesspoint(apssid, appwd) # To have time to press ^c time.sleep(2) # Update config with new values # Get Network Parameters if sta_if != None: (address, mask, gateway, dns) = sta_if.ifconfig() config.set_config('address', address) config.set_config('mask', mask) config.set_config('gateway', gateway) config.set_config('dns', dns) config.set_config('mac', hexlify(sta_if.config('mac'), ':')) # Ok now we save configuration! config.set_time() config.save_config() # Registering register_url = config.get_config('register') authorization = config.get_config('authorization') if register_url != '' and authorization != '': from register import register # When it starts send a register just to know we're alive tim = machine.Timer(-1) print('register init 5min') tim.init(period=300000, mode=machine.Timer.PERIODIC, callback=lambda t: register(register_url, authorization)) # Free some memory ssid = pwd = None apssid = appwd = None address = mask = gateway = dns = None gc.collect() # Launch Server from httpserver import Server s = Server(8805) # construct server object s.activate() # server activate with try: s.wait_connections() # activate and run except KeyboardInterrupt: pass except Exception: machine.reset() pass
def __init__(self, fconf, handler): """ Initialize a MasterServer instance @param fconf the path to the configuration file @param handler the handler object in charge of managing HTTP requests """ Logger.__init__(self, "Manager") conf = json.load(open(fconf)) # Jinja2 initialization. tmpl_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates') self.env = Environment(loader=FileSystemLoader(tmpl_path)) self.status = ApplicationStatus() # This is a dictionary structure in the form # reduce_dict["group-name"] = [ # [ file list by unique integers, size in byte # ] => Reduce-0 # [ # ] => Reduce-1 # ] self.reduce_mark = set() self.reduce_dict = defaultdict(list) self.dead_reduce_dict = defaultdict(list) # This is a dictionary nick => Handler instance self.masters = {} self.last_id = -1 self.pending_works = defaultdict(list) # nick => [work, ...] self.ping_max = int(conf["ping-max"]) self.ping_interval = int(conf["ping-interval"]) self.num_reducer = int(conf["num-reducer"]) # This will just keep track of the name of the files self.reduce_files = [] self.results_printed = False for _ in range(self.num_reducer): self.reduce_files.append("N/A") # Load the input module and assing the generator to the work_queue module = load_module(conf["input-module"]) cls = getattr(module, "Input", None) # Some code for the DFS generator = cls(fconf).input() self.use_dfs = use_dfs = conf['dfs-enabled'] if use_dfs: dfsconf = conf['dfs-conf'] dfsconf['host'] = dfsconf['master'] self.path = conf['output-prefix'] else: dfsconf = None self.path = os.path.join( os.path.join(conf['datadir'], conf['output-prefix']) ) self.work_queue = WorkQueue(self.logger, generator, use_dfs, dfsconf) # Lock to synchronize access to the timestamps dictionary self.lock = Lock() self.timestamps = {} # nick => (send_ts:enum, ts:float) # Ping thread self.hb_thread = Thread(target=self.hearthbeat) # Event to mark the end of the server self.finished = Event() self.addrinfo = (conf['master-host'], conf['master-port']) Server.__init__(self, self.addrinfo[0], self.addrinfo[1], handler)