Exemplo n.º 1
0
def main():
    parser = ConfigArgumentParser("TosPingPong", description="Application arguments",
                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument("--dest", default=AM_BROADCAST_ADDR, type=arg_hex2int,
                        help="Discover GUID of destination address")
    parser.add_argument("--guid", default="FFFFFFFFFFFFFFFF", type=arg_check_hex16str,
                        help="Discover address of GUID")

    parser.add_argument("--connection", default="sf@localhost:9002")
    parser.add_argument("--address", default=0xFFFE, type=arg_hex2int, help="Local address")
    parser.add_argument("--group", default=0x22, type=arg_hex2int, help="Local group")

    parser.add_argument("--response", action="store_true", default=False,
                        help="Send a response packet instead of a request")

    parser.add_argument("--debug", action="store_true", default=False)

    args = parser.parse_args()

    if args.debug:
        # todo setup moteconnection logging
        pass

    interrupted = threading.Event()

    def kbi_handler(sig, frm):
        del sig, frm
        interrupted.set()

    signal.signal(signal.SIGINT, kbi_handler)

    con = Connection()
    con.connect(args.connection, reconnect=5.0)

    disco = GUIDDisco(con, args)
    # disco.start()

    time.sleep(1)
    while not interrupted.is_set():
        disco.run()
        time.sleep(1)

    # disco.join()

    con.disconnect()
    con.join()

    print("done")
Exemplo n.º 2
0
                                  packet.src, packet.dest, packet.type)
            out = "{} ({:>3}/{:>3}/{:>3}) time={:>4.0f}ms delay={:>4.0f}ms uptime={:d}s {:s}".format(
                pout, p.ping_size, p.pong_size, p.pong_size_max, rtt, delay,
                p.uptime_s,
                p.padding.encode("hex").upper())

            print(out)

        except ValueError as e:
            printred("{} pong {}".format(self._ts_now(), e.message))


if __name__ == '__main__':

    parser = ConfigArgumentParser(
        "TosPingPong",
        description="Application arguments",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument("destination",
                        default=1,
                        type=arg_hex2int,
                        help="Ping destination")

    parser.add_argument("--count",
                        default=0,
                        type=int,
                        help="Ping count, 0 for unlimited")
    parser.add_argument("--interval",
                        default=1000,
                        type=int,
                        help="Ping interval (milliseconds)")
Exemplo n.º 3
0
def main():

    import argparse
    from argconfparse.argconfparse import ConfigArgumentParser, arg_str2bool
    parser = ConfigArgumentParser(
        "subsdatasink",
        description="datasink arguments",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)

    parser.add_argument("--db-host", default="localhost")
    parser.add_argument("--db-port", default=5432)
    parser.add_argument("--db-user", default="datasink")
    parser.add_argument("--db-pass", default="datasink")

    parser.add_argument("--api-host", default="0.0.0.0")
    parser.add_argument("--api-port", type=int, default=54320)
    parser.add_argument("--api-user", default="user")
    parser.add_argument("--api-pass", default="pass")

    parser.add_argument("--logdir", default="/var/log/subsdatasink")

    parser.add_argument("--http",
                        type=arg_str2bool,
                        nargs="?",
                        const=True,
                        default=False)
    parser.add_argument("--server-crt", default="server.crt")
    parser.add_argument("--server-key", default="server.key")

    parser.add_argument("--debug",
                        type=arg_str2bool,
                        nargs="?",
                        const=True,
                        default=False,
                        help="Configure logging.basicConfig")
    parser.add_argument("--debug-server",
                        type=arg_str2bool,
                        nargs="?",
                        const=True,
                        default=False,
                        help="Run app with Flask debug server")

    args = parser.parse_args()

    if args.debug:
        logging.basicConfig(level=logging.DEBUG)
    else:
        if not os.path.isdir(args.logdir):
            os.makedirs(args.logdir)

        ch = logging.handlers.TimedRotatingFileHandler(os.path.join(
            args.logdir, "subsdatasink.log"),
                                                       when="W6",
                                                       backupCount=8)
        ch.setLevel(logging.DEBUG)

        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

        ch.setFormatter(formatter)

        root_logger = logging.getLogger()
        root_logger.setLevel(logging.DEBUG)
        root_logger.addHandler(ch)

    if args.http:
        context = None
    else:
        import ssl
        # openssl genrsa -des3 -out server.key.secure 2048
        # openssl rsa -in server.key.secure -out server.key
        # openssl req -new -key server.key -out server.csr
        # openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

        context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
        context.load_cert_chain(args.server_crt, args.server_key)

    datasink = DataSinkPostgres(args.db_host, args.db_port, args.db_user,
                                args.db_pass)

    app = Flask(__name__, static_url_path="")
    api = Api(app)
    api.add_resource(DataSinkFlask,
                     '/api/v0/sink/<string:database>',
                     endpoint='datasink',
                     resource_class_args=({
                         args.api_user: args.api_pass
                     }, datasink))

    if args.debug_server:
        app.run(debug=args.debug,
                host=args.api_host,
                port=args.api_port,
                ssl_context=context)
    else:
        if args.debug:
            from tornado.log import enable_pretty_logging
            enable_pretty_logging()
        tornadoserver(app, args.api_host, args.api_port, context)