コード例 #1
0
        def attempt_loop(function, max_attempts, try_all=False):
            attempt_count = 0
            success_count = 0
            last_error = None
            while attempt_count < max_attempts:
                try:
                    if try_all:
                        function()
                    else:
                        return function()
                    success_count += 1
                    log.i('Success of attempt {} of {}'.format(
                        attempt_count + 1, max_attempts))
                except Exception as e:
                    last_error = e
                    log.e('Failure of attempt {} of {}: {}'.format(
                        attempt_count + 1, max_attempts, e))
                attempt_count += 1

                time.sleep(0.5)  # to increase robustness

            if success_count == 0:
                log.e(
                    'No successful attempt in any of the {} attempts. Last error:'
                    .format(max_attempts))
                raise last_error
コード例 #2
0
    def check(self):
        steamvr_running = self.is_steamvr_running()

        # log.d('Stage: {}   steamvr_running {}'.format(self.current_stage, steamvr_running))

        if self.current_stage == self.Stages.BEFORE_STEAMVR:
            if steamvr_running:
                self.update_stage(self.Stages.DURING_STEAMVR)
            elif self.start_of_current_stage + 60 <= time.time():
                log.e("SteamVR never started, exiting. Looking for a process with this name: {}".format(
                    self.config.daemon_watch_process_name()))
                self.steamvr_utils.turn_off()
                log.i("Exiting...")
                return False

        elif self.current_stage == self.Stages.DURING_STEAMVR:
            if not steamvr_running:
                self.update_stage(self.Stages.AFTER_STEAMVR)

        elif self.current_stage == self.Stages.AFTER_STEAMVR:
            if steamvr_running:
                self.update_stage(self.Stages.DURING_STEAMVR)
            elif self.start_of_current_stage + self.config.daemon_wait_after_quit() <= time.time():
                self.steamvr_utils.turn_off()
                log.i("Exiting...")
                return False

        return True
コード例 #3
0
ファイル: main.py プロジェクト: nickjerry/agar
def switch_handler(s, conn, addr):
    ucon = upconnection.load(s, conn, addr)
    alternative_args = {
            'socket' : s,
            'addr'   : s.getsockname()[0],
            'port'   : s.getsockname()[1],
            'conn'   : conn,
            'ucon'   : ucon,
            }

    while 1:
        ucon.recv()
        suc_match = False
        for tup in handler_list:
            match = re.match(tup[0], ucon.rfile)
            if match:
                suc_match = True
                args = []
                for key in tup[2]:
                    if key in alternative_args:
                        args.append(alternative_args[key])
                    elif key == 'regex':
                        args += match.groups()
                    else:
                        log.e("Unknown key {}".format(key))
                sdata = tup[1](*args)
                if sdata:
                    ucon.send(sdata)
                break
        if not ucon.alive or not suc_match:
            ucon.close()
            break
コード例 #4
0
ファイル: config.py プロジェクト: fomichev/pycryptobox
def read(args):
    """
    Read configuration (possibly pointed by args)
    """

    if debug:
        log.w("DEBUGGING ENABLED! YOUR DATA MAY BE EXPOSED!")

    v = vars(args)

    global verbose
    if 'verbose' in v:
        verbose = v['verbose']

    user_config_parser = ConfigParser.ConfigParser()
    try:
        if 'config' in v and v['config'] != None:
            f = open(v['config'])
            user_config_parser.readfp(f)
        else:
            try:
                f = open('.cryptoboxrc')
                user_config_parser.readfp(f)
            except:
                try:
                    f = open('~/.cryptoboxrc')
                    user_config_parser.readfp(f)
                except:
                    pass
    except Exception as e:
        log.e("Could not load user config!")
        log.e(str(e))
        sys.exit(1)

    return read_user_config(user_config_parser)
コード例 #5
0
    def rescan_all_cards():
        arguments = ['pactl', 'load-module', 'module-detect']
        return_code, stdout, stderr = utlis.run(arguments)

        if return_code != 0:
            log.e('\'{}\' () failed, stderr:\n{}'.format(
                " ".join(arguments), stderr))
コード例 #6
0
ファイル: upconnection.py プロジェクト: nickjerry/agar
    def recv(self):
        self.raw_recv()
        if not '\r\n\r\n' in self.data:
            log.e('Unable to parse the data:{}.'.format(self.data))
            self.alive = False
            return
        proto_headers, self.body = self.data.split('\r\n\r\n', 1)
        proto, headers = proto_headers.split('\r\n', 1)
        result = re.match(r'(GET|POST)\s+(\S+)\s+HTTP/1.1', proto)
        if not result:
            log.e('unsupported protocol')
            exit(1)
        self.method, res = result.groups()
        if res[0] == '/':
            res = res[1:]
        lis = res.split('?')
        lis.append('')
        self.rfile, query_string = lis[0:2]
        self.params = [tuple((param+'=').split('=')[0:2])
                for param in query_string.split('&')]

        ma_headers = re.findall(r'^\s*(.*?)\s*:\s*(.*?)\s*\r?$', headers, re.M)
        self.headers = {item[0]:item[1] for item in ma_headers}

        #log.d("rfile : {}\nparams : {}\nheaders : {}\nbody : {}".format(self.rfile,  str(self.params), str(self.headers), self.body))

        if not self.headers.get('connection') \
            or 'keep-alive' != self.headers['connection'].lower():
                self.alive = False
コード例 #7
0
ファイル: kermit.py プロジェクト: deverac/hpircomm
 def local_type(self, filename):
     if filename:
         f = open(filename, 'r')
         lines = f.read()
         f.close()
         log.i(lines)
     else:
         log.e('Missing filename')
コード例 #8
0
ファイル: serial.py プロジェクト: deverac/hpircomm
 def receive_file(self, filename):
     mode = self.config['mode'].value
     if mode == C['mode']['timeout']:
         self.receive_file_timeout(filename)
     elif mode == C['mode']['watchars']:
         self.receive_file_watchars(filename)
     else:
         log.e('Invalid mode {}'.format(mode))
コード例 #9
0
ファイル: kprotocol.py プロジェクト: deverac/hpircomm
 def write_packet(self, pkt):
     if not pkt:
         log.e('No packet to write')
         return False
     lst = pkt.to_list()
     if self.config['debug'].value:
         log.i('Sending {}'.format(lst))
     self.transport.write_bytes(bytearray(lst))
     return True
コード例 #10
0
ファイル: huluo.py プロジェクト: huluo/m-huluo-src
def main( p_port ) :
    if p_port == 0 :
        print 'port could not be set as 0'
        log.e( 'port could not be set as 0' )
        exit( 1 )
    log.c( 'www listening on port : %s' % p_port )
    app = Application()
    app.listen( p_port )
    tornado.ioloop.IOLoop.instance().start()
コード例 #11
0
ファイル: kprotocol.py プロジェクト: deverac/hpircomm
 def _send_bytes(self, name, bytes):
     try:
         packets = self._bytes_to_packets(name, bytes)
         self._send_packets(packets)
         return True
     except KeyboardInterrupt as ki:
         log.e('Aborting')
         self.send_abort()
         return False
コード例 #12
0
ファイル: hook_context.py プロジェクト: luntan365/reassist
 def read_data(self, dbg, addr, size, ignore_limit=False):
     addr = self.get_value(addr)
     size = self.get_value(size)
     try:
         buf = self.read_process_memory(dbg, addr, size, ignore_limit)
         return buf
     except Exception, e:
         log.e("Error in read_data(). " + e.message)
         return "Error in read_data()" + e.message
コード例 #13
0
ファイル: hook_context.py プロジェクト: lmy375/reassist
	def read_data(self, dbg, addr , size, ignore_limit = False):
		addr = self.get_value(addr)
		size = self.get_value(size)
		try:
			buf = self.read_process_memory(dbg, addr, size, ignore_limit)
			return buf
		except Exception,e:
			log.e("Error in read_data(). "+ e.message)
			return "Error in read_data()" + e.message
コード例 #14
0
def main(connection=None):
    client = get_client(connection)
    try:
        while client.IsConnected():
            if client.GetFrame():
                logger.info(get_data(client, 'test'))

    except ViconDataStream.DataStreamException as e:
        log.e(f'Error: {e}')
コード例 #15
0
ファイル: kermit.py プロジェクト: deverac/hpircomm
 def set(self, line):
     cmd, tail = util.parse_cmdline2(line, self.config, log)
     if not cmd:
         log.e('Name not found: {}'.format(line))
         return
     if cmd == 'receive':
         log.i('Cannot set receive')
         return
     util.set_config(line, self.config, kprotocol.C, log)
コード例 #16
0
ファイル: kermit.py プロジェクト: deverac/hpircomm
 def local_push(self):
     shell = self.config['shell'].value
     if shell:
         os.system(shell)
     elif os.name == 'posix':
         os.system('bash')
     elif os.name == 'nt':
         os.system('command.com')
     else:
         log.e("Unknown shell. (Set the 'shell' config value)")
コード例 #17
0
def main():
    actions = {
        SteamvrUtils.Action.ON: ['on', '1'],
        SteamvrUtils.Action.OFF: ['off', '0'],
        SteamvrUtils.Action.DAEMON: ['daemon', 'd'],
        SteamvrUtils.Action.CONFIG_HELP: ['config-help', 'c']
    }

    parser = argparse.ArgumentParser()
    parser.add_argument('action',
                        choices=[
                            keyword for _, keywords in actions.items()
                            for keyword in keywords
                        ],
                        help='action to perform on the Base Stations')
    parser.add_argument(
        '--dry-run',
        help=
        'Do not modify anything (bluetooth connections are still made, but never used to write).',
        action='store_true')
    parser.add_argument('--config',
                        default=None,
                        help='Path to a config file.')
    parser.add_argument(
        '--version',
        action='version',
        version='steamvr_utils {version}'.format(version=__version__))
    args = parser.parse_args()

    config = Config(config_path=args.config, dry_run_overwrite=args.dry_run)

    log.initialise(config)

    # noinspection PyBroadException
    try:

        selected_action = None
        for action in SteamvrUtils.Action:
            if args.action in actions[action]:
                selected_action = action

        if selected_action == SteamvrUtils.Action.CONFIG_HELP:
            config_helper = ConfigHelper(config)
            config_helper.print_help()
            return

        log.i('steamvr_utils version: {}'.format(__version__))
        log.d('dry_run: {}'.format(config.dry_run()))

        steamvr_utils = SteamvrUtils(config=config)

        steamvr_utils.action(selected_action)
    except Exception:
        log.e('', exc_info=True)
        exit(1)
コード例 #18
0
    def set_profile(self, config, profile):
        if config.dry_run():
            log.w('Skipping because of dry run')
            return

        arguments = ['pactl', 'set-card-profile', self.name, profile.name]
        return_code, stdout, stderr = utlis.run(arguments)

        if return_code != 0:
            log.e('\'{}\' () failed, stderr:\n{}'.format(
                " ".join(arguments), stderr))
コード例 #19
0
ファイル: hook_point.py プロジェクト: lmy375/reassist
	def hook(self, dbg):
		if self.__active: 
			return 
		self.address = self.get_address(dbg)
		if self.address is None or self.address == 0x0:
			log.e("[!] Fail to hook %s: invalid address %#x"%(self.func, self.address))
			return False
		try:
			dbg.bp_set(self.address, restore=True, handler=self.__proxy_on_entry)
		except Exception,e:
			log.e("[!] Fail to hook %s: %s" % (self.func,e.message))
			return False
コード例 #20
0
    def find_matching_sink(sinks, regex, name):
        vr_matches = [sink for sink in sinks if re.match(regex, sink.name)]
        if len(vr_matches) == 1:
            return vr_matches[0]

        elif len(vr_matches) == 0:
            log.e(
                'No {} audio sink for the normal device was found. Tried to find a match for: {}'
                .format(name, regex))
        else:
            raise RuntimeError(
                'Multiple matches for the {} audio sink found. Tried to find a match for: {}'
                .format(name, regex))
コード例 #21
0
    def set_stream_for_all_stream_connections(self, stream):
        if self.config.dry_run():
            log.w('Skipping because of dry run')
            return

        # verify stream name exists before proceeding
        streams = self.get_all_streams()
        found = False
        for s in streams:
            if s.name == stream.name:
                found = True

        if not found:
            log.w('Skipping {} since the {} name does not exist'.format(
                self.get_move_stream_connection_command(),
                self.get_stream_type_name()))
            return

        stream_connections = self.get_all_stream_connections()
        pactl_interface.Client.get_client_names(stream_connections)
        stream_connections = self.filter_by_client_name(stream_connections)

        for stream_connection in stream_connections:
            failure = \
                ([failure for failure in self.failed_stream_connections if
                  failure.stream_connection_id == stream_connection.id] + [
                     None])[0]
            if failure is not None and not failure.try_again():
                continue

            arguments = [
                'pactl',
                self.get_move_stream_connection_command(),
                str(stream_connection.id), stream.name
            ]
            log.w("move {}".format(" ".join(arguments)))
            return_code, stdout, stderr = pactl_interface.utlis.run(
                arguments, assert_success=False)

            if return_code != 0:
                if failure is None:
                    failure = self.Failure(stream_connection.id)
                    self.failed_stream_connections.append(failure)
                else:
                    failure.add_attempt()

                log.e(
                    '\'{}\' (client_name: {}) failed (count: {}), stderr:\n{}'.
                    format(" ".join(arguments), stream_connection.client_name,
                           failure.failure_count, stderr))
                self.output_logger.log_all()
コード例 #22
0
    def find_matching_stream(self, streams, regex, name):
        matches = [
            stream for stream in streams if re.match(regex, stream.name)
        ]
        if len(matches) == 1:
            return matches[0]

        elif len(matches) == 0:
            log.e('No {} audio {} was found. Tried to find a match for: {}'.
                  format(name, self.stream_type, regex))
        else:
            raise RuntimeError(
                'Multiple matches for the {} audio {} found. Tried to find a match for: {}'
                .format(name, self.stream_type, regex))
コード例 #23
0
def _init_api(connection=None, host="127.0.0.1", port="5000"):
    try:
        client = get_client(connection)
    except Exception as e:
        log.e("Failed to connect to client")
        log.e(e.message)
        client = None
    app = Flask("vicon-ds")
    api = Api(app)
    try:
        sensor = setup_phidget()
    except Exception as e:
        log.e("Failed to connect to sensor")
        log.e(e)
        sensor = None

    class ViconMarkerStream(Resource):
        def get(self, data_type, subject_name):
            if client is not None and client.IsConnected() and client.GetFrame(
            ):
                return get_data(client, data_type, subject_name)
            return "restart:  client didn't connect", 404

    api.add_resource(ViconMarkerStream,
                     '/<string:data_type>/<string:subject_name>')
    try:
        app.run(host=host, port=int(port))
    finally:
        if sensor is not None:
            sensor.close()
コード例 #24
0
ファイル: hook_point.py プロジェクト: luntan365/reassist
 def hook(self, dbg):
     if self.__active:
         return
     self.address = self.get_address(dbg)
     if self.address is None or self.address == 0x0:
         log.e("[!] Fail to hook %s: invalid address %#x" %
               (self.func, self.address))
         return False
     try:
         dbg.bp_set(self.address,
                    restore=True,
                    handler=self.__proxy_on_entry)
     except Exception, e:
         log.e("[!] Fail to hook %s: %s" % (self.func, e.message))
         return False
コード例 #25
0
 def _write_file(self, filename, bufdat):
     try:
         if len(bufdat) == 0:
             return
         while bufdat[-1] == 0x00:  # HP pads with 0x00
             del bufdat[-1]
         bufdat.append(0x00)  # HP objects must end with null.
         log.i('Received ' + str(len(bufdat)) + ' bytes')
         log.i('Saving to file ' + filename)
         f = open(filename, 'wb')
         f.write(bytearray(bufdat))
         f.close()
     except IOError as err:
         log.e('Failed to write file ' + filename)
         return False
     return True
コード例 #26
0
def __getContent(url, requestHeaders=None):
    if requestHeaders == None:
        requestHeaders = headers

    try:
        log.d("GET - {0} [{1}]".format(url, requestHeaders))
        response = urllib2.urlopen(urllib2.Request(url,
                                                   headers=requestHeaders))

        result = response.read()
        # log.d("RESPONSE - {0}".format(result))

        return result
    except urllib2.URLError as error:
        log.e(str(error))
        return None
コード例 #27
0
    def set_suspend_state(self, config, state):
        if config.dry_run():
            log.w('Skipping because of dry run')
            return

        if state:
            state = "true"
        else:
            state = "false"

        arguments = ['pactl', 'suspend-sink', self.name, state]
        log.d('set_suspend_state {}'.format(' '.join(arguments)))
        return_code, stdout, stderr = utlis.run(arguments)

        if return_code != 0:
            log.e('\'{}\' () failed, stderr:\n{}'.format(" ".join(arguments), stderr))
コード例 #28
0
ファイル: back.py プロジェクト: nickjerry/agar
def handle_data(dataFromClient):
    data_valid = True
    try:
        obj = json.loads(dataFromClient)
    except:
        data_valid = False
    if not data_valid or not obj.get('header'):
        log.e('ws get invalid data (len={}):{}'.format(len(dataFromClient), ','.join('%x'%(ord(i)) for i in dataFromClient)))
        return {"header":"unknown"}
    switcher = {
            'init':responseInit,
            'update':responseUpdate,
            }
    retObj = switcher[obj['header']](obj)
    if not 'header' in retObj:
        retObj['header'] = obj['header']
    return retObj
コード例 #29
0
ファイル: kprotocol.py プロジェクト: deverac/hpircomm
 def _send_then_receive(self, pkt, max_retries=5):
     # Difficult because initial write_packet() may not be received
     # correctly and, per Kermit protocol, we do not get an ACK (but might
     # get a NACK).
     #
     # For 'receive_initiate' (R):
     # "...the only two valid responses to a successfully received R packet
     # are an S packet or an E packet. The R packet is not ACK'd."  p. 26
     self.transport.clear_buffer()
     retries = 0
     while retries < max_retries:
         pkt_in = self._write_verify(pkt)
         if pkt_in and pkt_in.type != 'N':
             self._receive(pkt_in)
             return
         retries += 1
     log.e('Failed to send command {}'.format(pkt.payload))
コード例 #30
0
ファイル: main.py プロジェクト: nickjerry/agar
def parse_args():
    args = ''.join(sys.argv[1:])
    regexs = [
        (r'^(\d+\.\d+\.\d+\.\d+):(\d+)$',
            lambda x:(x.group(1),x.group(2))),
        (r'^(\d+)$',
            lambda x:('127.0.0.1', x.group(1))),
        (r'^(\d+\.\d+\.\d+\.\d+)$',
            lambda x:(x.group(1), '8080'))
        ]
    for regex in regexs:
        result = re.match(regex[0], args)
        if result:
            addr, port = regex[1](result)
            return addr, int(port)
    log.e('Invalid IP address or port !!!')
    exit(0)
コード例 #31
0
    def set_sink_for_all_sink_inputs(self, sink):
        if self.config.dry_run():
            log.w('Skipping because of dry run')
            return

        # verify sink name exists before proceeding
        sinks = pactl_interface.Sink.get_all_sinks(self)
        found = False
        for s in sinks:
            if s.name == sink.name:
                found = True

        if not found:
            log.w(
                'Skipping move-sink-input since the sink name does not exist')
            return

        sink_inputs = pactl_interface.SinkInput.get_all_sink_inputs(self)
        pactl_interface.Client.get_client_names(sink_inputs)
        sink_inputs = self.filter_by_client_name(sink_inputs)

        for sink_input in sink_inputs:
            failure = \
                ([failure for failure in self.failed_sink_inputs if failure.sink_input_id == sink_input.id] + [None])[0]
            if failure is not None and not failure.try_again():
                continue

            arguments = [
                'pactl', 'move-sink-input',
                str(sink_input.id), sink.name
            ]
            return_code, stdout, stderr = pactl_interface.utlis.run(arguments)

            if return_code != 0:
                if failure is None:
                    failure = self.Failure(sink_input.id)
                    self.failed_sink_inputs.append(failure)
                else:
                    failure.add_attempt()

                log.e(
                    '\'{}\' (client_name: {}) failed (count: {}), stderr:\n{}'.
                    format(" ".join(arguments), sink_input.client_name,
                           failure.failure_count, stderr))
                self.log_state()
コード例 #32
0
ファイル: hook_context.py プロジェクト: luntan365/reassist
    def on_exit(self, dbg):
        # Fill context.
        self.ret_value = dbg.context.Eax

        # Save hook context to info_man.hook_infos, before calling
        # user-defined handler.
        # This will be submited to InfoManager earlier before
        # user-defined DbgInfo does.
        self.save()

        # Call user-defined handler.
        if self.func.exit_hook:
            try:
                global_exit_hook(self, dbg)
                self.func.exit_hook(self, dbg)
            except Exception, e:
                log.e("Exception %s in exit_hook of %s:\n %s" %
                      (e, self.func, traceback.format_exc()))
コード例 #33
0
ファイル: hook_context.py プロジェクト: lmy375/reassist
	def on_exit(self, dbg):
		# Fill context.
		self.ret_value = dbg.context.Eax

		# Save hook context to info_man.hook_infos, before calling
		# user-defined handler. 
		# This will be submited to InfoManager earlier before 
		# user-defined DbgInfo does.
		self.save()

		# Call user-defined handler.
		if self.func.exit_hook:
			try:
				global_exit_hook(self, dbg)				
				self.func.exit_hook(self, dbg)
			except Exception, e:
				log.e("Exception %s in exit_hook of %s:\n %s" %
					(e, self.func, traceback.format_exc()))
コード例 #34
0
ファイル: kermit.py プロジェクト: deverac/hpircomm
    def local_directory(self, line=''):
        DIR_HEADER = '\x01'
        dir = os.getcwd()
        filenames = []
        if os.path.isdir(line) or not line:
            if line:
                dir = line
            filenames = os.listdir(dir)
        else:
            specs = shlex.split(line)
            for spec in specs:
                filenames.extend(glob.glob(spec))
        entries = []
        for filename in filenames:
            abspath = os.path.join(dir, filename)
            if os.path.isdir(abspath):
                filename = '{}[{}]'.format(DIR_HEADER, filename)
            s = os.stat(abspath)
            filesize = s.st_size
            lastmodified = s.st_mtime
            entries.append((lastmodified, filesize, filename))

        # Sort is stable.
        order_by = util.key_for_val(kprotocol.C['order-by'],
                                    self.config['order-by'].value)
        for ch in order_by[::-1]:
            if ch == 'd':
                entries.sort(key=lambda tup: tup[0])
            elif ch == 's':
                entries.sort(key=lambda tup: tup[1])
            elif ch == 'n':
                entries.sort(key=lambda tup: tup[2])
            else:
                log.e('Bad field char {}'.format(ch))

        oslope = self.config['oslope'].value
        for entry in entries[::oslope]:
            dt = datetime.datetime.fromtimestamp(
                entry[0]).strftime('%Y-%m-%d %H:%M')
            sz = util.format_si(entry[1])
            nm = entry[2]
            if nm.startswith(DIR_HEADER):
                nm = nm[1:]
            log.i('  {}  {}  {}'.format(dt, sz, nm))
コード例 #35
0
ファイル: data.py プロジェクト: liuxu0703/douban_movie_rating
 def requestSearch(self, keyword):
     log.d("search keyword: " + getDecodedString(keyword))
     self.origin_search = keyword
     self.search = getUtf8String(keyword)
     count = config.getSearchCount()
     request_string = "/v2/movie/search?count=" + str(
         count) + "&q=" + self.search
     log.d("req: http://api.douban.com" + request_string)
     conn = httplib.HTTPConnection("api.douban.com")
     conn.request("GET", request_string)
     res = conn.getresponse()
     ret = res.read()
     if (res.status == 200):
         log.d("res: " + str(res.status) + ", " + str(res.reason) + ", " +
               ret)
         return ret
     else:
         log.e("res: " + str(res.status) + ", " + str(res.reason) + ", " +
               ret)
コード例 #36
0
ファイル: kprotocol.py プロジェクト: deverac/hpircomm
 def _unescape_payload(self, payload):
     buf = []
     pos = 0
     while pos < len(payload):
         byte = payload[pos]
         if byte == self.config['receive']['ctl-prefix'].value:
             pos += 1
             if pos < len(payload):
                 byte2 = payload[pos]
                 n = ord(byte2) & 0x7F
                 if ctl(n) < 32 or ctl(n) == 127:
                     buf.append(chr(ctl(ord(byte2))))
                 else:
                     buf.append(byte2)
             else:
                 log.e('Bad payload length')
         else:
             buf.append(byte)
         pos += 1
     return buf
コード例 #37
0
    def __init__(self, args=default_args):
        self.prompt = PROMPTER
        self.scripts = []
        self.arg_cmds = []
        self.arg_flag = True
        self.cmd_proc = None

        self.done = False

        self.config = {
            'exit-on-error':
            CV(C['exit-on-error']['false'], bool, 'Exit on error'),
            'trace-on-error':
            CV(C['trace-on-error']['true'], bool,
               'Print stack trace on error'),
            'local-echo':
            CV(C['local-echo']['true'], bool, 'Echo command line locally'),
            'log-level':
            CV(5, int, 'Set log level'),
            'wav-prefix':
            CV('', str, 'Set wav prefix'),
        }

        self.transport = transport.Transport(args.showinit, args.wavprefix,
                                             args.framerate, args.sensitivity)

        self.kermit_cmd_proc = KermitCmds(self.transport)
        self.serial_cmd_proc = SerialCmds(self.transport)
        self.xmodem_cmd_proc = XmodemCmds(self.transport)

        init_file = args.init
        if init_file and (init_file != DEFAULT_INI_FILE
                          or os.path.exists(init_file)):
            log.i('Reading init script {}'.format(init_file))
            try:
                self.scripts = read_scripts(init_file)
            except IOError:
                log.e('Error reading {}'.format(init_file))

        self.arg_cmds = self.proc_args(args)
コード例 #38
0
ファイル: robot.py プロジェクト: aurickq/rg-skeleton
 def act(self, game):
   if Robot._turn != game.turn:
     Robot._gs = GameState(game)
     Robot._turn = game.turn
     Robot._ai.compute_commands(Robot._gs)
   for bot in Robot._gs.friends:
     if bot.robot_id == self.robot_id:
       cmd = bot.get_command()
       if cmd != None:
         if cmd == CMD_SUICIDE:
           return ['suicide']
         elif cmd == CMD_GUARD:
           return ['guard']
         elif IS_MOVE[cmd]:
           r = CELL_R[CELL_MOVE[cmd]]
           c = CELL_C[CELL_MOVE[cmd]]
           return ['move', (c, r)]
         elif IS_ATTACK[cmd]:
           r = CELL_R[CELL_ATTACK[cmd]]
           c = CELL_C[CELL_ATTACK[cmd]]
           return ['attack', (c, r)]
         else:
           log.e('Unrecognized command! Suiciding... Bot: ' + str(bot))
           return ['suicide']
       else:
         log.e('No command found! Suiciding... Bot: ' + str(bot))
         return ['suicide']
   log.e('Bot was not found! Something has gone horribly wrong. Suiciding... robot_id: ' + str(self.robot_id))
   return ['suicide']
コード例 #39
0
ファイル: hook_context.py プロジェクト: luntan365/reassist
    def on_entry(self, dbg):
        # Fill context. This may be used in self.func.exit_hook().
        self.tid = dbg.dbg.dwThreadId
        self.pid = dbg.dbg.dwProcessId

        self.ret_addr = dbg.get_arg(0)
        self.args = self.get_args(dbg)

        if not self.module:
            module = dbg.addr_to_module(self.ret_addr)
            if module:
                self.module = module.szModule.lower()
            else:
                self.module = "UNKNOWN"

        # Call user-defined handler.
        if self.func.entry_hook:
            try:
                global_entry_hook(self, dbg)
                self.func.entry_hook(self, dbg)
            except Exception, e:
                log.e("Exception %s in entry_hook of %s:\n %s" %
                      (e, self.func, traceback.format_exc()))
コード例 #40
0
ファイル: hook_context.py プロジェクト: lmy375/reassist
	def on_entry(self, dbg):
		# Fill context. This may be used in self.func.exit_hook().
		self.tid = dbg.dbg.dwThreadId
		self.pid = dbg.dbg.dwProcessId

		self.ret_addr = dbg.get_arg(0)
		self.args = self.get_args(dbg)

		if not self.module:
				module = dbg.addr_to_module(self.ret_addr)
				if module:
					self.module = module.szModule.lower()
				else:
					self.module = "UNKNOWN"

		# Call user-defined handler.
		if self.func.entry_hook:
			try:
				global_entry_hook(self, dbg)
				self.func.entry_hook(self, dbg)
			except Exception, e:
				log.e("Exception %s in entry_hook of %s:\n %s" %
					(e, self.func, traceback.format_exc()))
コード例 #41
0
    def looper(self, args):
        except_count = 0
        history_file = '.hpirhist'
        exit_val = EXIT_OK
        d = None

        try:
            log.set_log_level(args.log)
            read_history_file(history_file)

            d = dispatcher.Dispatcher(args)
            d.start_transport()

            while not d.is_done():
                try:
                    d.read_and_exec()
                    except_count = 0
                except:
                    except_count += 1
                    log.i('') # Ensure the following error message starts on a new line.
                    log.e('{} : {}'.format(sys.argv[0], sys.exc_info()[1]))
                    if d.is_trace_on_error():
                        print traceback.format_exc()
                    if (except_count >= 2) or d.is_exit_on_error():
                        exit_val = EXIT_ERR
                        d.force_done()

            write_history_file(history_file)
        except:
            exit_val = EXIT_ERR
            print traceback.format_exc()
        finally:
            if d:
                d.stop_transport()

        return exit_val
コード例 #42
0
ファイル: main.py プロジェクト: lmy375/reassist
def handler_rip(dbg):	
	log.e("RIP Event:", dbg)
	log.e("Error code:%#x" % dbg.u.RipInfo.dwError, dbg)
	log.e("Error type:%#x" % dbg.u.RipInfo.dwType, dbg.dwProcessId,dbg.tid)
	return DBG_CONTINUE
コード例 #43
0
ファイル: huluo.py プロジェクト: huluo/m-huluo-src
        ]
        tornado.web.ErrorHandler = guest.PageNotFoundHandler
        tornado.web.Application.__init__( self, handlers, **settings )
 

def main( p_port ) :
    if p_port == 0 :
        print 'port could not be set as 0'
        log.e( 'port could not be set as 0' )
        exit( 1 )
    log.c( 'www listening on port : %s' % p_port )
    app = Application()
    app.listen( p_port )
    tornado.ioloop.IOLoop.instance().start()


#define("port", default=8888, help="run on the given port", type=int)
port = 0
try :
    port = int( sys.argv[1].split('=')[1] )
except :
    print 'need port params'
    log.e( 'need port params' )
    exit( 1 )


if __name__ == "__main__" :
    main( port )