def __init__(self, uuid, proc, path, port):
"""Initialize an engine based on existing system process. """
self.uuid = uuid
self.proc = proc
self.port = port
self.path = path
self.util = psutil.Process(proc.pid)
self.evaluating = False
self.queue = collections.deque()
self.url = "http://localhost:%s" % port
self.files = []
self.out = StringIO()
self.err = StringIO()
stdout = proc.stdout.fileno()
stderr = proc.stderr.fileno()
self._set_nonblocking(stdout)
self._set_nonblocking(stderr)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(stdout, self._on_stdout, ioloop.READ | ioloop.ERROR)
ioloop.add_handler(stderr, self._on_stderr, ioloop.READ | ioloop.ERROR)
def __init__(self, session, user, ws_handler):
global args
wdir = SESSIONS_DIR + session
mkdir_p(wdir)
# Delete and create a dummy file so that the directory mtime changes....
#
tmp_fname = wdir + '/' + str(time.time())
ftmp = open(tmp_fname, 'w+')
ftmp.close()
os.remove(tmp_fname)
self.mtime = os.stat(wdir).st_mtime;
self.h = subprocess.Popen(args.julia, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=wdir)
self.session = session
jl_stdout = self.h.stdout.fileno()
flags = fcntl.fcntl(jl_stdout, fcntl.F_GETFL)| os.O_NDELAY
fcntl.fcntl(jl_stdout, fcntl.F_SETFL, flags)
ioloop.add_handler(jl_stdout, functools.partial(push_to_clients, self.h.stdout, self), ioloop.READ|ioloop.ERROR)
global g_sessions
g_sessions[session] = self
self.resp_buffer = ''
self.clients = []
self.history = deque([])
self.add_user(user, ws_handler)
self.cmd_q = deque()
def add_task(self, taskname, *args, **kwargs):
"""Run a function in a Process. All args and kwargs except
`callback` are passed to task.
:param taskname: a `callable`
:keyword callback: callable with a single argument (task result)
This method creates a random UnixSocket under /tmp/ for
communication, registers a handler on `tornado.ioloop.IOLoop`
with its fd, creates a `Pipe` for communicating back the
result and runs `taskname` using `run_as_process`. Which runs
the given task, sends result back through and connects to the
UnixSocket to let IOLoop know
"""
user_cb = kwargs.pop('callback')
assert callable(user_cb)
ioloop = tornado.ioloop.IOLoop().instance()
fname = '/tmp/proc_socket_%s' % uuid4()
# create & bind socket
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(fname)
sock.listen(1)
# pass down input callback
callback = functools.partial(self._on_complete, user_cb)
ioloop.add_handler(sock.fileno(), callback, ioloop.READ)
# subprocess
self.tor_conn, proc_conn = Pipe()
run_as_process(fname, proc_conn, target=taskname,
args=args, kwargs=kwargs)
self.process_socket = sock
def main():
global sources, collector, collector_stream
tornado.options.parse_command_line()
application = tornado.web.Application([
(r"/", MainHandler),
(r"/echo",EchoWebSocket),
(r"/p7",P7WebSocket)
], static_path=os.path.join(os.path.dirname(__file__), "client"))
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(options.port)
# Start the time signal
time_signal()
# Start the fake source providers
fake_sources()
ioloop = tornado.ioloop.IOLoop.instance()
# Set up collector
collector = collectd.Reader(host="0.0.0.0")
collector._sock.setblocking(0)
ioloop.add_handler(collector._sock.fileno(), on_collect, ioloop.READ)
ioloop.start()
def add_task(self, taskname, *args, **kwargs):
"""Run a Celery task. All args and kwargs except `callback` are
passed to task.
:param taskname: celery task
:keyword callback: callable with a single argument (task result)
This method creates a random UnixSocket under /tmp/ for
communication, registers a handler on `tornado.ioloop.IOLoop`
with its fd, calls `taskname.apply_async(args, kwargs)` and
links to notifier subtask to be run upon successful completion.
:attr:`celery_result` contains return value of apply_async
"""
user_cb = kwargs.pop('callback')
assert callable(user_cb)
ioloop = tornado.ioloop.IOLoop().instance()
fname = '/tmp/task_socket_%s' % uuid4()
# create & bind socket
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(fname)
sock.listen(1)
# pass down input callback
callback = functools.partial(self._on_complete, user_cb)
ioloop.add_handler(sock.fileno(), callback, ioloop.READ)
# subtask
link = celery_notifier.subtask(args=(fname,), immutable=True)
self.celery_result = taskname.apply_async(args, kwargs, link=link)
self.celery_socket = sock
def install_package(filename, callback):
filename = os.path.join(DOWNLOAD_TMP_DIR, filename)
if not os.path.exists(filename):
callback({
'ok' : False,
'error' : "Failed to find archive",
'removed': [],
})
return
proc = subprocess.Popen(['tar','zxf', filename],
cwd=DOWNLOAD_TMP_DIR,
stdout=subprocess.PIPE)
def install_all_bundles():
removed = []
installed = []
for bundle in os.listdir(DOWNLOAD_TMP_DIR):
tmppath = os.path.join(DOWNLOAD_TMP_DIR, bundle)
bundlepath = os.path.join(LV2_PLUGIN_DIR, bundle)
if os.path.exists(bundlepath):
removed += remove_bundle_to_lilv_world(bundlepath, True)
shutil.rmtree(bundlepath)
shutil.move(tmppath, bundlepath)
installed += add_bundle_to_lilv_world(bundlepath, True)
# TODO - make ingen refresh lv2 world
if len(installed) == 0:
resp = {
'ok' : False,
'error' : "No plugins found in bundle",
'removed': removed,
}
else:
resp = {
'ok' : True,
'removed' : removed,
'installed': installed,
}
return resp
def end_untar_pkgs(fileno, event):
if proc.poll() is None:
return
ioloop.remove_handler(fileno)
os.remove(filename)
callback(install_all_bundles())
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(proc.stdout.fileno(), end_untar_pkgs, 16)
def _start_handler(self, q):
self.process_count += 1
if hasattr(q, '_reader'):
# use the reader fd to hook into ioloop
self.fd = q._reader.fileno()
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(self.fd, lambda fd, events: self._process_q(), tornado.ioloop.IOLoop.READ | tornado.ioloop.IOLoop.ERROR)
else:
self.timer = tornado.ioloop.PeriodicCallback(lambda: self._process_q(), 1000)
self.timer.start()
def communicate(self):
self.log.info("Adding handler")
fcntl.fcntl(self.fd, fcntl.F_SETFL, os.O_NONBLOCK)
def utf8_error(e):
self.log.error(e)
self.reader = io.open(self.fd, "rb", buffering=0, closefd=False)
self.writer = io.open(self.fd, "wt", encoding="utf-8", closefd=False)
ioloop.add_handler(self.fd, self.shell_handler, ioloop.READ | ioloop.ERROR)
def handle_server(fd, event):
s = fd_map[fd]
if event & IOLoop.READ:
get_connection, cli_addr = s.accept()
print "connection %s" % cli_addr[0]
get_connection.setblocking(0)
get_connection_fd = get_connection.fileno()
fd_map[get_connection_fd] = get_connection
handle = functools.partial(handle_client, cli_addr[0])
ioloop.add_handler(get_connection_fd, handle, IOLoop.READ)
message_queue_map[get_connection] = Queue.Queue()
def communicate(self):
self.log.info('Adding handler')
fcntl.fcntl(self.fd, fcntl.F_SETFL, os.O_NONBLOCK)
def utf8_error(e):
self.log.error(e)
self.reader = io.open(self.fd, 'rb', buffering=0, closefd=False)
self.writer = io.open(self.fd, 'wt', encoding='utf-8', closefd=False)
ioloop.add_handler(self.fd, self.shell_handler,
ioloop.READ | ioloop.ERROR)
def query_via_udp(name, callback, type=TYPE.A, server='127.0.0.1', port=53, *, sock=None, ioloop=None):
q = mkquery((name, type)).pack()
if sock is None:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(q, (server, port))
if ioloop is None:
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(sock.fileno(),
partial(_recv_dns_msg, callback, ioloop, sock),
ioloop.READ)
def accept(sock):
@return_future
def wrap_add_handler(callback):
def wait_for_accept(fd,events): # TODO more intelligently check for events?
try:
result = sock.accept()
callback(result)
except socket.error, e:
if e.args[0] not in (errno.EWOULDBLOCK, errno.EAGAIN):
raise
ioloop.add_handler(sock.fileno(), wait_for_accept, ioloop.READ)
def communicate(self):
self.log.info('PTY forked : %s (%s)' %
(os.ttyname(self.fd), os.ctermid()))
fcntl.fcntl(self.fd, fcntl.F_SETFL, os.O_NONBLOCK)
def utf8_error(e):
self.log.error(e)
self.reader = io.open(self.fd, 'rb', buffering=0, closefd=False)
self.writer = io.open(self.fd, 'wt', encoding='utf-8', closefd=False)
ioloop.add_handler(self.fd, self.shell_handler,
ioloop.READ | ioloop.ERROR)
def main():
commander = getInstance(Commander)
""" tell the commander to clean up the node """
nodeinst = getInstance(node.Node)
commander.add(nodeinst.stop)
""" add the stdin handler, and tell the commander to clean up the ioloop """
ioloop = tornado.ioloop.IOLoop.instance()
getInstance.singletons[tornado.ioloop.IOLoop] = ioloop
ioloop.add_handler(sys.stdin.fileno(), stdinHandler, ioloop.READ)
commander.add(ioloop.stop)
""" now serve the web-page, start listening """
web()
listen()
""" start it up! """
ioloop.start()
def subprocess(self, cmd, callback):
ioloop = tornado.ioloop.IOLoop.instance()
args = shlex.split(cmd)
LOG.debug(args)
pipe = subprocess.Popen(args, stdout = subprocess.PIPE, close_fds = True)
fd = pipe.stdout.fileno()
result = []
def recv(*args):
data = pipe.stdout.readline()
if data:
result.append(data)
elif pipe.poll() is not None:
ioloop.remove_handler(fd)
callback(''.join(result))
ioloop.add_handler(fd, recv, ioloop.READ)
def subprocess(self, cmd, callback):
ioloop = tornado.ioloop.IOLoop.instance()
args = shlex.split(cmd)
LOG.debug(args)
pipe = subprocess.Popen(args, stdout=subprocess.PIPE, close_fds=True)
fd = pipe.stdout.fileno()
result = []
def recv(*args):
data = pipe.stdout.readline()
if data:
result.append(data)
elif pipe.poll() is not None:
ioloop.remove_handler(fd)
callback(''.join(result))
ioloop.add_handler(fd, recv, ioloop.READ)
def communicate(self):
fcntl.fcntl(self.fd, fcntl.F_SETFL, os.O_NONBLOCK)
self.reader = io.open(
self.fd,
'rb',
buffering=0,
closefd=False
)
self.writer = io.open(
self.fd,
'wt',
encoding='utf-8',
closefd=False
)
ioloop.add_handler(
self.fd, self.shellHandle, ioloop.READ | ioloop.ERROR)
def subprocess(self, cmd, callback):
ioloop = tornado.ioloop.IOLoop.instance()
PIPE = subprocess.PIPE
cmd = " ".join(cmd)
pipe = subprocess.Popen(cmd, shell=True, stdin=PIPE,
stdout=PIPE, stderr=subprocess.STDOUT, close_fds=True)
fd = pipe.stdout.fileno()
def read(*args):
data = pipe.stdout.readline()
if data:
callback(data)
elif pipe.poll() is not None:
ioloop.remove_handler(fd)
callback(None)
# read handler
ioloop.add_handler(fd, self.async_callback(read), ioloop.READ)
def start_task_as_admin(self, *args, **kwargs):
task_cb = kwargs.pop('callback')
assert callable(task_cb)
taskname = self.taskname
ioloop = tornado.ioloop.IOLoop.instance()
socket_file = '/tmp/forge.d/forge_user_task_notify_%s' % uuid.uuid4()
sox = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sox.bind(socket_file)
sox.listen(1)
cb = functools.partial(self.__on_complete, task_cb, socket_file)
ioloop.add_handler(sox.fileno(), cb, ioloop.READ)
self.tornado_conn, proc_conn = multiprocessing.Pipe()
self.__run_process_as_admin(socket_file, proc_conn, taskname=taskname, args=args, kwargs=kwargs)
self.process_sox = sox
def query_via_udp(name,
callback,
type=TYPE.A,
server='127.0.0.1',
port=53,
*,
sock=None,
ioloop=None):
q = mkquery((name, type)).pack()
if sock is None:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(q, (server, port))
if ioloop is None:
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(sock.fileno(),
partial(_recv_dns_msg, callback, ioloop, sock),
ioloop.READ)
def main(): commander = getInstance(Commander) """ tell the commander to clean up the node """ nodeinst = getInstance(node.Node) commander.add(nodeinst.stop) """ add the stdin handler, and tell the commander to clean up the ioloop """ ioloop = tornado.ioloop.IOLoop.instance() getInstance.singletons[tornado.ioloop.IOLoop] = ioloop ioloop.add_handler(sys.stdin.fileno(), stdinHandler, ioloop.READ) commander.add(ioloop.stop) """ now serve the web-page, start listening """ web() listen() """ start it up! """ ioloop.start()
def __init__(self, family, address, onaccept_func):
"""Initialize a ListenSocket.
Args:
family: eg. socket.AF_INET, socket.AF_INET6, socket.AF_UNIX
address: eg. ('0.0.0.0', 1234) or '/tmp/unix/socket/path'
onaccept_func: called with newly-accepted socket, with parameters
(address, sock).
"""
self.onaccept_func = onaccept_func
self.family = family
self.address = address
self.sock = None
self.sock = _ListenSocket(family, address)
if family != socket.AF_UNIX:
self.address = self.sock.getsockname()[:2]
print 'Listening on %r' % (self.address,)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(self.sock.fileno(), self._Accept, ioloop.READ)
def main():
parse_command_line()
if options.split:
split_file = tempfile.mktemp(suffix="-mpu6050.log")
print("Writing data to '%s'" % split_file)
outf = open(split_file, 'wb')
then = time.time()
def split_write(message):
outf.write(b"#" * 10)
outf.write(b"\n")
outf.write(message)
else:
def split_write(_message):
pass
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
}
app = tornado.web.Application(
[
(r'/', IndexHandler),
(r'/ws', WebSocketHandler),
],
**settings
)
socket = nanomsg.Socket(nanomsg.PAIR)
print("Connecting to nanomsg on '%s'" % options.uri)
socket.connect(options.uri)
print("Server listening on 'http://localhost:%i/'" % options.port)
app.listen(options.port)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(
socket.fd,
partial(imu_message_arrived, socket, split_write),
tornado.ioloop.IOLoop.READ | tornado.ioloop.IOLoop.WRITE | tornado.ioloop.IOLoop.ERROR
)
ioloop.start()
def __init__(self, family, address, onaccept_func):
"""Initialize a ListenSocket.
Args:
family: eg. socket.AF_INET, socket.AF_INET6, socket.AF_UNIX
address: eg. ('0.0.0.0', 1234) or '/tmp/unix/socket/path'
onaccept_func: called with newly-accepted socket, with parameters
(address, sock).
"""
self.onaccept_func = onaccept_func
self.family = family
self.address = address
self.sock = None
self.sock = _ListenSocket(family, address)
if family != socket.AF_UNIX:
self.address = self.sock.getsockname()[:2]
print 'Listening on %r' % (self.address,)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(self.sock.fileno(), self._Accept, ioloop.READ)
def communicate(self):
self.log.debug('Adding handler')
fcntl.fcntl(self.fd, fcntl.F_SETFL, os.O_NONBLOCK)
def utf8_error(e):
self.log.error(e)
self.reader = io.open(
self.fd,
'rb',
buffering=0,
closefd=False
)
self.writer = io.open(
self.fd,
'wt',
encoding='utf-8',
closefd=False
)
ioloop.add_handler(
self.fd, self.shell_handler, ioloop.READ | ioloop.ERROR)
def main():
# add web handler
application = tornado.web.Application([
(r"/", MainHandler),
(r"/ws", EchoWebSocket),
])
application.listen(8888)
pcap = Pcap()
dev = pcap.create(pcap.device)
print 'using', pcap.device
#can_mon = pcap.can_set_rfmon(dev)
#print 'can mon:', can_mon
#if can_mon == 0:
# print pcap.get_error(dev)
#else:
# mon = pcap.set_rfmon(dev, 1)
# print 'rf mon:', mon
#to = pcap.set_timeout(dev, 0)
#print 'timeout', to
#buff = pcap.set_buff_size(dev, 65535)
#print 'buff size:', buff
#snap = pcap.set_snaplen(dev, 65535)
#print 'snap:', snap
#prom = pcap.set_promisc(dev, 1)
#print 'prom:', prom
act = pcap.activate(dev)
print 'activated:', act
nb = pcap.set_nonblock(dev, 1)
print "non block", nb
fd = pcap.get_fd(dev)
print 'fd:', fd
gnb = pcap.get_nonblock(dev)
print 'get nonblock', gnb
cbh = CallbackHandler()
ioloop = tornado.ioloop.IOLoop.instance()
if fd > 0 and gnb > 0:
read_partial = partial(read_fd, **{'dev':dev, 'pcap':pcap, 'cbh':cbh})
ioloop.add_handler(fd, read_partial, ioloop.READ)
#ioloop.add_timeout(ioloop.time()+5, shutdown, *(pcap, dev))
ioloop.start()
def start_ioloop(self):
"""
Method to start ioloop for paho-mqtt mosquitto clients so that it can
process read/write events for the sockets.
Using tornado's ioloop, since if we use any of the loop*() function provided by
phao-mqtt library, it will either block the entire tornado thread, or it will
keep on creating separate thread for each client if we use loop_start() fucntion.
We don't want to block thread or to create so many threads unnecessarily given
python GIL.
Since the separate threads calls the loop() function indefinitely, and since its doing
network io, its possible it may release GIL, but I haven't checked that yet, if that
is the case, we can very well use loop_start().Pattern
But for now we will add handlers to tornado's ioloop().
"""
# pi('start_ioloop')
# the socket conection of the present mqtt mosquitto client object
self._sock = self._client.socket()
# adding tornado iooloop handler
events = READ | WRITE | ERROR
# print '[MosquittoClient] adding tornado handler now'
if self._sock:
# print 'self._sock is present, hence adding handler'
ioloop.add_handler(self._sock.fileno(), self._events_handler,
events)
else:
LOGGER.warning('[MosquittoClient] client socket is closed already')
def communicate(self):
self.log.info('PTY forked : %s (%s)' % (
os.ttyname(self.fd), os.ctermid()))
fcntl.fcntl(self.fd, fcntl.F_SETFL, os.O_NONBLOCK)
def utf8_error(e):
self.log.error(e)
self.reader = io.open(
self.fd,
'rb',
buffering=0,
closefd=False
)
self.writer = io.open(
self.fd,
'wt',
encoding='utf-8',
closefd=False
)
ioloop.add_handler(
self.fd, self.shell_handler, ioloop.READ | ioloop.ERROR)
def start_ioloop(self):
"""
Method to start ioloop for paho-mqtt mosquitto clients so that it can
process read/write events for the sockets.
Using tornado's ioloop, since if we use any of the loop*() function provided by
phao-mqtt library, it will either block the entire tornado thread, or it will
keep on creating separate thread for each client if we use loop_start() fucntion.
We don't want to block thread or to create so many threads unnecessarily given
python GIL.
Since the separate threads calls the loop() function indefinitely, and since its doing
network io, its possible it may release GIL, but I haven't checked that yet, if that
is the case, we can very well use loop_start().Pattern
But for now we will add handlers to tornado's ioloop().
"""
# pi('start_ioloop')
# the socket conection of the present mqtt mosquitto client object
self._sock = self._client.socket()
# adding tornado iooloop handler
events = READ | WRITE | ERROR
# print '[MosquittoClient] adding tornado handler now'
if self._sock:
# print 'self._sock is present, hence adding handler'
ioloop.add_handler(self._sock.fileno(), self._events_handler, events)
else:
LOGGER.warning('[MosquittoClient] client socket is closed already')
logging.info(" [*] Listening on 0.0.0.0:" + str(options.options.port))
print "*SYSOUT* User API Websocket is created at localhost:" + str(options.options.port) + "/api"
# Create a userControl object
userControl = UserControl()
# Install signal handlers
signalCallback = functools.partial(signalHandler, userControl)
signal.signal(signal.SIGTERM, signalCallback)
signal.signal(signal.SIGINT, signalCallback)
# Start listener thread
t = threading.Thread(target=listenerThread)
t.daemon = True
# Start it
t.start()
# Create ioloop
ioloop = ioloop.IOLoop.instance()
# Add user control via stdin pipe
ioloop.add_handler(sys.stdin.fileno(), userControl.userPlayer, ioloop.READ)
# Before starting ioloop, stop led blinking,
# which will light up correct LED and give information to the user
# that all is ready
if platform.machine() == "mips":
subprocess.call(["/etc/init.d/led_blink", "stop"])
ioloop.start()
def input_add(fd, cond): ioloop.add_handler(fd, pypurple.io_invoke, cond)
def inotify_handler(event):
if (event.mask & pyinotify.IN_CLOSE_WRITE) and not (event.mask & pyinotify.IN_ISDIR):
file_name = os.path.join(event.path, event.name)
if os.path.isfile(file_name):
if file_name[0] == ".":
file_name = file_name[1:]
for socket in active_sockets:
socket.send_update(file_name)
if __name__ == "__main__":
application = tornado.web.Application([
(r"/(livereload.js)", tornado.web.StaticFileHandler, {'path': "js"}),
(r"/livereload", LiveReloadSocket),
])
application.listen(35729)
ioloop = tornado.ioloop.IOLoop.instance()
wm = pyinotify.WatchManager()
inotifier = pyinotify.Notifier(wm, inotify_handler)
wm.add_watch(".", pyinotify.ALL_EVENTS, rec=True)
def inotify_fd_handler(*args):
inotifier.process_events()
if inotifier.check_events():
inotifier.read_events()
inotifier.process_events()
ioloop.add_handler(wm.get_fd(), inotify_fd_handler, ioloop.READ)
ioloop.start()
#print "start user script"
#userControl.start()
# Install signal handlers
signalCallback = functools.partial(signalHandler, userControl)
signal.signal(signal.SIGTERM, signalCallback)
signal.signal(signal.SIGINT, signalCallback)
# Prepare lock for the thread
weioRunnerGlobals.lockConn = multiprocessing.Lock()
# Start listener thread
t = threading.Thread(target=listenerThread)
t.daemon = True
# Start it
t.start()
# Create ioloop
ioloop = ioloop.IOLoop.instance()
# Add user control via stdin pipe
ioloop.add_handler(sys.stdin.fileno(), userControl.userPlayer, ioloop.READ)
# Before starting ioloop, stop led blinking,
# which will light up correct LED and give information to the user
# that all is ready
if (platform.machine() == 'mips'):
subprocess.call(["/etc/init.d/led_blink", "stop"])
ioloop.start()
def start(self, ioloop):
ioloop.add_handler(self._channel._reader.fileno(), self._on_channel,
ioloop.READ)
def on_close(self):
print 'websocket closed'
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# int main(int argc, char** argv)
#
if __name__=='__main__':
# need to use these global variables
global tunfd
global running
global application
try:
# the event loop
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_handler(sys.stdin.fileno(), stdinHandler, ioloop.READ)
# initialize application and listen
application = tornado.web.Application([
(r'/websocket', BasicWebSocket),
])
application.ws = None
subprocess.check_call('sudo /sbin/ifconfig en1 inet 169.254.134.89 netmask 255.255.0.0 alias', shell=True)
application.listen(port)
print 'running...'
except Exception, err:
raise Exception('Error: %s\n' % str(err))
try:
ioloop.start()
except Exception, err:
raise Exception('Error: %s\n' % str(err))
def make_xen_pipe():
"""
用户发送从xenserver接收到的报警到主线程
"""
xen_read_fd, xen_write_fd = os.pipe()
flags = fcntl.fcntl(xen_read_fd, fcntl.F_GETFL)
fcntl.fcntl(xen_read_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
flags = fcntl.fcntl(xen_write_fd, fcntl.F_GETFL)
fcntl.fcntl(xen_write_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
return xen_read_fd, xen_write_fd
if __name__ == '__main__':
# make simple test
def nagios_read_handler(fd, events):
print os.read(fd, 1024)
nagios_read, nagios_write = make_nagios_pipe()
xen_read, xen_write = make_xen_pipe()
ioloop = ioloop.IOLoop().instance()
ioloop.add_handler(nagios_read, nagios_read_handler, ioloop.READ)
ioloop.add_handler(xen_read, nagios_read_handler, ioloop.READ)
os.write(nagios_write, "hello nagios\n")
os.write(xen_write, "hello xenserver\n")
ioloop.start()
(r'/', IndexHandler),
(r'/ws', WebSocketHandler),
(r'/ajax', AjaxHandler),
(r"/login", LoginHandler),
(r"/download", DownloadHandler),
(r"/logout", LogoutHandler),
]
settings = dict(
static_path = os.path.join(os.getcwd(), 'static'),
template_path = os.path.join(os.getcwd(), 'templates'),
debug = True,
cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
)
app = tornado.web.Application(handlers, **settings)
ioloop.add_handler(cnx.fileno(), watch_db, ioloop.READ)
def main():
try:
app.listen(8000)
listen('agent_state_changes')
print('server is running in port 8000')
ioloop.start()
except KeyboardInterrupt as e:
print('stopping server')
ioloop.stop()
if __name__ == '__main__':
main()
#>>> get_ip_address('lo')
#'127.0.0.1'
#>>> get_ip_address('eth0')
#'38.113.228.130'
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# int main(int argc, char** argv)
#
if __name__ == '__main__':
try:
application = tornado.web.Application([
(r'/websocket', BasicWebSocket),
])
application.listen(port)
except Exception, err:
print('Error: could not initialize application and listen' + str(err))
try:
ioloop.add_handler(sys.stdin.fileno(), stdinHandler, ioloop.READ)
print 'running ...'
# our ip address that we need to assign to outgoing packet that we forward:
our_ip = get_ip_address('eth0')
print('our ip address of eth0 to assign to packets: ' + our_ip)
ioloop.start()
finally:
if tunfd:
os.close(tunfd)
