def run(self): print "Service Started at: "+ self._address +":"+ str(self._port) self._server = LocalSMTPServer((self._address, self._port), None) self._server.set_parent(self) self._stopevent.clear() while not self._stopevent.isSet(): asyncore.loop(timeout=0.01, count=1)
def run(self):
print "Starting " + self.name
if self.name == 'socket':
asyncore.loop()
elif self.name == 'MySQLpoll':
mysqlpoll()
print "Exiting " + self.name
def _runImpl(self):
self._server = NimbleServer(router=self._router)
self._SERVER_THREAD = self
self._ACTIVATING = False
NimbleEnvironment.log(NimbleServerThread._ACTIVE_MESSAGE)
asyncore.loop()
def run(self):
"""Drives the communication service with the remote inspector."""
try:
while asyncore.socket_map:
asyncore.loop(timeout=1, count=1, use_poll=True)
except KeyboardInterrupt:
pass
def run(self):
self.active = True
self.__flag.set()
while self.active and asyncore.socket_map:
with self.active_lock:
asyncore.loop(timeout=0.1, count=1)
asyncore.close_all()
def start(self):
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
try:
self.bind((self.host, self.port))
except socket.error:
sys.stderr.write("Unable bind socket to %s:%s\n" % (self.host, self.port))
sys.exit(1)
self.listen(500)
# Check for a pidfile to see if the daemon already runs
try:
pf = file(self.pidfile,'r')
pid = int(pf.read().strip())
pf.close()
except IOError:
pid = None
if pid:
message = "pidfile %s already exist. Daemon already running?\n"
sys.stderr.write(message % self.pidfile)
sys.exit(1)
# Start the daemon
self.daemonize()
asyncore.loop(use_poll=True, timeout=0.1)
def run(self):
with shared.printLock:
print "Asyncore thread started"
while True:
asyncore.loop(timeout=1) # Despite the horrible parameter name, this function will not timeout until all channels are closed.
time.sleep(1)
def __init__(self, host, port):
''' Communicates between the GUI and server. '''
async_chat.__init__(self)
self.data = []
self.ID = -1
self.ch = ClientHelper(self)
while True:
if host == None:
host = raw_input("Enter the IP of the server (leave blank for localhost) >")
if len(host.strip()) == 0:
host = "localhost"
try:
print "connecting to...",host
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.connect((host,port))
self.set_terminator("\n")
self.register()
try: asyncore.loop()
except KeyboardInterrupt: print
break
except Exception:
print "Cannot connect, ", Exception
host = None
def setup_worker(fp, server_addr, port, counter=0, verbose=False,
error_profile=None):
""" This routine starts the worker.
fp: fp that should be used to store intermediate data
server_addr: ip address of server
port: port on server to connect to
counter: counts each round of denoising
verbose: verbose flag
error_profile: path to error profile .dat file
"""
if fp==None:
raise ValueError, "setup_worker needs file path for worker"
log_fh=None
if verbose:
dir = dirname(fp+".log")
if not exists(dir):
makedirs(dir)
log_fh = open(fp+".log","a",0)
#use local tmp if possible
new_fp = fp
if exists("/tmp"):
new_fp = "/tmp/" + split(fp)[1]
#set up the workers and start the loop
worker = DenoiseWorker(new_fp, server_addr, port, counter=counter,
log_fh=log_fh, error_profile=error_profile)
#this asyncore loop will run until the server closes the connection
loop()
def monitor(intent, project, dispatch, verbose):
""" Monitor of mcaf observation files.
Scans that match intent and project are searched (unless --dispatch).
Blocking function.
"""
# Set up verbosity level for log
if verbose:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
# Report start-up information
logger.info('* * * * * * * * * * * * * * * * * * * * *')
logger.info('* * * VLA Dispatcher is now running * * *')
logger.info('* * * * * * * * * * * * * * * * * * * * *')
logger.info('* Looking for intent = %s, project = %s' % (intent, project))
logger.debug('* Running in verbose mode')
if dispatch:
logger.info('* Running in dispatch mode. Will dispatch obs commands.')
else:
logger.info('* Running in listening mode. Will not dispatch obs commands.')
logger.info('* * * * * * * * * * * * * * * * * * * * *\n')
# This starts the receiving/handling loop
controller = FRBController(intent=intent, project=project, dispatch=dispatch, verbose=verbose)
obsdoc_client = mcaf_library.ObsdocClient(controller)
try:
asyncore.loop()
except KeyboardInterrupt:
# Just exit without the trace barf
logger.info('Escaping mcaf_monitor')
def start(self):
logging.info("Starting client...")
self.local.start()
logging.info("Awaiting local connections...")
self.remote.start()
logging.info("Client started. Connecting to [%s:%d]..." % (self.address, self.port))
asyncore.loop()
def start_smtp_server(queue):
server = TestingSMTPServer(SMTP_SERVER, None, queue)
try:
asyncore.loop()
finally:
queue.close()
server.close()
def unix_mainloop(repodir, port, logfilename):
try:
port = int(port)
except ValueError:
port = None
if not os.path.isdir(repodir):
sys.stderr.write("Specified directory, %s, is not a directory!\n" % repodir)
usage()
elif port is None:
sys.stderr.write("Bad port number, %s, specified.\n", portnum)
usage()
try:
repo = start_angel(repodir, port, logfilename)
except:
sys.stderr.write("%s: exception initializing angel:\n%s" % (
time.ctime(), ''.join(traceback.format_exception(*sys.exc_info()))))
sys.exit(1)
# Finally, start up the server loop! This loop will not exit until
# all clients and servers are closed. You may cleanly shut the system
# down by sending SIGINT (a.k.a. KeyboardInterrupt).
from uplib.plibUtil import note
while True:
try:
asyncore.loop()
except (KeyboardInterrupt, SystemExit), x:
note(4, "Exited from main loop due to exception:\n%s", ''.join(traceback.format_exception(*sys.exc_info())))
raise
except:
def loop(self):
"""The main loop of bzrflag.
Checks events, updates positions, and draws to the screen until
the pygame window is closed, KeyboardInterrupt, or System Exit.
"""
self.running = True
self.start_servers()
if not self.config['test']:
self.display.setup()
try:
while self.running:
if self.game.end_game:
break
asyncore.loop(constants.LOOP_TIMEOUT, count=1)
self.update_game()
if not self.config['test']:
self.update_graphics()
self.display.update()
except KeyboardInterrupt:
pass
finally:
final_scores = '\nFinal Score\n'
for team in self.game.teams:
team_total = self.game.teams[team].score.total()
final_scores += 'Team %s: %d\n' % (team, team_total)
if not self.config['test']:
print final_scores
def handle_noargs(self, **options):
receiver = EmailReceiver('localhost', 7999)
try:
asyncore.loop()
except KeyboardInterrupt:
pass
def start(self, sock, force):
self.__sock = sock
# Remove socket
if os.path.exists(sock):
logSys.error("Fail2ban seems to be already running")
if force:
logSys.warning("Forcing execution of the server")
os.remove(sock)
else:
raise AsyncServerException("Server already running")
# Creates the socket.
self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.set_reuse_addr()
try:
self.bind(sock)
except Exception:
raise AsyncServerException("Unable to bind socket %s" % self.__sock)
AsyncServer.__markCloseOnExec(self.socket)
self.listen(1)
# Sets the init flag.
self.__init = True
# TODO Add try..catch
# There's a bug report for Python 2.6/3.0 that use_poll=True yields some 2.5 incompatibilities:
if (sys.version_info >= (2, 7) and sys.version_info < (2, 8)) \
or (sys.version_info >= (3, 4)): # if python 2.7 ...
logSys.debug("Detected Python 2.7. asyncore.loop() using poll")
asyncore.loop(use_poll=True) # workaround for the "Bad file descriptor" issue on Python 2.7, gh-161
else:
asyncore.loop(use_poll=False) # fixes the "Unexpected communication problem" issue on Python 2.6 and 3.0
def test_connection_attributes(self):
server = BaseServer(self.family, self.addr)
client = BaseClient(self.family, server.address)
# we start disconnected
self.assertFalse(server.connected)
self.assertTrue(server.accepting)
# this can't be taken for granted across all platforms
#self.assertFalse(client.connected)
self.assertFalse(client.accepting)
# execute some loops so that client connects to server
asyncore.loop(timeout=0.01, use_poll=self.use_poll, count=100)
self.assertFalse(server.connected)
self.assertTrue(server.accepting)
self.assertTrue(client.connected)
self.assertFalse(client.accepting)
# disconnect the client
client.close()
self.assertFalse(server.connected)
self.assertTrue(server.accepting)
self.assertFalse(client.connected)
self.assertFalse(client.accepting)
# stop serving
server.close()
self.assertFalse(server.connected)
self.assertFalse(server.accepting)
def multi_ping_query(hosts, timeout=1, step=512, ignore_errors=False):
"""
Sends multiple icmp echo requests at once.
"hosts" is a list of ips or hostnames which should be pinged.
"timeout" must be given and a integer or float greater than zero.
"step" is the amount of sockets which should be watched at once.
See the docstring of "PingQuery" for the meaning of "ignore_erros".
"""
results, host_list, id = {}, [], 0
for host in hosts:
try:
host_list.append(socket.gethostbyname(host))
except socket.gaierror:
results[host] = None
while host_list:
sock_list = []
for ip in host_list[:step]: # select supports only a max of 512
id += 1
sock_list.append(PingQuery(ip, id, timeout, ignore_errors))
host_list.remove(ip)
# Remember to use a timeout here. The risk to get an infinite loop
# is high, because noone can guarantee that each host will reply!
asyncore.loop(timeout)
for sock in sock_list:
results[sock.get_host()] = sock.get_result()
return results
def run(self, host, port=6667):
if self.debug:
message = 'Connecting to %s:%s...' % (host, port)
print >> sys.stderr, message,
s = None
for res in socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
try:
s = socket.socket(af, socktype, proto)
except socket.error as msg:
s = None
continue
try:
self.addr = sa
s.connect(sa)
except socket.error as msg:
s.close()
s = None
continue
break
if s is None:
if self.debug:
print >> sys.stderr, 'could not open socket'
sys.exit(1)
# Lets hope asyncore doesnt change anything in create_socket and connect
# Emulating http://hg.python.org/cpython/file/2.7/Lib/asyncore.py#l295
s.setblocking(0)
self.set_socket(s)
# Emulating http://hg.python.org/cpython/file/2.7/Lib/asyncore.py#l344
self.connected = False
self.connecting = True
self.handle_connect_event()
try: asyncore.loop()
except KeyboardInterrupt:
sys.exit()
def start():
try:
server = Server('localhost', 0)
write_file(str(server.port_))
asyncore.loop() # blocks
except Exception as err:
logger.exception(err)
def asyncore_call():
try:
asyncore.loop(count=1)
except:
LOG_CURRENT_EXCEPTION()
BigWorld.callback(0.1, asyncore_call)
def _listeners_and_readers_loop(self):
while self._listeners_and_readers or not self.stopping:
try:
asyncore.loop(count=1, timeout=1,
map=self._listeners_and_readers)
except:
pass
def run():
try:
opts, args = getopt.getopt(sys.argv[1:], "ht")
except getopt.error as msg:
print(str(msg) + "\n\n" + __doc__, file=sys.stderr)
sys.exit()
for opt, arg in opts:
if opt == "-h":
print(__doc__, file=sys.stderr)
sys.exit()
elif opt == "-t":
state.isTest = True
state.runTestServer = True
state.createWorkers()
if state.runTestServer:
print("Running a test SMTP server on port 8025...")
TestListener()
asyncore.loop()
else:
state.isTest = True
state.buildServerStrings()
testSocketMap = {}
def runTestServer():
TestListener(socketMap=testSocketMap)
asyncore.loop(map=testSocketMap)
def runProxy():
trainer = SMTPTrainer(Classifier(), state)
BayesSMTPProxyListener("localhost", 8025, ("", 8026), trainer)
Dibbler.run()
_thread.start_new_thread(runTestServer, ())
_thread.start_new_thread(runProxy, ())
sb_test_support.unittest_main(argv=sys.argv + ["suite"])
def start(self):
self.log.debug('Starting server...')
try:
asyncore.loop()
finally:
self.log.debug('Server closed.')
def initiate_connect(self, host, port):
if self.verbose:
message = 'Connecting to %s:%s...' % (host, port)
print >> sys.stderr, message,
if self.use_ssl:
self.send = self._ssl_send
self.recv = self._ssl_recv
for res in socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
try:
self.create_socket(af,socktype)
except socket.error as msg:
continue
try:
self.connect(sa)
except socket.error as msg:
self.close()
continue
break
else:
raise Exception("No connectivity")
try: asyncore.loop()
except KeyboardInterrupt:
sys.exit()
except Exception, e:
print '[asyncore]', e
def loop(): global scheduler while True: if scheduler.empty(): asyncore.loop(count=1) else: scheduler.run()
def handle_noargs(self, **options):
from django.conf import settings
import asyncore
import socket
host_port = (settings.EMAIL_HOST, settings.EMAIL_PORT)
try:
server = MailDebuggingServer(host_port, None)
except socket.error:
raise CommandError('Could not set up the mail server at %s:%d.\n'
% host_port
+ 'Make sure that you can actually host a server using the\n'
+ 'current values for settings.EMAIL_HOST and settings.EMAIL_PORT.')
print('Mail debugging server is running at %s:%d' % host_port)
print('Emails from this Django site will appear here instead of being sent.')
print('Quit the server with CONTROL-C.')
try:
asyncore.loop()
except KeyboardInterrupt:
# Print a blank line after the ^C. This looks nicer.
print('')
pass
def join_game(screen, host, port, team):
try:
sock = socket.socket()
sock.connect((host, port))
mapname = [None]
other_team = [None]
spawns = [None]
def handler(type, data):
if type == "MAP":
mapname[0] = data
if type == "TEAM":
other_team[0] = deserialize_team(data)
if type == "SPAWNS":
spawns[0] = deserialize_spawns(data)
conn = Messager(handler, sock)
conn.push_message("TEAM", serialize_team(team))
while mapname[0] is None or other_team[0] is None or spawns[0] is None:
asyncore.loop(count=1, timeout=0.1)
except:
sys.excepthook(*sys.exc_info())
return
teams = [("Player 1", conn, other_team[0]), ("Player 2", None, team)]
game = XadirMain(screen, mapname=mapname[0])
game.load_resources()
game.init_teams(teams, spawns[0])
game.main_loop()
def DevDemo(args):
args = make_argument_parser().parse_args()
if not args.srv_host or not args.uuidfile:
print make_argument_parser().parse_args(['-h'])
exit(1)
errqueue = Queue()
statqueue = Queue()
errlog = ErrLog('DevDemo')
statlog = StatLog('DevDemo')
errworker = WorkerThread(errqueue,errlog,)
errworker.start()
statworker = WorkerThread(statqueue,statlog)
statworker.start()
host = ()
try:
d = args.srv_host.index(':')
host = (args.srv_host[:d],int(args.srv_host[d:]))
except:
host = (args.srv_host,3478)
uulist = read_uuid_file(args.uuidfile)
for uid in uulist:
apps = DevSocket(host,uid,errqueue,statqueue)
asyncore.loop(timeout=2)
def ThreadMain(self):
self._logger.info('Starting up')
while not self._quit:
asyncore.loop(timeout=0.5, count=1)
if not asyncore.socket_map:
time.sleep(0.5)
self._logger.info('Quitting')
def main():
print("Server is running...")
svr = Server()
asyncore.loop()
class Server(ServerBase):
"""A standalone HTTP server.
"""
# ServerBase boilerplate
channel_class = Channel
SERVER_IDENT = 'httpy'
def __init__(self, responder, address, threads, uid):
"""Takes an IResponder.
"""
#validate_input(responder, address, threads, uid)
self.responder = responder
self.address = address
if address[0] in ('/', '.'):
self.sockfam = socket.AF_UNIX
else:
self.sockfam = socket.AF_INET
self.threads = threads
self.uid = uid
# Set up signal handling so we can shut down cleanly.
# ===================================================
for sig in STOP_SIGNALS:
signal.signal(sig, self.stop)
# Satisfy ServerBase requirements.
# ================================
asyncore.dispatcher.__init__(self)
self.adj = default_adj
if (not WINDOWS) and (self.sockfam == socket.AF_UNIX):
# The default adjustment doesn't apply here, and triggers an error.
self.adj.socket_options = []
self.verbose = False
task_dispatcher = ThreadedTaskDispatcher()
task_dispatcher.setThreadCount(self.threads)
self.task_dispatcher = task_dispatcher
self.logger = logging.getLogger(self.__class__.__name__)
def start(self):
"""Start the server.
"""
# Bind to an address.
# ===================
self.create_socket(self.sockfam, socket.SOCK_STREAM)
self.set_reuse_addr()
if (not WINDOWS) and (self.sockfam == socket.AF_UNIX):
if os.path.exists(self.address):
os.unlink(self.address)
timeout = time.time() + 10
while 1:
if time.time() < timeout:
try:
self.bind(self.address)
break
except socket.error, err:
time.sleep(0.5)
else:
raise err
# Switch user accounts.
# =====================
if self.uid:
os.setreuid(self.uid)
# Start listening.
# ================
self.accept_connections()
if self.sockfam == socket.AF_INET:
addr, port = self.socket.getsockname()
msg = "port %s" % port
elif (not WINDOWS) and (self.sockfam == socket.AF_UNIX):
msg = "%s" % self.address
print >> sys.stderr, "HTTP server started on %s" % msg
asyncore.loop(timeout=5)
# Become nobody
if options.setuid:
try:
import pwd
except ImportError:
print >> sys.stderr, \
'Cannot import module "pwd"; try running with -n option.'
sys.exit(1)
nobody = pwd.getpwnam('nobody')[2]
try:
os.setuid(nobody)
except OSError, e:
if e.errno != errno.EPERM: raise
print >> sys.stderr, \
'Cannot setuid "nobody"; try running with -n option.'
sys.exit(1)
classname = options.classname
if "." in classname:
lastdot = classname.rfind(".")
mod = __import__(classname[:lastdot], globals(), locals(), [""])
classname = classname[lastdot + 1:]
else:
import __main__ as mod
class_ = getattr(mod, classname)
proxy = class_((options.localhost, options.localport),
(options.remotehost, options.remoteport))
try:
asyncore.loop()
except KeyboardInterrupt:
pass
def profile_loop ():
try:
asyncore.loop()
except KeyboardInterrupt:
pass
def notifier(): notifier = pyinotify.AsyncNotifier(wm, EventHandler()) wdd = wm.add_watch(basepath, mask, rec=False) asyncore.loop()
def sendmsg(msg):
Client(msg)
asyncore.loop(1)
def start(self):
self.server = SMTPServerMock(("0.0.0.0", 4444),
None,
enable_SMTPUTF8=True)
asyncore.loop()
class CoreClient(asynchat.async_chat, threading.Thread):
"""This is a hybrid class of asyn_chat and Thread. It deals with
the communications with the server. An instance of this class
will be a component of the Client and will be runned in a different
thread apart from the GUI.
"""
def __init__(self, address):
"""*Note*: the connection is established in the `run` routine
instead of __init__.
"""
asynchat.async_chat.__init__(self)
threading.Thread.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_address = address
self.set_terminator(TERM)
# incomming data buffer
self.data = []
# command dictionary, dispatches the command from the server
self.cmd_dict = {
'OPEN': self._cmd_open,
'CLOSE': self._cmd_close,
'VALUE': self._cmd_value,
'PARENT': self._cmd_parent,
'PATH': self._cmd_path
}
# algorithm dictionary
self.algo_dict = {
ASTARM: 'ASTARM',
ASTARE: 'ASTARE',
ASTARC: 'ASTARC',
DIJKSTRA: 'DIJKSTRA',
BDBFS: 'BDBFS'
}
def run(self):
"""Overides the run method of threading.Thread
"""
# try to connect the server every COUNTDOWN_COOLDOWN seconds
# if not connected
while not self.connected:
try:
self.connect(self.server_address)
except Exception, e:
print 'Unable to connect', self.server_address
print 'Retry in %d seconds' % COUNTDOWN_COOLDOWN
time.sleep(COUNTDOWN_COOLDOWN)
self.close()
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
print 'connected with server at', self.server_address
# begin the main loop
try:
asyncore.loop()
except KeyboardInterrupt:
self.close()
raise SystemExit
def run(self):
logger.debug("Thread Start")
l = Listener(self._config)
asyncore.loop()
def __str__(self):
return "%s:%d" % (self.host, self.port)
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG, format="%(name)s %(message)s")
clients = []
socket_map = {}
HTTP_HOST = "www.baidu.com"
HTTP_PORT = 80
WHOIS_HOST = "36.55.244.17"
WHOIS_PORT = 43
for line in sys.stdin:
line = line.strip()
if not line:
continue
host, port = line.split(":")
clients.append(
AsyncHTTPTunnelClient(host, port, WHOIS_HOST, WHOIS_PORT, "whois",
socket_map))
#clients.append(AsyncHTTPTunnelClient(host, port, HTTP_HOST, HTTP_PORT, "http", socket_map))
asyncore.loop(timeout=1, use_poll=True, map=socket_map)
for c in clients:
print c.buffer.getvalue()
def get_flowgram_distances_on_cluster(id,
flowgram,
flowgrams,
fc,
ids,
num_cores,
num_flows,
spread,
client_sockets=[]):
"""Computes distance scores of flowgram to all flowgrams in parser.
id: The flowgram identifier, also used to name intermediate files
flowgram: This flowgram is used to filter all the other flowgrams
flowgrams: iterable filehandle of flowgram file
fc: a sink of flowgrams, which serves as source in the next round
ids: list of flowgram ids that should be used from flowgrams
num_cores: number of cpus
num_flows: Number of flows in parser
client_sockets: A list of open sockets for client-server communication
spread: historical distribution of processing runtimes
"""
epoch = time()
check_flowgram_ali_exe()
qiime_config = load_qiime_config()
min_per_core = int(qiime_config['denoiser_min_per_core'])
CLOUD = not qiime_config['cloud_environment'] == "False"
#if using from future import division this has to be checked,
#as we want true integer division here
per_core = max(min_per_core, (num_flows / num_cores) + 1)
names = []
scores = []
#Need to call this here, since we iterate over the same iterator repeatedly.
#Otherwise the call in ifilter will reset the iterator by implicitely calling __iter__.
#test if iter does the same
flowgrams_iter = flowgrams.__iter__()
#prepare input files and commands
#synchronous client-server communication
workload = compute_workload(num_cores, num_flows, spread)
debug_count = 0
for i in range(num_cores):
socket = client_sockets[i]
#send master flowgram to file first
send_flowgram_to_socket(id, flowgram, socket)
if (workload[i] < 1):
#no data left for this poor guy
save_send(socket, "--END--")
continue
else:
# Then add all others which are still valid, i.e. in ids
for (k, f) in (izip(
range(workload[i]),
ifilter(lambda f: ids.has_key(f.Name), flowgrams_iter))):
fc.add(f)
send_flowgram_to_socket(k, f, socket, trim=False)
names.append(f.Name)
debug_count += 1
#send the termination signal
save_send(socket, "--END--")
#asynchronous client-server communication
#ClientHandlers write data in results
results = [None] * num_cores #
timing = [0.0 for x in xrange(num_cores)]
for i in range(num_cores):
socket = client_sockets[i]
ClientHandler(socket, i, results, timing)
loop()
#end asynchronous loop
spread = adjust_processing_time(num_cores, workload, timing, epoch)
#flatten list
scores = [item for list in results for item in list]
if (debug_count != len(scores)):
raise RuntimeError,"Something bad has happened! I received less " +\
"alignment scores %d than there are flowgrams %d. Most likely this " \
% (len(scores), debug_count)+\
"means that the alignment program is not setup correctly or corrupted. "+\
"Please run the test scripts to figure out the cause of the error."
return (scores, names, fc)
def main():
global remote_configuration_command_id
# FPS debug
last_time = time.time()
frame_counter = 0
fps = 0
fps_counter = 0
# Load default settings
load_configuration_file()
# Controller start
controller = main_controller()
controller.reload_settings()
# Servers start
remote_configuration_server("10.42.0.1", 6000)
tserver = telemetry_server("10.42.0.1", 7001)
# Data logger
datalogger = my_datalogger.datalogger("datalogger")
# Main loop
counter = 0
while True:
# Non blocking call
asyncore.loop(timeout=0, count=1)
# Process command ID
if remote_configuration_command_id == 1:
controller.quit()
break
elif remote_configuration_command_id == 2:
controller.init_ai()
elif remote_configuration_command_id == 3:
print("Start recording...")
controller.start_recording()
elif remote_configuration_command_id == 4:
print("Stop recording!")
controller.stop_recording()
elif remote_configuration_command_id == 5:
print("Start running...")
controller.start_running()
datalogger.start()
elif remote_configuration_command_id == 6:
print("Stop running!")
datalogger.stop()
controller.stop_running()
elif remote_configuration_command_id == 10:
controller.reload_settings()
remote_configuration_command_id = 0
# Process
controller.process()
# Telemetry
counter += 1
msg = str(counter) + ';' + str(float(
controller.direction)) + ';' + str(float(
controller.throttle)) + ';' + str(
float(controller.actual_error))
tserver.sendTelemetry(msg)
# Data logger
log_list = []
log_list.append(float(fps))
log_list.append(float(controller.lidar_distance_gauche))
log_list.append(float(controller.lidar_distance_droit))
log_list.append(float(controller.actual_error))
log_list.append(float(controller.positional_error))
log_list.append(float(controller.pid_wall))
log_list.append(float(controller.direction))
log_list.append(float(controller.throttle))
log_list.append(float(controller.mode))
datalogger.record(log_list)
# FPS debug
frame_counter += 1
if time.time() >= last_time + 1.0:
last_time = time.time()
fps = frame_counter
frame_counter = 0
# Local Debug
if fps_counter % 60 == 0:
print("fps:" + str(fps) + " DIR:" + str(controller.direction) +
" THR:" + str(controller.throttle) + " MODE:" +
str(controller.mode) + " LiG:" +
str(controller.lidar_distance_gauche) + " LiD:" +
str(controller.lidar_distance_droit))
fps_counter += 1
def asyncore_thread(self):
asyncore.loop(map=self.channel_map)
def loop(self):
asyncore.loop()
def collect_incoming_data(self, data): #读取和暂存数据
self.data.append(data.decode())
def found_terminator(self): #遇到结束符时处理数据
line = ''.join(self.data) #内容整合为一行
self.data = [] #清空数据列表
print(line) #打印
class ChatServer(dispatcher):
def __init__(self, port):
dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM) #指定要创建的套接字类型
self.set_reuse_addr() #地址重用
self.bind(('', port)) #将服务器关联到特定地址
self.listen(5) #监听连接，最大连接数为5
self.sessions = []
def handle_accept(self):
conn, addr, = self.accept() #允许客户端连接，返回套接字和地址
self.sessions.append(ChatSession(conn))
print('Connection attempt from', addr[0])
if __name__ == '__main__':
s = ChatServer(PORT)
try:
asyncore.loop() #启动监听循环
except KeyboardInterrupt:
pass
def conn(self, server, port):
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.connect((server, port))
asyncore.loop()
def online_start(self):
'''start a local server'''
self.robots = []
MainServer(8080)
asyncore.loop()
print('out')
def run(self):
asyncore.loop()
except ValueError:
pass
print('after reap', pid)
def register_parent_signal(self):
signal.signal(signal.SIGINT, self.exit_parent)
signal.signal(signal.SIGTERM, self.exit_parent)
signal.signal(signal.SIGCHLD, self.reap_child) # 监听子进程退出
def exit_child(self, sig, frame):
self.close() # 关闭serversocket
asyncore.close_all() # 关闭所有clientsocket
print('all closed')
def register_child_signal(self):
signal.signal(signal.SIGINT, self.exit_child)
signal.signal(signal.SIGTERM, self.exit_child)
def handle_accept(self):
pair = self.accept() # 接收新连接
if pair is not None:
sock, addr = pair
RPCHandler(sock, addr)
if __name__ == '__main__':
host = sys.argv[1]
port = int(sys.argv[2])
RPCServer(host, port)
asyncore.loop() # 启动事件循环
return value
return retrier
def multi_interact(self, line, handler):
for server in self.servers:
logger.warn("Sending %s to: %s", line, server)
try:
server._do_interaction(line, handler.clone())
except ServerInUse, (msg, server):
logger.info(msg)
# ignore
pass
asyncore.loop(use_poll=True,
timeout=ASYNCORE_TIMEOUT,
count=ASYNCORE_COUNT)
results = filter(None, (s.result for s in self.servers))
return results
@retry_until_succeeds
def _all_broadcast(self, cmd, *args, **kwargs):
"""Broadcast to all servers and return the results in a compacted
dictionary, where the keys are the server objects and the values are
the result of the command.
"""
func = getattr(protohandler, "process_%s" % cmd)
return self.multi_interact(*func(*args, **kwargs))
@retry_until_succeeds
def asyncloop():
# check every sec if all channel are close
asyncore.loop(1)
except ValueError:
pass
print 'after reap', pid
def register_parent_signal(self):
signal.signal(signal.SIGINT, self.exit_parent)
signal.signal(signal.SIGTERM, self.exit_parent)
signal.signal(signal.SIGCHLD, self.reap_child) # 监听子进程退出...
def exit_child(self, sig, frame):
self.close() # 关闭 serversocket
asyncore.close_all() # 关闭所有 clientsocket
print 'all closed'
def register_child_signal(self):
signal.signal(signal.SIGINT, self.exit_child)
signal.signal(signal.SIGTERM, self.exit_child)
def handle_accept(self):
pair = self.accept() # 接收新连接
if pair is not None:
sock, addr = pair
RPCHandler(sock, addr)
if __name__ == '__main__':
host = sys.argv[1]
port = int(sys.argv[2])
RPCServer(host, port)
asyncore.loop() # 启动事件循环...
def test_invalid_chunk_length(self):
self.sock.sendall('get\r\na bogus message\r\n')
asyncore.loop(1, map=self.map, count=1)
assert self.error and self.error[0] is asynchunk.Error
def run(self): print "PacClient is running!" asyncore.loop()
def test_chunk_length_with_extension(self):
data = self._encoded[0:1] + ' ; some extension ' + self._encoded[1:]
self.sock.sendall(data)
asyncore.loop(1, map=self.map, count=1)
assert self.incoming == self._chunks
assert not self.error
def run(self):
while not self._stopevent.isSet():
asyncore.loop(timeout=SmtpMailsink.
TIME_TO_WAIT_BETWEEN_CHECKS_TO_STOP_SERVING,
count=1)
self.create_socket(socket.AF_INET, socket.SOCK_DGRAM)
self.bind(('', 0)) # bind to all interfaces and a "random" free port.
print "Connecting..."
# Once a "connection" is made do this stuff.
def handle_connect(self):
print "Connected"
# If a "connection" is closed do this stuff.
def handle_close(self):
self.close()
# If a message has arrived, process it.
def handle_read(self):
data, addr = self.recv(2048)
print data
# Actually sends the message if there was something in the buffer.
def handle_write(self):
if self.buffer != "":
print self.buffer
sent = self.sendto(self.buffer, (self.server, self.port))
self.buffer = self.buffer[sent:]
connection = AsyncoreClientUDP("127.0.0.1", 5005) # create the "connection"
while 1:
asyncore.loop(count=10) # Check for upto 10 packets this call?
connection.buffer += raw_input(
" Chat > ") # raw_input (this is a blocking call)
def test_decode(self):
self.sock.sendall(self._encoded)
asyncore.loop(1, map=self.map, count=1)
assert self.incoming == self._chunks
assert not self.error
def run(spin=SPIN):
if _debug: run._debug("run spin=%r", spin)
global running, taskManager, deferredFns, sleeptime
# reference the task manager (a singleton)
taskManager = TaskManager()
# count how many times we are going through the loop
loopCount = 0
running = True
while running:
# if _debug: run._debug(" - time: %r", time.time())
loopCount += 1
# get the next task
task, delta = taskManager.get_next_task()
try:
# if there is a task to process, do it
if task:
# if _debug: run._debug(" - task: %r", task)
taskManager.process_task(task)
# if delta is None, there are no tasks, default to spinning
if delta is None:
delta = spin
# there may be threads around, sleep for a bit
if sleeptime and (delta > sleeptime):
time.sleep(sleeptime)
delta -= sleeptime
# if there are deferred functions, use a small delta
if deferredFns:
delta = min(delta, 0.001)
# if _debug: run._debug(" - delta: %r", delta)
# loop for socket activity
asyncore.loop(timeout=delta, count=1)
# check for deferred functions
while deferredFns:
# get a reference to the list
fnlist = deferredFns
deferredFns = []
# call the functions
for fn, args, kwargs in fnlist:
# if _debug: run._debug(" - call: %r %r %r", fn, args, kwargs)
fn(*args, **kwargs)
# done with this list
del fnlist
except KeyboardInterrupt:
if _debug: run._info("keyboard interrupt")
running = False
except Exception, err:
if _debug: run._exception("an error has occurred: %s", err)
def run():
"""
Start Bulk.
Handles all commmand line arguments, logging setup,
and kicking off the network listener.
"""
parser = argparse.ArgumentParser(description='A content inspecting \
mail relay built on smtpd')
parser.add_argument(
'--bind_address',
default='127.0.0.1',
help='Address to bind to and listen on for incoming mail. \
Default is 127.0.0.1')
parser.add_argument(
'--bind_port',
default=1025,
type=int,
help='Port to bind to and to listen on for incoming mail. \
Default is 1025')
parser.add_argument('--remote_address',
default='127.0.0.1',
help='Remote address to forward outbound mail. \
Default is 127.0.0.1')
parser.add_argument(
'--remote_port',
default=25,
type=int,
help='Remote port to forward outbound mail. Default is 25')
# Note that type can be a function
parser.add_argument(
'--base_log_directory',
default='/tmp/bulk/',
type=directory_name,
help='Directory to write log files, messages, and attachments. \
Default is /tmp/bulk/')
parser.add_argument(
'--log_all_messages',
action='store_true',
help='Log all messages to /base_log_directory/messages/')
parser.add_argument(
'--block',
action='store_true',
help='Block mail with quarantined attachments. Default is False')
parser.add_argument(
'--always_block',
action='store_true',
help='Turn the proxy into a server (block all). Default is false')
parser.add_argument(
'--save_attachments',
action='store_true',
help='Experimental: Save all attachments as seperate files. \
Default is false.')
parser.add_argument(
'--log_config',
default='/etc/bulk/logging.conf',
help='Logging config file. Default is /etc/bulk/logging.conf')
# add a group to mark certain arguments as required
req = parser.add_argument_group('required')
# the processor arg is the only required argument
req.add_argument(
'--processor',
default=[],
required=True,
nargs='+',
action=CreateProcessor,
dest='processors',
help='Choose a processing engine by supplying an import string as the \
first positional argument and multiple rules files as optional \
following arguments. For example: \
--processor bulk.processors.basic /etc/bulk/rules/simple')
args = parser.parse_args()
err = validate_arguments(args)
if err:
raise Exception(err)
create_sub_directories(args.base_log_directory)
# Setup logging
logger = setup_logging(args.log_config)
logger.info('Starting Bulk Proxy')
logger.info('Listening on %s:%s' % (args.bind_address, args.bind_port))
if not args.always_block:
logger.info('Forwarding to %s:%s' %
(args.remote_address, args.remote_port))
logger.info('Bulk matches will be logged to %squarantine/' %
args.base_log_directory)
if args.block:
logger.info('Emails that match a processor rule will be BLOCKED')
if args.always_block:
logger.info('Bulk set to BLOCK ALL mail')
if args.log_all_messages:
logger.info('Logging ALL messages to %smessages/' %
args.base_log_directory)
if args.save_attachments:
logger.info('Saving attachments to %sattachments/' %
args.base_log_directory)
if args.processors:
for p in args.processors:
logger.info('Bulk using %s' % p)
server = BulkProxy((args.bind_address, args.bind_port),
(args.remote_address, args.remote_port),
args.processors,
base_directory=args.base_log_directory,
block=args.block,
always_block=args.always_block,
log=args.log_all_messages,
save_attachments=args.save_attachments)
# Kick off the main process
asyncore.loop()
