async def handleconnection(reader, writer):
    receivedrequest = await readhttpheaders(reader)
    log(receivedrequest)

    if "POST" in receivedrequest:  # this is causing the str and binary comparison warning
        await recpostsave(receivedrequest, reader, "POSTUPLOAD.txt")
        await servemessage(writer, "done")
        await writer.aclose()
        #await reader.aclose()  # this gets a keyerror
        convertsavepostfile("POSTUPLOAD.txt")
        return

    rpath = receivedrequest.get("GET")

    bcallaclose = True
    if "WebSocketKey" in receivedrequest:
        bcallaclose = await servewebsocket(rpath, reader, writer,
                                           receivedrequest["WebSocketKey"],
                                           wswritesensorloop)
    elif rpath is None:
        pass
    elif rpath == "":
        await servefilelist(writer)
    else:
        await servestaticfile(writer, rpath)

    if bcallaclose:
        await writer.aclose()
async def wswritesensorloop(rpath, writer, wscondition):
    rpath = rpath.split(",")

    delayms = int(rpath[1])
    hexbuff = bytearray(16)
    #if rpath[0] == "bme280":
    try:
        while wscondition[1]:
            while len(wscondition) > 2:
                incoming = wscondition.pop(2)
                log("[WS%d incoming] %s" % (wscondition[0], incoming))

            await writer.awrite(make_hybi07_header(16))
            ustruct.pack_into(">II", hexbuff, 8, hook_ms5611[1],
                              hook_ms5611[2])
            for i in range(8):
                b = hexbuff[i + 8]
                hexbuff[i * 2] = (b >> 4) + (48 if b < 160 else 55
                                             )  #ord('0')=48; ord('A')=65
                b &= 15
                hexbuff[i * 2 + 1] = b + (48 if b < 10 else 55)
            await writer.awrite(hexbuff)
            await uasyncio.sleep_ms(delayms)

    except OSError as e:
        elog(e)
        wscondition[1] = 1
    log("[WS%d wpleave]" % wscondition[0])
Пример #3
0
async def wsread(reader, wsid):
    while True:
        rex = await reader.readexactly(1)
        if len(rex) != 0:
            break
        log("[WS%d readexactly]" % wsid, [rex])
    opcode = (rex)[0] & 0x0F  # 8 means close
    if opcode == 8:
        log("[WS%d close]" % wsid)
        return None

    v = (await reader.readexactly(1))[0]
    masked = (v & 0x80)
    length = v & 0x7F
    if length == 0x7E:
        length = ustruct.unpack(">H", await reader.readexactly(2))[0]
    if length == 0x7F:
        length = ustruct.unpack(">Q", await reader.readexactly(8))[0]
    if masked:
        masked = await reader.readexactly(4)
    else:
        masked = b"\x00\x00\x00\x00"

    v = await reader.readexactly(length)
    v = bytes(k ^ masked[i % 4] for i, k in enumerate(v))
    return v
async def ams5611():
    log("Entering ams5611")
    bdat = open("b%d_%d.dat" % (powid, time.ticks_ms() // 1000), "wb")
    nbdat = 0
    try:
        dc = GetMS5611calibrations(i2c)
        readout = bytearray(3)
        while hook_ms5611[0]:
            await ams5611read(dc, readout, i2c, uasyncio)
            t = time.ticks_ms()
            hook_ms5611[2] = MS5611convert(dc)
            if bdat:
                nextpt(t, hook_ms5611[2] - 100000, bdat)
                nbdat += 1
                if nbdat > 10000:
                    bdat.close()
                    bdat = None
            if hook_ms5611[3]:  # dump out to logfile here (if open)
                hook_ms5611[3].write(
                    ustruct.pack("<II", hook_ms5611[1], hook_ms5611[2]))
                if (hook_ms5611[1] >> 13) != (t >> 13):  # 8 seconds
                    hook_ms5611[3].flush()
            hook_ms5611[1] = t
            greenpin.duty((t % 500) if hook_ms5611[3] or (((t // 500) %
                                                           3) == 0) else 0)
    except Exception as e:
        elog(e)
    hook_ms5611[0] = -1
    log("Leaving ams5611")
Пример #5
0
 def update(self, table, key, value, where=""):
     qstr = "UPDATE {0} SET {1}='{2}'".format(table, key, value)
     if where: qstr += " WHERE {0}".format(where)
     try:
         self.execute(qstr)
         self.db.commit()
         return self.cur.lastrowid
     except Exception, e:
         log(LOG_INFO, "{0}: database.Sqlite3Database.update: Exception occurred when updating {1}: {2}".format(self.session, table, e))
async def recpostsave(receivedrequest, reader, fname):
    rpath = receivedrequest["POST"]
    fsize = int(receivedrequest["Content-Length"])
    log("recpostsave", str(fsize))
    fout = open(fname, "wb")
    while fsize > 0:
        fb = await reader.read(min(fsize, 20))
        fout.write(fb)
        fsize -= len(fb)
    fout.close()
Пример #7
0
 def update_d(self, table, d, where=""):
     set_str = ", ".join(["{0}='{1}'".format(x, y) for x, y in d.iteritems()])
     qstr = "UPDATE {0} SET {1}".format(table, set_str)
     if where: qstr += " WHERE {0}".format(where)
     try:
         self.execute(qstr)
         self.db.commit()
         return self.cur.lastrowid
     except Exception, e:
         log(LOG_INFO, "{0}: database.Sqlite3Database.update_d: Exception occurred when updating {1}: {2}".format(self.session, table, e))
Пример #8
0
 def grow(self, size):
     # size is in MB
     # make sure that 20% over current usage is preallocated
     fh = util.createUnlinkedTmpFile(self._path)
     usage = self._getFileSystemUsage()
     while self._allocated < 1.2 * usage:
         util.growFile(fh, size)
         self._allocated += size
         log('growing %s to %sMB' % (self._path, self._allocated))
     fh.close()
Пример #9
0
 def grow(self, size):
     # size is in MB
     # make sure that 20% over current usage is preallocated
     fh = util.createUnlinkedTmpFile(self._path)
     usage = self._getFileSystemUsage()
     while self._allocated < 1.2 * usage:
         util.growFile(fh, size)
         self._allocated += size
         log('growing %s to %sMB' % (self._path, self._allocated))
     fh.close()
Пример #10
0
def clear_speedtest():
    if os.path.isfile(SPEEDTEST_LOCK_FILE):
        try:
            os.unlink(SPEEDTEST_LOCK_FILE)
        except:
            syslog.log("Unable to remove speed test lock file.")
    if os.path.isfile(SPEEDTEST_RESULTS_FILE):
        try:
            os.unlink(SPEEDTEST_RESULTS_FILE)
        except IOError:
            syslog.log("Unable to remove speed test results file.")
Пример #11
0
 def start(self):
     """ Every 5min try to allocate more space. """
     # Wait a couple of minutes before starting allocation to let the
     # machine finish booting.
     log('sleeping 120s before growing filesystems')
     time.sleep(120)
     while True:
         for fs in self._fs:
             fs.grow(self._size)
         log('sleeping 300s')
         time.sleep(300)
Пример #12
0
 def start(self):
     """ Every 5min try to allocate more space. """
     # Wait a couple of minutes before starting allocation to let the
     # machine finish booting.
     log('sleeping 120s before growing filesystems')
     time.sleep(120)
     while True:
         for fs in self._fs:
             fs.grow(self._size)
         log('sleeping 300s')
         time.sleep(300)
def bme280init(i2c):
    k = i2c.readfrom_mem(0x77, 0xD0, 1)
    if k != b'\x60':
        log("bme280 chip not found")
        return False
    i2c.writeto_mem(0x77, 0xF2, b'\x01')  # switch on humidity (over)sampling=1
    i2c.writeto_mem(
        0x77, 0xF4, b'\x27'
    )  # switch on temp and pressure (over)sampling=1, mode=normal(continuous readings)
    i2c.writeto_mem(0x77, 0xF5, b'\x00')  # 0.5ms standby, no filtering, no-SPI
    return True
Пример #14
0
 def __init__(self, config_path):
     log(syslog.LOG_INFO, "starting service...")
     self._prepare()
     
     self.config = Config(config_path)
     
     self.xorg_server = XorgServer(self.config)
     
     system_bus = dbus.SystemBus()
     self.name = dbus.service.BusName("org.bumblepyy", system_bus)
     
     dbus.service.Object.__init__(self, system_bus, '/BumblePyy')
Пример #15
0
 def __init__(self, config):
     self.args = ":%s -config %s -sharevts -nolisten tcp -noreset -configdir /dev/null %s" % (
         config.x_display,
         config.x_config,
         config.system.x_args
     )
     
     self._thread = None
     self._proc = None
     
     self._library_path = config.system.library_path
     
     log(syslog.LOG_INFO, "X.Org server ready")
Пример #16
0
 def create_call(self, src, dst, cid, context, xid="None"):
     try:
         self.ami.originate(
             "SIP/1{0}@outbound".format(src),
             dst,
             context,
             '1',
             '',
             cid,
             True,
             xid
         )
     except Exception, e:
         log(LOG_ERR, "Exception occurred in create_call: {0}".format(e))
Пример #17
0
 def send(self, src, dst, msg):
     msg = msg.replace("<br />", "\r\n")
     msg = re.sub("<.*?>", "", msg)
     success = self.sendsms(src, dst, msg)
     if not success:
         raise SMSSendFailed(
             "sms: Failed to send message from {0} to {1}".format(src,
                                                                  dst))
     else:
         log(LOG_INFO,
             "SMS Send success: SRC: {0}, DST: {1} ->  {2}".format(src,
                                                                   dst,
                                                                   success))
     return success
async def createLogFile():
    ti = 0
    while hook_ms5611:
        ti = (ti + 1 if touchpin.read() < 1100 else 0)
        if ti > 3:
            log("making datfile")
            hook_ms5611[3] = open(
                "%d_%d.dat" % (powid, time.ticks_ms() // 1000), "wb")
            for i in range(12 * 10):  # 10 minutes
                await uasyncio.sleep_ms(5 * 1000)  # 5 second chunks
                if touchpin.read() < 1100:
                    break  # break early
            hook_ms5611[3].close()
            hook_ms5611[3] = None
            await uasyncio.sleep_ms(5 * 1000)  # pause before activating again
        await uasyncio.sleep_ms(50)
Пример #19
0
async def wsreadprintloop(reader, wscondition):
    while wscondition[1]:
        try:
            res = await wsread(reader, wscondition[0])
        except OSError as e:
            print("[WS%d wsreadexception] %s" % (wscondition[0], str(e)))
            res = None

        if res is None:
            wscondition[1] = 0  # closed condition
            break
        log("[WS%d]" % wscondition[0], res)

        # pass any important messages through into this sequence!
        # (not seen as a signal, but picked up next time that task wakes up)
        wscondition.append(res)

    log("[WS%d rlleave]" % wscondition[0])
Пример #20
0
 def stop(self):
     if self._thread != None and self._thread.isAlive():
         log(syslog.LOG_DEBUG, "Trying to stop X.Org...")
         self._proc.send_signal(signal.SIGTERM)
         self._thread.join(timeout=3)
         if self._thread.isAlive():
             log(syslog.LOG_WARNING, "X.Org couldn't be stopped, killing")
             self._proc.kill()
             self._thread.join(timeout=5)
             if self._thread.isAlive():
                 log(syslog.LOG_ERR, "X.Org couldn't be killed")
                 return False
             else:
                 log(syslog.LOG_WARNING, "X.Org killed")
         else:
             log(syslog.LOG_DEBUG, "X.Org stopped")
     
     return True
Пример #21
0
    def select(self, table, keys="*", where="", fetchall = False, as_dict = False, order_by=""):
        if keys == "*":
            keys = ", ".join([x[1] for x in self.execute("PRAGMA table_info({0})".format(table)).fetchall()])
        else:
            keys = ", ".join(keys)
        qstr = "SELECT {0} FROM {1}".format(keys, table)

        if where:
            qstr += " WHERE {0}".format(where)

        if order_by:
            qstr += " ORDER BY {0}".format(order_by)

        try:
            res = self.execute(qstr)
            if not as_dict:
                if fetchall:
                    return res.fetchall()
                return res.fetchone()
            else:
                keys = keys.split(", ")
                if fetchall:
                    d = []
                    for row in res.fetchall():
                        temp = {}
                        if not row:
                            continue
                        t = zip(keys, row)
                        [temp.__setitem__(x, y) for x, y in t]
                        d.append(temp)
                else:
                    d = {}
                    row = res.fetchone()
                    if not row:
                        return {}
                    row = zip(keys, row)
                    [d.__setitem__(x, y) for x, y in row]
                return d

        except Exception, e:
            log(LOG_INFO, "{0}: database.Sqlite3Database.select: Exception occurred when selecting {1} from {2}: {3}".format(self.session, keys, table, e))
async def handleconnection(reader, writer):
    receivedrequest = await readhttpheaders(reader)

    if "POST" in receivedrequest:
        await recpostsave(receivedrequest, reader, "POSTUPLOAD.txt")
        await servemessage(writer, "done")
        await writer.aclose()
        convertsavepostfile("POSTUPLOAD.txt")
        return

    rpath = receivedrequest.get("GET")
    log(receivedrequest)

    bcallaclose = True
    if rpath == "":
        await servefilelist(writer)
    elif rpath:
        await servestaticfile(writer, rpath)

    if bcallaclose:
        await writer.aclose()
Пример #23
0
  def run(self, name, password):
    if doomrl.user():
      return 'You are already logged in!'

    if not name or not password:
      return 'You must specify both a username and a password.'

    # Check password
    try:
      with open(doomrl.homepath('passwd', user=name)) as f:
        passwd = f.read()
      if passwd == password:
        log('%s successfully logged in.' % name)
        doomrl.login(name)
        return
    except IOError as e:
      pass

    log('Failed login attempt as %s' % name)
    doomrl.login()
    return 'Login failed.'
Пример #24
0
    def connect(self, path):
        if not os.path.exists(path):
            log(LOG_INFO, "{0}: database.Sqlite3Database.connect: {1} doesn't exist. Creating it".format(self.session, path))
            db = sql.connect(path)
            cur = db.cursor()

            create = [
                (
                      "CREATE TABLE users("
                      "rowID INTEGER PRIMARY KEY AUTOINCREMENT, "
                      "username VARCHAR, "
                      "phonenumber VARCHAR UNIQUE, "
                      "extension VARCHAR, "
                      "secret VARCHAR"
                      ")"
                ),

                (
                      "CREATE TABLE entry("
                      "rowID INTEGER PRIMARY KEY AUTOINCREMENT, "
                      "game INTEGER, "
                      "phonenumber VARCHAR, "
                      "result VARCHAR, "
                      "UNIQUE(game, phonenumber) ON CONFLICT ABORT"
                      ")"
                )
            ]

            try:
                for stmt in create:
                    log(LOG_INFO, "{0}: database.Sqlite3Database: Executing statement: {1}".format(self.session, stmt))
                    cur.execute(stmt)
                db.commit()
            except Exception, e:
                log(LOG_INFO, "{0}: database.Sqlite3Database: Failed to create tables: {1}".format(self.session, e))
async def servestaticfile(w, lpath, fsize=0):
    try:
        if fsize == 0:
            try:
                fsize = os.stat(lpath)[6]
            except OSError:
                pass
        if fsize == 0:
            log("File '%s' not found"%(lpath))
            await w.awrite(b"HTTP/1.0 404 Not found\r\n\r\n")
            await w.awrite(b"File '%s' not found" % lpath.encode())
            return
        
        await w.awrite(b"HTTP/1.0 200 OK\r\n")
        lfext = lpath[lpath.rfind(".")+1:]
        await w.awrite(b"Content-Type: %s\r\n" % contenttypes.get(lfext, "text/plain; charset=utf-8"))
        if lfext == "js" and fsize > 20000:
            await w.awrite(b"Cache-Control: max-age=31536000\r\n")
        await w.awrite(b"Content-Length: %d\r\n" % fsize)
        await w.awrite(b"\r\n")

        #fsize = os.stat(lpath)[6]
        fin = open(lpath, "rb")
        
        t0 = time.ticks_ms()
        bs = bytearray(60)
        Dn = 0
        for i in range(int((fsize-1)/len(bs))):
            fin.readinto(bs)
            await w.awrite(bs)
            Dn += len(bs)
        nbs = fin.readinto(bs)
        Dn += nbs
        await w.awrite(bs, sz=nbs)
        td = time.ticks_ms() - t0
        log("File '%s' (%d bytes) served in %dms"%(lpath, fsize, td))
    except OSError as e:
        elog(e)
Пример #26
0
    def run(self, name):
        if not doomrl.user():
            return 'You must log in first.'

        if not name:
            return self.list_running_games()

        # We can be a bit looser about names here, but for simplicity's sake we
        # just reuse the name validation code we use for player names.
        if not doomrl.name_valid(name):
            return 'Invalid save name.'

        # Check that they aren't already playing *right now*.
        self.recfile = doomrl.homepath('ttyrec')
        if exists(self.recfile):
            return 'You are already playing in another window! Quit that game first.'

        (scores, mortem) = self.setup(name)
        try:
            self.run_doomrl()

        except OSError as e:
            # This almost certainly means that the user disconnected in mid-game.
            # Don't try to output any error messages, they'll just throw again because
            # our tty is gone.
            if self.child and (self.child.poll() is None):
                self.child.kill()
                self.child = None
            # Call _exit rather than using sys.exit so we don't try to run finalizers.
            os._exit(1)

        except Exception as e:
            import traceback
            log('Error running DoomRL: ' + traceback.format_exc())
            traceback.print_exc()
            sys.exit(1)
        finally:
            self.shutdown(name, scores, mortem)
Пример #27
0
  def run(self, name):
    if not doomrl.user():
      return 'You must log in first.'

    if not name:
      return self.list_running_games()

    # We can be a bit looser about names here, but for simplicity's sake we
    # just reuse the name validation code we use for player names.
    if not doomrl.name_valid(name):
      return 'Invalid save name.'

    # Check that they aren't already playing *right now*.
    self.recfile = doomrl.homepath('ttyrec')
    if exists(self.recfile):
      return 'You are already playing in another window! Quit that game first.'

    (scores,mortem) = self.setup(name)
    try:
      self.run_doomrl()

    except OSError as e:
      # This almost certainly means that the user disconnected in mid-game.
      # Don't try to output any error messages, they'll just throw again because
      # our tty is gone.
      if self.child and (self.child.poll() is None):
        self.child.kill()
        self.child = None
      # Call _exit rather than using sys.exit so we don't try to run finalizers.
      os._exit(1)

    except Exception as e:
      import traceback
      log('Error running DoomRL: ' + traceback.format_exc())
      traceback.print_exc()
      sys.exit(1)
    finally:
      self.shutdown(name, scores, mortem)
def convertsavepostfile(pname):
    lgen = flinesplitgen(pname, 80)
    linebreakhash = uhashlib.sha1(next(lgen)).digest()

    # get the headers
    for l in lgen:
        if l == b'\r\n':
            break
        k, v = bytes(l).split(b":")
        if k == b'Content-Disposition':
            for s in v.split(b";"):
                se = s.strip().split(b"=", 1)
                if len(se) == 2:
                    if se[0] == b"filename":
                        filename = se[1].strip(b'"').decode()

    log("convpostfile", filename)
    fout = open(filename, "wb")
    prelinebreak = b""  # used to handle the linebreak before the breakline
    for l in lgen:
        linehash = uhashlib.sha1(l).digest()
        if linehash == linebreakhash:
            if not prelinebreak:
                print("where the prelinebreak?")
            break
        if prelinebreak:
            fout.write(prelinebreak)
            prelinebreak = b""
        if len(l) == 2:
            prelinebreak = bytes(l)
            if prelinebreak != b"\r\n":
                prelinebreak = b""
        if not prelinebreak:
            fout.write(l)
            
    fout.close()
    os.remove(pname)
    
Пример #29
0
    def run_doomrl(self):
        if exists(doomrl.datapath('ttysound', 'libSDL_mixer-1.2.so.0')):
            cmd = ['./doomrl']
            env = {
                **os.environ,
                "LD_LIBRARY_PATH": doomrl.datapath('ttysound'),
                "SDL_AUDIODRIVER": 'disk',
                'SDL_DISKAUDIOFILE': '/dev/null',
            }
        else:
            cmd = ['./doomrl', '-nosound']
            env = os.environ

        (rpipe, wpipe) = os.pipe()
        self.child = subprocess.Popen(cmd,
                                      stdout=wpipe,
                                      env=env,
                                      cwd=doomrl.homepath())
        os.close(wpipe)

        # DoomRL needs the terminal in raw mode, but since it's running inside ttyrec
        # it can't control that setting.
        tty.setraw(1)

        with TTYRec(self.recfile) as rec:
            # This will return when DoomRL closes the fd.
            # It will also automatically reset the TTY on leaving the 'with' block.
            rec.ttyrec(in_fd=rpipe)
        try:
            self.child.wait()
        except Exception as e:
            import traceback
            log('Error while DoomRL was running: ' + traceback.format_exc())
            self.child.kill()
            raise e
        self.child = None
Пример #30
0
 def start(self):
     if self.running():
         return True
     
     log(syslog.LOG_INFO, "Starting X.Org server...")
     
     self._thread = threading.Thread(target=self._run)
     self._thread.start()
     
     time.sleep(1)
     
     if self._thread.isAlive():
         log(syslog.LOG_INFO, "X.Org server started")
     else:
         log(syslog.LOG_ERR, "X.Org server cannot be started")
     return self._thread.isAlive()
Пример #31
0
 def _run(self):
     self._proc = Popen("X "+self.args, shell=True, stderr=subprocess.PIPE, env={
         "LD_LIBRARY_PATH": self._library_path
     })
     
     for line in self._proc.stderr:
         log(syslog.LOG_DEBUG, "[xorg] %s" % (line.strip(),))
     
     self._proc.stderr.close()
     self._proc.kill()
     
     status = self._proc.wait()
     if status == 0:
         log(syslog.LOG_INFO, "X.Org was successfully stopped")
     else:
         log(syslog.LOG_WARNING, "X.Org ended with status %d" % (status,))
     
     self._proc = None
Пример #32
0
  def run(self, name, password):
    # Check name validity
    if not doomrl.name_valid(name):
      return 'Invalid name.'

    # Check that password was specified
    if not password:
      return 'No password specified.'

    # Try to create user directory and die if we can't
    try:
      os.mkdir(doomrl.homepath(user=name))
    except OSError as e:
      return 'That name is unavailable.'

    # Fill in user directory
    log('Creating a new account: %s' % name)
    print('Creating user account.')
    try:
      doomrl.login(name)
      self.install(password)
    except Exception as e:
      doomrl.login()
      log('Error creating account %s: %s' % (name, e))
      print('Error creating user directory.')
      print('Report this to the server administrator.')
      if doomrl.debug():
        raise e
      try:
        shutil.rmtree(doomrl.homepath(user=name))
      except OSError as e:
        log('Error cleaning up account %s: %s' % (name, e))
        print('Error cleaning up the half-created user directory! This username is unavailable until the admin fixes things.')
      return 'Unable to create user.'

    return
Пример #33
0
  def run(self, name, password):
    # Check name validity
    if not doomrl.name_valid(name):
      return 'Invalid name.'

    # Check that password was specified
    if not password:
      return 'No password specified.'

    # Try to create user directory and die if we can't
    try:
      os.mkdir(doomrl.homepath(user=name))
    except OSError as e:
      return 'That name is unavailable.'

    # Fill in user directory
    log('Creating a new account: %s' % name)
    print('Creating user account.')
    try:
      doomrl.login(name)
      self.install(password)
    except Exception as e:
      doomrl.login()
      log('Error creating account %s: %s' % (name, e))
      print('Error creating user directory.')
      print('Report this to the server administrator.')
      if doomrl.debug():
        raise e
      try:
        shutil.rmtree(doomrl.homepath(user=name))
      except OSError as e:
        log('Error cleaning up account %s: %s' % (name, e))
        print('Error cleaning up the half-created user directory! This username is unavailable until the admin fixes things.')
      return 'Unable to create user.'

    return
Пример #34
0
def requestCaption(session, uuid, path, method="PREMIUM"):
    reference = uuid
    callback = CALLBACK
    apikey = KEY
    try:
        duration = getAudioDuration(path)
    except:
        duration = 10
    log(LOG_INFO,
        "{0}: mycaption.requestCaption: Sending {1} for MyCaption transcription".format(
            session, path))

    fmt = getFormat(path)
    if not fmt:
        raise Exception("Unable to determine file format")

    log(LOG_INFO,
        "{0}: mycaption.requestCaption: File format: {1}".format(session, fmt))

    if method == 'ASR':
        api = MYCAPTION_ASR_API
    else:
        api = MYCAPTION_PREMIUM_API

    url = genURL(apikey, duration, reference, fmt, callback, url=api)
    if not url:
        raise Exception("Unable to generate URL")

    data = open(path, 'rb').read()
    size = len(data)
    if size <= 100:
        log(LOG_INFO,
            "{0}: mycaption.requestCaption: File size indicates empty file!".format(
                session))
        return False
    log(LOG_INFO,
        "{0}: mycaption.requestCaption: Read in {1} bytes of audio data".format(
            session, size))

    headers = {'content-type': 'application/octet-stream'}
    log(LOG_INFO,
        "{0}: mycaption.requestCaption: Sending request to MyCaption".format(
            session))
    res = requests.post(url=url, data=data, headers=headers)
    log(LOG_INFO,
        "{0}: mycaption.requestCaption: Got a response! {1}".format(session,
                                                                    res.content))
    try:
        response = json.loads(res.content)
    except:
        response = {}

    if 'status' in response and response['status'] == '200':
        for key, value in response.iteritems():
            log(LOG_INFO,
                "{0}: mycaption.requestCaption: {1} - {2}".format(session, key,
                                                                  value))
        return True
    else:
        log(LOG_INFO,
            "{0}: mycaption.requestCaption: Transmission failed.".format(
                session))
    return False
Пример #35
0
 def execute(self, qstr):
     log(LOG_INFO, "database.Sqlite3Database.execute: EXECUTING: {0}".format(qstr))
     return self.cur.execute(qstr)
Пример #36
0
def speedtest_worker(sio):
    def run_thread(t, timeout_seconds):
        timeout_time = time.time() + timeout_seconds
        t.start()
        while t.isAlive() and time.time() < timeout_time:
            time.sleep(0.25)
        if t.isAlive():
            timed_out = True
        else:
            timed_out = False
        return timed_out

    ABORT_SPEEDTEST = False
    servers = []
    s = Speedtest()
    try:
        sio.emit('speedtest', '{ "progress": "getservers" }', broadcast=False)
    except IOError:
        pass

# get a speedtest server
    t = threading.Thread(target=s.get_servers, args=(servers, ))

    thread_timed_out = run_thread(t, SPEEDTEST_GETSERVERS_TIMEOUT)
    if thread_timed_out:
        try:
            sio.emit('speedtest',
                     '{ "error": "Timeout while getting server list."}',
                     broadcast=False)
            ABORT_SPEEDTEST = True
        except:
            pass

    if not ABORT_SPEEDTEST:
        t = threading.Thread(target=s.get_best_server)
        thread_timed_out = run_thread(t, SPEEDTEST_GETSERVERS_TIMEOUT)
        if thread_timed_out:
            try:
                sio.emit('speedtest',
                         '{"error" : "Timeout while getting best server."}',
                         broadcast=False)
                ABORT_SPEEDTEST = True
            except:
                pass

    if not ABORT_SPEEDTEST:
        try:
            sio.emit('speedtest',
                     '{ "progress": "download" }',
                     broadcast=False)
        except IOError:
            pass
        t = threading.Thread(target=s.download)
        thread_timed_out = run_thread(t, SPEEDTEST_DOWNLOAD_TIMEOUT)
        if thread_timed_out:
            try:
                sio.emit('speedtest',
                         '{"error" : "Timeout while testing download speed."}',
                         broadcast=False)
                ABORT_SPEEDTEST = True
            except:
                pass

    if not ABORT_SPEEDTEST:
        try:
            sio.emit('speedtest', '{ "progress": "upload" }', broadcast=False)
        except IOError:
            pass
        t = threading.Thread(target=s.upload)
        thread_timed_out = run_thread(t, SPEEDTEST_UPLOAD_TIMEOUT)
        if thread_timed_out:
            try:
                sio.emit('speedtest',
                         '{"error" : "Timeout while testing upload speed."}',
                         broadcast=False)
                ABORT_SPEEDTEST = True
            except:
                pass

    if not ABORT_SPEEDTEST:
        output = s.results.dict()
        speedtestResults = {}
        speedtestResults['results'] = output
        try:
            sio.emit('speedtest', json.dumps(speedtestResults), broadcast=True)
        except IOError:
            pass

        try:
            # save results to a file
            outfile = open(SPEEDTEST_RESULTS_FILE, 'w')
            json.dump(output, outfile)
        except IOError:
            syslog.log("Unable to create / write to speed test results file.")

    try:
        # remove lock file
        os.unlink(SPEEDTEST_LOCK_FILE)
    except IOError:
        syslog.log("Unable to remove speed test lock file")
from webserve_funcs import convertsavepostfile

from websocket_funcs import make_hybi07_header
from websocket_funcs import servewebsocket

from ms5611 import GetMS5611calibrations, MS5611convert, ams5611read
from ds3231 import rtctojsepoch, jsepochtoisodate

import machine, array
i2c = machine.I2C(scl=machine.Pin(5), sda=machine.Pin(4))

greenpin = machine.PWM(machine.Pin(13), freq=1024, duty=40)
touchpin = machine.TouchPad(machine.Pin(33))

jsepochoffset = rtctojsepoch(i2c, busywaitsec=True) - time.ticks_ms()
log(jsepochtoisodate(jsepochoffset))

# enable the wifi only if entry is held down on startup
ipnumber = ""
for i in range(10):
    if touchpin.read() > 1100:
        break
    greenpin.duty(500 if ((i % 2) == 0) else 0)
    time.sleep_ms(200)
    touchpin.read()
else:
    # this should be deferred or made on-off
    for i in range(20):
        greenpin.duty(500 if ((i % 2) == 0) else 0)
        time.sleep_ms(50)
Пример #38
0
    def rush_hero_logic(self, things, t):
        enemy_team = settings.ENEMY_TEAMS[self.team]
        enemies = [
            thing for thing in things.values() if thing.team == enemy_team
        ]
        enemy_ancient = [e for e in enemies if e.name == 'ancient'][0]
        enemy_tower = [e for e in enemies if e.name == 'tower']
        if enemy_tower: enemy_tower = enemy_tower[0]
        enemy_hero = [e for e in enemies if e.__class__.__name__ == "Hero"]
        if enemy_hero: enemy_hero = enemy_hero[0]
        closest_enemy = closest(self, enemies)
        closest_enemy_distance = distance(self, closest_enemy)

        friends = [
            thing for thing in things.values()
            if thing.team == self.team and thing != self
        ]
        friendly_ancient = [e for e in friends if e.name == 'ancient'][0]
        back_friends = sort_by_distance(self, friends)[2:]
        closest_friend = closest(self, friends)
        closest_friend_distance = distance(self, closest_friend)

        # I'm offside if there are not at least 2 friendlies in front of me
        offside = closest(enemy_ancient, back_friends + [self]) == self

        # There are enemy units behind me
        enemy_offside = closest(friendly_ancient, enemies + [self]) != self
        #        log("offside: "+ str(offside))
        #        log("friend: %s, enemy: %s" % (str(closest_friend), str(closest_enemy)))

        # if I can stun the other hero, that's highest priority
        if closest_enemy and closest_enemy == enemy_hero\
           and closest_enemy_distance <= settings.STUN_DISTANCE and self.can('stun', t):
            # try to stun him
            log('stun !!!')
            return 'stun', closest_enemy.position

        # move to get conver if I'm low on energy or there's an enemy behind me
        if (offside and self.life < 200):  # or enemy_offside:
            moves = sort_by_distance(friendly_ancient,
                                     valid_positions(self, things))
            return 'move', moves[0]

        if self.life < (self.max_life - settings.HEAL_BASE_HEALING[1]) and self.can('heal', t)\
           and (closest_friend and closest_friend_distance <= settings.HEAL_DISTANCE):
            log("heal")
            return 'heal', self.position

        else:
            if closest_enemy:
                # there is an enemy
                #                if closest_enemy_distance <= settings.FIREBALL_DISTANCE and self.can('fireball', t) and closest_enemy_distance > settings.FIREBALL_RADIUS and closest_friend_distance > (settings.FIREBALL_DISTANCE + settings.FIREBALL_RADIUS):
                if self.can('fireball', t) and closest_enemy_distance < settings.FIREBALL_DISTANCE +settings.FIREBALL_RADIUS\
                   and closest_enemy_distance > settings.FIREBALL_RADIUS\
                   and distance(closest_friend, closest_enemy) > settings.FIREBALL_RADIUS:

                    # else try to fireball him, but only if I'm not in range
                    log("fireball !!!")
                    return 'fireball', closest_enemy.position
                elif closest_enemy_distance <= settings.HERO_ATTACK_DISTANCE:
                    # else try to attack him
                    log("attack")
                    return 'attack', closest_enemy.position

                else:
                    if enemy_tower:
                        if distance(self, enemy_tower) < 5:
                            log("halt")
                            return
                    moves = sort_by_distance(enemy_ancient,
                                             valid_positions(self, things))
                    return 'move', moves[0]
Пример #39
0
 def run(self):
     log(syslog.LOG_INFO, "running")
     self.mainloop.run()
     
Пример #40
0
 def shutdown(self, sig, frame):
     log(syslog.LOG_INFO, "shutdown requested")
     self.remove_from_connection()
     self.mainloop.quit()
     self.xorg_server.stop()
     syslog.closelog()
Пример #41
0
 def disable(self):
     if not self.xorg_server.stop():
         log(syslog.LOG_ERR, "X.Org server cannot be stopped")
     return False
     
     return True
si = network.WLAN(network.STA_IF)
macaddress = "".join("{:02x}".format(x) for x in si.config("mac"))
si.active(True)

# wificodes are lines in form "name:password:"******":")[:2] for k in open("wificodes.txt", "rb"))
print("Scanning wifis:", ", ".join(s.decode() for s in knownwifis))

# X[3]=RSSI (received signal strength)
wifiname = max((sc for sc in si.scan() if sc[0] in knownwifis),
               key=lambda X: X[3],
               default=[None])[0]

if wifiname is not None:
    log("Strongest wifi", wifiname.decode())
    si.connect(wifiname, knownwifis[wifiname])
    del knownwifis

    while not si.isconnected():
        pass

    ipnumber = si.ifconfig()[0]

else:
    log("No recognized wifi")
    si = network.WLAN(network.AP_IF)  # create access-point interface
    si.active(True)  # activate the interface
    log("Creating access point ESP_{}".format(macaddress[-6:]))
    ipnumber = si.ifconfig()[0]
Пример #43
0
    def rush_hero_logic(self, things, t):
        enemy_team = settings.ENEMY_TEAMS[self.team]
        enemies = [thing for thing in things.values()
                   if thing.team == enemy_team]
        enemy_ancient = [e for e in enemies if e.name == 'ancient'][0]
        enemy_tower = [e for e in enemies if e.name == 'tower']
        if enemy_tower: enemy_tower = enemy_tower[0]
        enemy_hero = [e for e in enemies if e.__class__.__name__ == "Hero"]
        if enemy_hero: enemy_hero = enemy_hero[0]
        closest_enemy = closest(self, enemies)
        closest_enemy_distance = distance(self, closest_enemy)

        friends = [thing for thing in things.values()
                   if thing.team == self.team and thing != self]
        friendly_ancient = [e for e in friends if e.name == 'ancient'][0]
        back_friends = sort_by_distance(self, friends)[2:]
        closest_friend = closest(self, friends)
        closest_friend_distance = distance(self, closest_friend)
        
        # I'm offside if there are not at least 2 friendlies in front of me
        offside = closest(enemy_ancient, back_friends + [self]) == self 

        # There are enemy units behind me
        enemy_offside = closest(friendly_ancient, enemies + [self]) != self 
#        log("offside: "+ str(offside))
#        log("friend: %s, enemy: %s" % (str(closest_friend), str(closest_enemy)))

        # if I can stun the other hero, that's highest priority
        if closest_enemy and closest_enemy == enemy_hero\
           and closest_enemy_distance <= settings.STUN_DISTANCE and self.can('stun', t):
            # try to stun him
            log('stun !!!')
            return 'stun', closest_enemy.position

        # move to get conver if I'm low on energy or there's an enemy behind me
        if (offside and self.life < 200):# or enemy_offside:
            moves = sort_by_distance(friendly_ancient, valid_positions(self, things))
            return 'move', moves[0]

        if self.life < (self.max_life - settings.HEAL_BASE_HEALING[1]) and self.can('heal', t)\
           and (closest_friend and closest_friend_distance <= settings.HEAL_DISTANCE):
            log("heal")
            return 'heal', self.position

        else:
            if closest_enemy:
                # there is an enemy
#                if closest_enemy_distance <= settings.FIREBALL_DISTANCE and self.can('fireball', t) and closest_enemy_distance > settings.FIREBALL_RADIUS and closest_friend_distance > (settings.FIREBALL_DISTANCE + settings.FIREBALL_RADIUS):
                if self.can('fireball', t) and closest_enemy_distance < settings.FIREBALL_DISTANCE +settings.FIREBALL_RADIUS\
                   and closest_enemy_distance > settings.FIREBALL_RADIUS\
                   and distance(closest_friend, closest_enemy) > settings.FIREBALL_RADIUS:

                    # else try to fireball him, but only if I'm not in range
                    log("fireball !!!")
                    return 'fireball', closest_enemy.position
                elif closest_enemy_distance <= settings.HERO_ATTACK_DISTANCE:
                    # else try to attack him
                    log("attack")
                    return 'attack', closest_enemy.position


                else:
                    if enemy_tower:
                        if distance(self,enemy_tower) < 5:
                            log("halt")
                            return
                    moves = sort_by_distance(enemy_ancient, valid_positions(self, things))
                    return 'move', moves[0]