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()
