Example #1
0
def start(args):
    # Init logging
    if not args.wants_quiet:
        log_level = 'DEBUG' if args.wants_debug else 'INFO'

        get_log_manager().configure({
            'level': log_level,
            'console_enabled': True})

    # Let the user know we're in debug mode
    if args.wants_debug:
        _LOG.debug('Debug mode enabled.')

    # Start Pyrox
    start_pyrox(cfg=load_pyrox_config(args.upstream_host))
Example #2
0
def init():
    about_cb = project.about('chuckbox')

    if len(sys.argv) > 1:
        log.get_log_manager().configure({
            'level': 'DEBUG',
            'console_enabled': True})

        args = argparser.parse_args()

        if args.wants_version:
            print('chuckbox version: {}'.format(about_cb.version))
            sys.exit(0)

        if args.tool_name == 'pack':
            version_file = os.path.join(
                args.path, 'src/{name}/VERSION'.format(name=args.name))

            if not os.path.exists(version_file):
                print('Unable to locate version file: {vfile}'.format(
                    vfile=version_file))
                sys.exit(1)

            version = None

            with open(version_file, 'r') as vinfo:
                line = vinfo.readline()
                while line is not None:
                    if len(line) > 0:
                        version = line.strip()
                        break

            if version is None:
                print('No version info found in file: {vfile}'.format(
                    vfile=version_file))
                sys.exit(1)

            package.create(args.path, REQUIREMENTS_FILE, dict(),
                           args.name, version)
    else:
        argparser.print_help()
Example #3
0
File: main.py Project: zinic/rpyle
def init():
    log.get_log_manager().configure({
        'level': 'DEBUG',
        'console_enabled': True})

    about= project.about(__package__)
    _LOG.info('About: {}'.format(about.version))

    def start_webapp(randserve):
        app = rpyle.webservice.new_app(randserve)
        rpyle.http_server.serve(app)

    rpyle_server_comm, webserver_comm= mp.Pipe()

    webapp_proc = mp.Process(
        name='ryple_webserver',
        target=start_webapp,
        args=(webserver_comm,))
    webapp_proc.start()

    hasher = hashlib.new('sha1')

    rdata_pool = list()
    rdata_sources = [rpyle.system_provider.ProcessProvider([
            'arecord',
            '-f',
            'dat',
            '-B',
            '1024'
        ]),
        rpyle.system_provider.MemoryStatisticsProvider(),
        rpyle.system_provider.CPUStatisticsProvider()
    ]

    for source in rdata_sources:
        source.start()

    timeout = 0
    default_response = tuple()
    last_display_time = time.time()

    while True:
        entropy_amount = len(rdata_pool)
        if entropy_amount < 262144:
            had_ready_sources = False
            for source in rdata_sources:
                if source.ready():
                    had_ready_sources = True

                    rdata = source.read(64)
                    rdata_pool.extend(rdata)

            if had_ready_sources:
                timeout = 0
            else:
                timeout = 0.1
        else:
            timeout = 1

        now = time.time()
        if now - last_display_time > 7.5:
            last_display_time = now
            _LOG.info('Gathered {} bytes of entropy.'.format(entropy_amount))

        if rpyle_server_comm.poll(timeout):
            request = rpyle_server_comm.recv()
            response = default_response

            if isinstance(request, list) and len(request) > 0:
                command = request[0]

                if command == 'get':
                    if len(rdata_pool) > 128:
                        response = rdata_pool[:128]
                        rdata_pool = rdata_pool[128:]

            rpyle_server_comm.send(response)