Exemple #1
0
def main():  # pragma: no cover
    logger.info('Starting docker-pygen ...')

    kwargs = parse_arguments().__dict__

    if kwargs.get('debug'):
        set_log_level('DEBUG')

    logger.debug('Startup arguments: %s',
                 ', '.join('%s=%s' % item for item in kwargs.items()))

    app = PyGen(**kwargs)

    setup_signals(app)

    logger.debug('Signal handlers set up for SIGTERM, SIGINT and SIGHUP')

    try:
        app.update_target()

        logger.debug('Starting event watch loop')

        app.watch()

    finally:
        logger.info('Exiting...')

        app.stop()
def main():
    parser = argparse.ArgumentParser(description="""
        Pull binaries needed by perf.data from device to binary_cache directory."""
                                     )
    parser.add_argument('-i',
                        '--perf_data_path',
                        default='perf.data',
                        type=extant_file,
                        help="""
        The path of profiling data.""")
    parser.add_argument('-lib',
                        '--native_lib_dir',
                        type=extant_dir,
                        nargs='+',
                        help="""
        Path to find debug version of native shared libraries used in the app.""",
                        action='append')
    parser.add_argument('--disable_adb_root',
                        action='store_true',
                        help="""
        Force adb to run in non root mode.""")
    parser.add_argument('--ndk_path',
                        nargs=1,
                        help='Find tools in the ndk path.')
    parser.add_argument('--log',
                        choices=['debug', 'info', 'warning'],
                        default='info',
                        help='set log level')
    args = parser.parse_args()
    set_log_level(args.log)
    ndk_path = None if not args.ndk_path else args.ndk_path[0]
    builder = BinaryCacheBuilder(ndk_path, args.disable_adb_root)
    symfs_dirs = flatten_arg_list(args.native_lib_dir)
    builder.build_binary_cache(args.perf_data_path, symfs_dirs)
Exemple #3
0
    def _read_config(self, signum=None, frame=None):
        logit("info", "_read_config called!")
        try:
            self.parser.read(CONFIG_FILE)
        except ConfigParser.MissingSectionHeaderError as e:
            # The file exists, but doesn't have the correct format.
            raise exc.InvalidConfigurationFile(e)

        def safe_get(section, option, default=None):
            try:
                return self.parser.get(section, option)
            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
                return default

        self.log_level = safe_get("frame", "log_level", "INFO")
        set_log_level(self.log_level)

        self.reg_url = safe_get("host", "reg_url")
        if not self.reg_url:
            logit("error", "No registration URL in photo.cfg; exiting")
            exit()
        self.dl_url = safe_get("host", "dl_url")
        if not self.dl_url:
            logit("error", "No download URL configured in photo.cfg; exiting")
            exit()
        self.check_url = safe_get("host", "check_url", None)
        self.frameset = safe_get("frameset", "name", "")
        self.name = safe_get("frame", "name", "undefined")
        self.pkid = safe_get("frame", "pkid", "")
        self.description = safe_get("frame", "description", "")
        self.orientation = safe_get("frame", "orientation", "H")
        # When to start the image rotation
        self.interval_base = safe_get("frame", "interval_base", "*:*")
        # How often to change image
        self.interval_time = int(safe_get("frame", "interval_time", 10))
        # Units of time for the image change interval
        self.interval_units = safe_get("frame", "interval_units", "minutes")
        self.interval = _normalize_interval(self.interval_time,
                self.interval_units)
        logit("info", "Setting image interval to", self.interval)
        self.set_image_interval()
        check_interval = int(safe_get("frame", "host_check", 120))
        check_units = safe_get("frame", "host_check_units", "minutes")
        self.check_interval = _normalize_interval(check_interval, check_units)
        logit("info", "Setting host check interval to", self.check_interval)
        self.brightness = safe_get("monitor", "brightness")
        self.contrast = safe_get("monitor", "contrast")
        self.saturation = safe_get("monitor", "saturation")
    def scheduler(self, sched):
        set_log_level(logging.INFO)
        logging.info(f"scheduler() {self.batterystatus()}")

        timez = self._add_times_to_schedule(self.conf['schedule'])
        now = datetime.now()

        for run in timez.keys():
            if timez[run]['time'] > now:
                if timez[run]['state']:
                    state = self.switchon
                else:
                    state = self.switchoff
                sched.add_job(state, 'date', run_date=timez[run]['time'])
                logging.info(f"{timez[run]['emoji']:2} {run:10}: {timez[run]['time']}")
        logging.info(info_jobs(sched.get_jobs()))
def main():
  parser = optparse.OptionParser(usage='usage: %prog [options] [test_names]')
  parser.add_option('-e', '--environment_type', help='Environment type',
                    default=None)
  parser.add_option('-n', '--name', help='Environment name', default=None)
  parser.add_option('-p', '--environment_params',
                    help='Environment parameters if creating an environment '
                    'for the test', default=None)
  parser.add_option('-t', '--test_params', help='Test parameters',
                    default=None)
  utils.add_options(parser)
  global _options
  _options, args = parser.parse_args()
  del sys.argv[1:]

  utils.set_log_level(_options.verbose)
  utils.set_options(_options)
  unittest.main()
    def verify_state(self):
        logging.debug("verify_state()")
        if self.mystery_state == Light.UNKN:
            status = self.status()

            # XXX wouldn't need VERIFY_TABLE if status & self.state were the same type to verify against
            if VERIFY_TABLE[status] == self.state:
                logging.info(f"status is ✅ {status} 💡")
                self.mystery_state =  VERIFY_TABLE[status]
            elif VERIFY_TABLE[status] == Light.UNKN:
                logging.info("status is ❓")
                self.mystery_state =  Light.UNKN
            elif VERIFY_TABLE[status] != self.state:
                logging.info("status is 🚫 toggling 💡")
                self.toggle()
                self.mystery_state =  Light.UNKN
        else:
            logging.info("✅ status correct. quieting log messages")
            set_log_level(logging.WARNING) # XXX this might not be working ... just suck it up and accept the log messages ... could do this via apscheduler.job.pause() but that would require a dance
def load_settings(env=None):
    global settings_dict, curr_env
    mass_redis_settings = EnvSettings()

    mass_redis_settings.cpg = ConfigParser.SafeConfigParser()
    if env is None or env == EnvironmentType.LOCAL:
        mass_redis_settings.cpg.read(os.path.join(os.path.abspath(os.path.dirname(__file__)), r'config.txt'))
    else:
        mass_redis_settings.cpg.read(os.path.join(os.path.abspath(os.path.dirname(__file__)), r'config_%s.txt' % env))

    mass_redis_settings.ENV = mass_redis_settings.cpg.get('general', 'env')

    # Set only once so that this maintains a reference to the environment the app is running in
    # Don't want to do this on subsequent loads since when user requests a provider in a different environment
    if curr_env is None:
        curr_env = mass_redis_settings.ENV

    mass_redis_settings.LOG_ROOT = mass_redis_settings.cpg.get('general', 'log_root')
    mass_redis_settings.LOG_NAME = 'generic_redis_cache.log'
    mass_redis_settings.LOG_LEVEL = mass_redis_settings.cpg.get('general', 'log_level')

    utils.init_log(mass_redis_settings.LOG_NAME, mass_redis_settings.LOG_ROOT)
    level = logging.getLevelName(mass_redis_settings.LOG_LEVEL)
    utils.set_log_level(level, mass_redis_settings.LOG_NAME)

    logger = logging.getLogger(mass_redis_settings.LOG_NAME)

    # Redis Settings
    mass_redis_settings.REDIS_HOST = mass_redis_settings.cpg.get('general', 'redis_server')
    mass_redis_settings.REDIS_PORT = mass_redis_settings.cpg.get('general', 'redis_port')
    mass_redis_settings.REDIS_PASSWORD = mass_redis_settings.cpg.get('general', 'redis_password')
    mass_redis_settings.REDIS_DB = mass_redis_settings.cpg.get('general', 'redis_db')

    # For debugging purposes, log settings data
    logger.info('log_root: %s, log_name:%s, log_level:%s' % (mass_redis_settings.LOG_ROOT, mass_redis_settings.LOG_NAME,
                                                             mass_redis_settings.LOG_LEVEL))

    settings_dict[mass_redis_settings.ENV] = mass_redis_settings
Exemple #8
0
def main(kwargs):
    if kwargs['--verbose']:
        utils.set_log_level(utils.DEBUG)

    # Create the Tic Tac Toe board
    board = Board(int(kwargs['--size']))
    nn_dims = (board.num_cells, board.num_cells*2, board.num_cells)

    # TODO: Clean up player creation
    # Create the list of players
    if kwargs['--p1'] == 'human':
        p1 = HumanPlayer()
    elif kwargs['--p1'] == 'NN':
        p1 = NNPlayer(dims=nn_dims)

    if kwargs['--p2'] == 'human':
        p2 = HumanPlayer()
    elif kwargs['--p2'] == 'NN':
        p2 = NNPlayer(dims=nn_dims)

    game = Game(board=board, players=(p1, p2), num_rounds=int(kwargs['--num_rounds']))
    game.play()

    print(game.score_board)
Exemple #9
0
from io import Surface
from viz import Brain, TimeViewer
from utils import verbose, set_log_level, set_log_file

__version__ = "0.5dev"

set_log_level()
Exemple #10
0
def main():
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)

    target_group = parser.add_argument_group(
        title='Select profiling target').add_mutually_exclusive_group(
            required=True)
    target_group.add_argument(
        '-p',
        '--app',
        help="""Profile an Android app, given the package name.
                              Like `-p com.example.android.myapp`.""")

    target_group.add_argument('-np',
                              '--native_program',
                              help="""Profile a native program running on
                              the Android device. Like `-np surfaceflinger`."""
                              )

    target_group.add_argument(
        '-cmd',
        help="""Profile running a command on the Android device.
                              Like `-cmd "pm -l"`.""")

    target_group.add_argument(
        '--pid',
        nargs='+',
        help="""Profile native processes running on device
                              given their process ids.""")

    target_group.add_argument('--tid',
                              nargs='+',
                              help="""Profile native threads running on device
                              given their thread ids.""")

    target_group.add_argument('--system_wide',
                              action='store_true',
                              help="""Profile system wide.""")

    app_target_group = parser.add_argument_group(
        title='Extra options for profiling an app')
    app_target_group.add_argument('--compile_java_code',
                                  action='store_true',
                                  help="""Used with -p.
                                  On Android N and Android O, we need to compile Java code into
                                  native instructions to profile Java code. Android O also needs
                                  wrap.sh in the apk to use the native instructions."""
                                  )

    app_start_group = app_target_group.add_mutually_exclusive_group()
    app_start_group.add_argument('-a',
                                 '--activity',
                                 help="""Used with -p. Profile the launch time
                                 of an activity in an Android app. The app will be started or
                                 restarted to run the activity. Like `-a .MainActivity`."""
                                 )

    app_start_group.add_argument(
        '-t',
        '--test',
        help="""Used with -p. Profile the launch time of an
                                 instrumentation test in an Android app. The app will be started or
                                 restarted to run the instrumentation test. Like
                                 `-t test_class_name`.""")

    record_group = parser.add_argument_group('Select recording options')
    record_group.add_argument(
        '-r',
        '--record_options',
        default='-e task-clock:u -f 1000 -g --duration 10',
        help="""Set
                              recording options for `simpleperf record` command. Use
                              `run_simpleperf_on_device.py record -h` to see all accepted options.
                              Default is "-e task-clock:u -f 1000 -g --duration 10"."""
    )

    record_group.add_argument(
        '-lib',
        '--native_lib_dir',
        type=extant_dir,
        help="""When profiling an Android app containing native libraries,
                                      the native libraries are usually stripped and lake of symbols
                                      and debug information to provide good profiling result. By
                                      using -lib, you tell app_profiler.py the path storing
                                      unstripped native libraries, and app_profiler.py will search
                                      all shared libraries with suffix .so in the directory. Then
                                      the native libraries will be downloaded on device and
                                      collected in build_cache.""")

    record_group.add_argument(
        '-o',
        '--perf_data_path',
        default='perf.data',
        help='The path to store profiling data. Default is perf.data.')

    record_group.add_argument(
        '-nb',
        '--skip_collect_binaries',
        action='store_true',
        help="""By default we collect binaries used in profiling data from
                                      device to binary_cache directory. It can be used to annotate
                                      source code and disassembly. This option skips it."""
    )

    other_group = parser.add_argument_group('Other options')
    other_group.add_argument(
        '--ndk_path',
        type=extant_dir,
        help="""Set the path of a ndk release. app_profiler.py needs some
                                     tools in ndk, like readelf.""")

    other_group.add_argument(
        '--disable_adb_root',
        action='store_true',
        help="""Force adb to run in non root mode. By default, app_profiler.py
                                     will try to switch to root mode to be able to profile released
                                     Android apps.""")
    other_group.add_argument('--log',
                             choices=['debug', 'info', 'warning'],
                             default='info',
                             help='set log level')

    def check_args(args):
        if (not args.app) and (args.compile_java_code or args.activity
                               or args.test):
            log_exit(
                '--compile_java_code, -a, -t can only be used when profiling an Android app.'
            )

    args = parser.parse_args()
    set_log_level(args.log)
    check_args(args)
    if args.app:
        profiler = AppProfiler(args)
    elif args.native_program:
        profiler = NativeProgramProfiler(args)
    elif args.cmd:
        profiler = NativeCommandProfiler(args)
    elif args.pid:
        profiler = NativeProcessProfiler(args)
    elif args.tid:
        profiler = NativeThreadProfiler(args)
    elif args.system_wide:
        profiler = SystemWideProfiler(args)
    profiler.profile()
Exemple #11
0
    def exit_signal(*args):
        logger.info('Exiting ...')

        exit(0 if signal.SIGTERM else 1)

    signal.signal(signal.SIGTERM, exit_signal)
    signal.signal(signal.SIGINT, exit_signal)

    def update_signal(*args):
        worker.send_update()

    signal.signal(signal.SIGHUP, update_signal)


if __name__ == '__main__':  # pragma: no cover
    set_log_level('INFO')

    arguments = parse_arguments()

    if arguments.debug:
        set_log_level('DEBUG')

    worker = Worker(arguments.manager, arguments.retries, arguments.events,
                    arguments.metrics)

    setup_signals(worker)

    logger.debug('Signal handlers set up for SIGTERM, SIGINT and SIGHUP')

    try:
        worker.start()
        # Parse each conversation
        for state in json_archive['conversation_state']:
            conv = Conversation(state)
            conv.parse()
            conv.print_summary()
            conv.serialize()

    LOG_INFO('Finished parsing conversations!')


if __name__ == "__main__":
    LOG_INFO('Started script')
    parser = argparse.ArgumentParser()
    parser.add_argument('-f',
                        '--file-path',
                        default='raw/Hangouts.json',
                        type=str,
                        dest='file_path',
                        help='Path to raw data file')
    parser.add_argument('-l',
                        '--log-level',
                        default=1,
                        type=int,
                        dest='log_level',
                        help='Minimum logging level to output')
    args = parser.parse_args()

    utils.set_log_level(args.log_level)
    main(args.file_path)
Exemple #13
0
    kwargs = parse_arguments().__dict__

    if kwargs.get('debug'):
        set_log_level('DEBUG')

    logger.debug('Startup arguments: %s',
                 ', '.join('%s=%s' % item for item in kwargs.items()))

    app = PyGen(**kwargs)

    setup_signals(app)

    logger.debug('Signal handlers set up for SIGTERM, SIGINT and SIGHUP')

    try:
        app.update_target()

        logger.debug('Starting event watch loop')

        app.watch()

    finally:
        logger.info('Exiting...')

        app.stop()


if __name__ == '__main__':  # pragma: no cover
    set_log_level('INFO')
    main()
 def off_state(self):
     set_log_level(logging.INFO)
     self.switchoff()
 def on_state(self):
     set_log_level(logging.INFO)
     self.switchon()
#!/usr/bin/env python

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import ggplot
import pickle
import argparse
import datetime

import pandas as pd

import utils
utils.set_log_level(1)

from utils import LOG_ERROR, LOG_DEBUG, LOG_INFO, LOG_WARN

def main(file_path):
    # Validate raw data path
    if not os.path.exists(file_path):
        LOG_ERROR('Could not find file: {}'.format(file_path))
        return

    # Validate raw data file type
    if not file_path.endswith('.pkl'):
        LOG_ERROR('File path must be a pickle file')
        return

    with open(file_path, 'rb') as f: