def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], '6A:p:Sv') except getopt.error: sys.exit('usage: neubot skype_clnt [-6Sv] [-A address] [-p port]') if arguments: sys.exit('usage: neubot skype_clnt [-6Sv] [-A address] [-p port]') prefer_ipv6 = 0 address = '127.0.0.1' port = 45678 sslconfig = False verbose = 0 for name, value in options: if name == '-6': prefer_ipv6 = 1 elif name == '-A': address = value elif name == '-p': port = int(value) elif name == '-S': sslconfig = True elif name == '-v': verbose += 1 level = logging.INFO if verbose > 0: level = logging.DEBUG logging.getLogger().setLevel(level) handler = SkypeClient() handler.connect((address, port), prefer_ipv6, sslconfig, {}) POLLER.loop()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], '6A:P:p:Sv') except getopt.error: sys.exit(USAGE) if arguments: sys.exit(USAGE) prefer_ipv6 = 0 address = 'mlab-ns.appspot.com' policy = '' port = 80 sslconfig = 0 level = logging.INFO for name, value in options: if name == '-6': prefer_ipv6 = 1 elif name == '-A': address = value elif name == '-P': policy = value elif name == '-p': port = int(value) elif name == '-S': sslconfig = 1 elif name == '-v': level = logging.DEBUG logging.getLogger().setLevel(level) handler = RunnerMlabns() extra = {'policy': policy} handler.connect((address, port), prefer_ipv6, sslconfig, extra) POLLER.loop()
def _waiting_rawtest(self, stream, data): ''' Waiting for RAWTEST message from client ''' context = stream.opaque context.bufferise(data) tmp = context.pullup(len(RAWTEST)) if not tmp: stream.recv(len(RAWTEST), self._waiting_rawtest) return if tmp[4:5] == PING_CODE: logging.debug('< PING') stream.send(PINGBACK, self._sent_pingback) logging.debug('> PINGBACK') return if tmp[4:5] != RAWTEST_CODE: raise RuntimeError('raw_srvr: received invalid message') logging.debug('< RAWTEST') logging.info('raw_srvr: waiting for RAWTEST message... complete') logging.info('raw_srvr: raw test... in progress') context.count = context.snap_count = stream.bytes_out context.ticks = context.snap_ticks = utils.ticks() context.snap_utime, context.snap_stime = os.times()[:2] message = PIECE_CODE + context.auth * int(LEN_MESSAGE / AUTH_LEN) context.message = struct.pack('!I', len(message)) + message stream.send(context.message, self._piece_sent) #logging.debug('> PIECE') POLLER.sched(1, self._periodic, stream) stream.recv(1, self._waiting_eof)
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], '6A:p:Sv') except getopt.error: sys.exit(USAGE) if not arguments: sys.exit(USAGE) prefer_ipv6 = 0 address = '127.0.0.1' sslconfig = 0 port = 80 level = logging.INFO for name, value in options: if name == '-6': prefer_ipv6 = 1 elif name == '-A': address = value elif name == '-p': port = int(value) elif name == '-S': sslconfig = 1 elif name == '-v': level = logging.DEBUG logging.getLogger().setLevel(level) handler = HttpClientSmpl(POLLER) handler.connect((address, port), prefer_ipv6, sslconfig, (address, port, collections.deque(arguments), [0])) POLLER.loop()
def main(args): ''' Run the API server ''' try: options, arguments = getopt.getopt(args[1:], 'O:v') except getopt.error: sys.exit('usage: neubot background_api [-v] [-O setting]') if arguments: sys.exit('usage: neubot background_api [-v] [-O setting]') settings = [] for name, value in options: if name == '-O': settings.append(value) elif name == '-v': LOG.verbose() settings = utils_rc.parse_safe(iterable=settings) if not 'address' in settings: settings['address'] = '127.0.0.1 ::1' if not 'port' in settings: settings['port'] = '9774' start(settings['address'], settings['port']) POLLER.loop()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], '6A:p:v') except getopt.error: sys.exit('usage: neubot skype_negotiate [-6v] [-A address] [-p port]') if arguments: sys.exit('usage: neubot skype_negotiate [-6v] [-A address] [-p port]') prefer_ipv6 = 0 address = '127.0.0.1' port = 8080 level = logging.INFO for name, value in options: if name == '-6': prefer_ipv6 = 1 elif name == '-A': address = value elif name == '-p': port = int(value) elif name == '-v': level = logging.DEBUG logging.getLogger().setLevel(level) handler = SkypeNegotiate() handler.connect((address, port), prefer_ipv6, 0, {}) POLLER.loop()
def main(args): ''' Main() function ''' try: options, arguments = getopt.getopt(args[1:], '') except getopt.error: sys.exit('usage: neubot background_win32') if options or arguments: sys.exit('usage: neubot background_win32') # Read settings from database CONFIG.merge_database(DATABASE.connection()) # # Save logs into the database, to easily access # and show them via the web user interface. # LOG.use_database() # Complain if privacy settings are not OK privacy.complain_if_needed() background_api.start('127.0.0.1 ::1', '9774') BACKGROUND_RENDEZVOUS.start() __start_updater() POLLER.loop()
def main(args): ''' main() function ''' try: options, arguments = getopt.getopt(args[1:], 'vy') except getopt.error: sys.exit('neubot updater_runner [-vy] [version]') if len(arguments) > 1: sys.exit('neubot updater_runner [-vy] [version]') privacy = False for tpl in options: if tpl[0] == '-v': LOG.verbose() elif tpl[0] == '-y': privacy = True # Honor -y and force privacy permissions if privacy: CONFIG.conf.update({'privacy.informed': 1, 'privacy.can_collect': 1, 'privacy.can_publish': 1}) updater = UpdaterRunner('win32', os.path.dirname(ROOTDIR)) if arguments: updater.retrieve_files(arguments[0]) else: # Enable automatic updates if we arrive here CONFIG.conf['win32_updater'] = 1 updater.retrieve_versioninfo() POLLER.loop()
def main(args): """ Main function """ try: options, arguments = getopt.getopt(args[1:], "6A:p:Sv") except getopt.error: sys.exit("usage: neubot raw_clnt [-6Sv] [-A address] [-p port]") if arguments: sys.exit("usage: neubot raw_clnt [-6Sv] [-A address] [-p port]") prefer_ipv6 = 0 address = "127.0.0.1" port = 12345 sslconfig = False verbose = 0 for name, value in options: if name == "-6": prefer_ipv6 = 1 elif name == "-A": address = value elif name == "-p": port = int(value) elif name == "-S": sslconfig = True elif name == "-v": verbose += 1 level = logging.INFO if verbose > 0: level = logging.DEBUG logging.getLogger().setLevel(level) handler = RawClient() handler.connect((address, port), prefer_ipv6, sslconfig, {}) POLLER.loop()
def main(args): ''' main() function ''' CONFIG['verbose'] = 1 ctx = {'uri': args[1]} RunnerDload(ctx) POLLER.loop()
def _connect(self): ''' Connect first available epnt ''' sock = utils_net.connect(self.epnts.popleft(), self.prefer_ipv6) if sock: self.sock = sock self.timestamp = utils.ticks() POLLER.set_writable(self) else: self._connection_failed()
def handle_write(self): POLLER.unset_writable(self) if not utils_net.isconnected(self.endpoint, self.sock): self._connection_failed() return deferred = Deferred() deferred.add_callback(self._handle_connect) deferred.add_errback(self._handle_connect_error) deferred.callback(utils.ticks())
def _connection_failed(self): ''' Failed to connect first available epnt ''' if self.sock: POLLER.unset_writable(self) self.sock = None # MUST be below unset_writable() if not self.epnts: self.aterror.callback_each_np(self) return self._connect()
def _periodic(self, args): """ Periodically snap goodput """ stream = args[0] if stream.opaque: deferred = Deferred() deferred.add_callback(self._periodic_internal) deferred.add_errback(lambda err: self._periodic_error(stream, err)) deferred.callback(stream) POLLER.sched(1, self._periodic, stream)
def main(args): """ main() function """ logger = logging.getLogger() logger.setLevel(logging.DEBUG) LOG.verbose() ctx = {"uri": args[1]} RunnerDload(ctx) POLLER.loop()
def __init__(self, parent, sock, endpoint): Pollable.__init__(self) self.parent = parent self.lsock = sock self.endpoint = endpoint # Want to listen "forever" self.watchdog = -1 POLLER.set_readable(self) self.parent.handle_listen(self)
def main(args): """ Main function """ try: options, arguments = getopt.getopt(args[1:], "6A:np:vy") except getopt.error: sys.exit("usage: neubot skype [-6nvy] [-A address] [-p port]") if arguments: sys.exit("usage: neubot skype [-6nvy] [-A address] [-p port]") prefer_ipv6 = 0 # address = 'master.neubot.org' address = "localhost" runner = 1 port = 8080 noisy = 0 fakeprivacy = 0 for name, value in options: if name == "-6": prefer_ipv6 = 1 elif name == "-A": address = value elif name == "-n": runner = 0 elif name == "-p": port = int(value) elif name == "-v": noisy = 1 elif name == "-y": fakeprivacy = 1 if os.path.isfile(DATABASE.path): DATABASE.connect() CONFIG.merge_database(DATABASE.connection()) else: logging.warning("skype: database file is missing: %s", DATABASE.path) BACKEND.use_backend("null") if noisy: log.set_verbose() if runner: result = runner_clnt.runner_client( CONFIG["agent.api.address"], CONFIG["agent.api.port"], CONFIG["verbose"], "skype" ) if result: sys.exit(0) logging.info("skype: running the test in the local process context...") if not fakeprivacy and not privacy.allowed_to_run(): privacy.complain() logging.info("skype: otherwise use -y option to temporarily provide " "privacy permissions") sys.exit(1) handler = SkypeNegotiate() handler.connect((address, port), prefer_ipv6, 0, {}) POLLER.loop()
def send(self, send_octets, send_complete): ''' Async send() ''' if self.isclosed: raise RuntimeError('stream: send() on a closed stream') if self.send_octets: raise RuntimeError('stream: already send()ing') self.send_octets = send_octets self.send_complete = send_complete if self.send_blocked: logging.debug('stream: send() is blocked') return POLLER.set_writable(self)
def handshake(self): ''' Async SSL handshake ''' try: self.opaque.sock.sock.do_handshake() except ssl.SSLError: exception = sys.exc_info()[1] if exception.args[0] == ssl.SSL_ERROR_WANT_READ: POLLER.set_readable(self) elif exception.args[0] == ssl.SSL_ERROR_WANT_WRITE: POLLER.set_writable(self) else: raise else: stream = self.opaque self.opaque = None stream.atconnect.callback(stream)
def _schedule_after(self, interval): ''' Schedule next rendezvous after interval seconds ''' logging.info('background_rendezvous: next rendezvous in %d seconds', interval) timestamp = POLLER.sched(interval, self.run) STATE.update('idle', publish=False) STATE.update('next_rendezvous', timestamp)
def _waiting_piece(self, stream, data): ''' Invoked when new data is available ''' # Note: this loop cannot be adapted to process other messages # easily, as pointed out in <skype_defs.py>. context = stream.opaque context.bufferise(data) context.state['rcvr_data'].append((utils.ticks(), len(data))) while True: if context.left > 0: context.left = context.skip(context.left) if context.left > 0: break elif context.left == 0: tmp = context.pullup(4) if not tmp: break context.left, = struct.unpack('!I', tmp) if context.left > MAXRECV: raise RuntimeError('skype_clnt: PIECE too large') if not context.ticks: context.ticks = context.snap_ticks = utils.ticks() context.count = context.snap_count = stream.bytes_in context.snap_utime, context.snap_stime = os.times()[:2] POLLER.sched(1, self._periodic, stream) if context.left == 0: logging.debug('< {empty-message}') logging.info('skype_clnt: skype goodput test... complete') ticks = utils.ticks() timediff = ticks - context.ticks bytesdiff = stream.bytes_in - context.count context.state['goodput'] = { 'ticks': ticks, 'bytesdiff': bytesdiff, 'timediff': timediff, } if timediff > 1e-06: speed = utils.speed_formatter(bytesdiff / timediff) logging.info('skype_clnt: goodput: %s', speed) STATE.update('test_download', speed, publish=0) STATE.update('test_upload', 'N/A') self._periodic_internal(stream) context.state['complete'] = 1 stream.close() return else: raise RuntimeError('skype_clnt: internal error') stream.recv(MAXRECV, self._waiting_piece)
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], '6A:fp:v') except getopt.error: sys.exit('usage: neubot raw [-6fv] [-A address] [-p port]') if arguments: sys.exit('usage: neubot raw [-6fv] [-A address] [-p port]') prefer_ipv6 = 0 address = 'master.neubot.org' force = 0 port = 8080 noisy = 0 for name, value in options: if name == '-6': prefer_ipv6 = 1 elif name == '-A': address = value elif name == '-f': force = 1 elif name == '-p': port = int(value) elif name == '-v': noisy = 1 if os.path.isfile(DATABASE.path): DATABASE.connect() CONFIG.merge_database(DATABASE.connection()) else: logging.warning('raw: database file is missing: %s', DATABASE.path) BACKEND.use_backend('null') if noisy: log.set_verbose() if not force: result = runner_clnt.runner_client(CONFIG['agent.api.address'], CONFIG['agent.api.port'], CONFIG['verbose'], 'raw') if result: sys.exit(0) logging.warning('raw: failed to contact Neubot; is Neubot running?') sys.exit(1) logging.info('raw: run the test in the local process context...') handler = RawNegotiate() handler.connect((address, port), prefer_ipv6, 0, {}) POLLER.loop()
def recv(self, recv_bytes, recv_complete): ''' Async recv() ''' if self.isclosed: raise RuntimeError('stream: recv() on a closed stream') if self.recv_bytes > 0: raise RuntimeError('stream: already recv()ing') if recv_bytes <= 0: raise RuntimeError('stream: invalid recv_bytes') self.recv_bytes = recv_bytes self.recv_complete = recv_complete if self.recv_blocked: logging.debug('stream: recv() is blocked') return POLLER.set_readable(self)
def _periodic(self): ''' Periodically generate notification for old events ''' POLLER.sched(INTERVAL, self._periodic) self._tofire, queue = [], self._tofire for event in queue: # # WARNING! Please resist the temptation of merging # the [] and the del into a single pop() because that # will not work: this is a defaultdict and so here # event might not be in _subscribers. # queue = self._subscribers[event] del self._subscribers[event] logging.debug("notify: periodically publish event: %s", event) self._fireq(event, queue)
def _waiting_piece(self, stream, data): """ Invoked when new data is available """ # Note: this loop cannot be adapted to process other messages # easily, as pointed out in <raw_defs.py>. context = stream.opaque context.bufferise(data) context.state["rcvr_data"].append((utils.ticks(), len(data))) while True: if context.left > 0: context.left = context.skip(context.left) if context.left > 0: break elif context.left == 0: tmp = context.pullup(4) if not tmp: break context.left, = struct.unpack("!I", tmp) if context.left > MAXRECV: raise RuntimeError("raw_clnt: PIECE too large") if not context.ticks: context.ticks = context.snap_ticks = utils.ticks() context.count = context.snap_count = stream.bytes_in context.snap_utime, context.snap_stime = os.times()[:2] POLLER.sched(1, self._periodic, stream) if context.left == 0: logging.debug("< {empty-message}") logging.info("raw_clnt: raw goodput test... complete") ticks = utils.ticks() timediff = ticks - context.ticks bytesdiff = stream.bytes_in - context.count context.state["goodput"] = {"ticks": ticks, "bytesdiff": bytesdiff, "timediff": timediff} if timediff > 1e-06: speed = utils.speed_formatter(bytesdiff / timediff) logging.info("raw_clnt: goodput: %s", speed) STATE.update("test_progress", "100%", publish=False) STATE.update("test_download", speed, publish=0) STATE.update("test_upload", "N/A") self._periodic_internal(stream) context.state["complete"] = 1 stream.close() return else: raise RuntimeError("raw_clnt: internal error") stream.recv(MAXRECV, self._waiting_piece)
def main(args): ''' Main() function ''' try: options, arguments = getopt.getopt(args[1:], '') except getopt.error: sys.exit('usage: neubot background_win32') if options or arguments: sys.exit('usage: neubot background_win32') # Read settings from database CONFIG.merge_database(DATABASE.connection()) BACKEND.use_backend("neubot") BACKEND.datadir_init() # # Save logs into the database, to easily access # and show them via the web user interface. # LOG.use_database() logging.info('%s for Windows: starting up', utils_version.PRODUCT) # Complain if privacy settings are not OK privacy.complain_if_needed() background_api.start_api() BACKGROUND_RENDEZVOUS.start() __start_updater() POLLER.loop() logging.info('%s for Windows: shutting down', utils_version.PRODUCT) LOG.writeback() # # Make sure that we do not leave the database # in an inconsistent state. # DATABASE.close()
def main(args): ''' Main() function ''' try: options, arguments = getopt.getopt(args[1:], 'nO:vy') except getopt.error: sys.exit('usage: neubot background_rendezvous [-nvy] [-O setting]') if arguments: sys.exit('usage: neubot background_rendezvous [-nvy] [-O setting]') notest = False fakeprivacy = False settings = [] for name, value in options: if name == '-n': notest = True elif name == '-O': settings.append(value) elif name == '-v': LOG.verbose() elif name == '-y': fakeprivacy = True # Fake privacy settings if fakeprivacy: CONFIG.conf.update({ 'privacy.informed': 1, 'privacy.can_collect': 1, 'privacy.can_publish': 1 }) if notest: CONFIG.conf.update({'enabled': 0}) settings = utils_rc.parse_safe(iterable=settings) if 'interval' in settings: CONFIG.conf['agent.interval'] = settings['interval'] BACKGROUND_RENDEZVOUS.run() POLLER.loop()
def main(args): ''' main() function ''' try: options, arguments = getopt.getopt(args[1:], 'C:O:vy') except getopt.error: sys.exit(USAGE) if len(arguments) > 1: sys.exit(USAGE) sysname = 'win32' channel = CONFIG['win32_updater_channel'] privacy = False for tpl in options: if tpl[0] == '-C': channel = tpl[1] elif tpl[0] == '-O': sysname = tpl[1] elif tpl[0] == '-v': CONFIG['verbose'] = 1 elif tpl[0] == '-y': privacy = True # Honor -y and force privacy permissions if privacy: CONFIG.conf.update({'privacy.informed': 1, 'privacy.can_collect': 1, 'privacy.can_publish': 1}) CONFIG['win32_updater_channel'] = channel updater = UpdaterRunner(sysname, utils_hier.BASEDIR) if arguments: updater.retrieve_files({}, arguments[0]) else: # Enable automatic updates if we arrive here CONFIG.conf['win32_updater'] = 1 updater.retrieve_versioninfo() POLLER.loop()
def main(args): ''' Main function ''' try: options, arguments = getopt.getopt(args[1:], 'A:p:v') except getopt.error: sys.exit('usage: neubot background_api [-v] [-A address] [-p port]') if arguments: sys.exit('usage: neubot background_api [-v] [-A address] [-p port]') address = None port = None for name, value in options: if name == '-A': address = value elif name == '-p': port = int(value) elif name == '-v': CONFIG['verbose'] = 1 start_api(address, port) POLLER.loop()
def main(args): ''' Main() function ''' try: options, arguments = getopt.getopt(args[1:], 'ni:vy') except getopt.error: sys.exit('usage: neubot background_rendezvous [-nvy] [-i interval]') if arguments: sys.exit('usage: neubot background_rendezvous [-nvy] [-i interval]') notest = False fakeprivacy = False interval = 0 for name, value in options: if name == '-n': notest = True elif name == '-i': interval = int(value) elif name == '-v': CONFIG['verbose'] = 1 elif name == '-y': fakeprivacy = True # Fake privacy settings if fakeprivacy: CONFIG['privacy.informed'] = 1 CONFIG['privacy.can_collect'] = 1 CONFIG['privacy.can_publish'] = 1 if notest: CONFIG['enabled'] = 0 if interval: CONFIG['agent.interval'] = interval BACKGROUND_RENDEZVOUS.run() POLLER.loop()