def run():
sys.stderr.write(time.ctime() + " : Dronedata started\n")
if not os.path.exists(drconfig.VEHICLE_PORT):
sys.stderr.write(time.ctime() + " : No vehicle\n")
#exit()
if not os.path.exists(drconfig.OPCREADER_PORT):
sys.stderr.write(time.ctime() + " : No opc\n")
#exit()
if not os.path.exists(drconfig.NO2READER_PORT):
sys.stderr.write(time.ctime() + " : No no2\n")
#exit()
try:
os.unlink(drconfig.DRONEDATA_FILE)
except:
pass
#subprocess.Popen(['/usr/bin/python', 'vehstatus/vehicledata.py', '--connect', drconfig.VEHICLE_PORT])
#subprocess.Popen(['opcreader/opcread', drconfig.OPCREADER_PORT])
time.sleep(3)
rt = threading.Thread(target=connectNo2)
rt.daemon = True
rt.start()
rt = threading.Thread(target=connectOpc)
rt.daemon = True
rt.start()
rt = threading.Thread(target=connectVeh)
rt.daemon = True
rt.start()
rt = threading.Thread(target=readthread)
rt.daemon = True
rt.start()
sv = SocketServer.ThreadingUnixStreamServer(drconfig.DRONEDATA_FILE,
servthread)
sv.serve_forever()
drconfig.SockVeh.send("X")
drconfig.SockVeh.close()
drconfig.SockOpc.send("X")
drconfig.SockOpc.close()
drconfig.SockNo2.send("X")
drconfig.SockNo2.close()
def unix(options):
"""Run UNIX SOCKET server."""
try:
if os.path.exists(options.socket):
os.remove(options.socket)
except EnvironmentError as ex:
logger.error("Failed to delete old socket '%s': %s", options.socket,
ex)
sys.exit(1)
sockets = {}
if options.socket:
try:
unixd = SocketServer.ThreadingUnixStreamServer(
options.socket, StreamHandler)
unixd.daemon_threads = True
sockets[unixd.fileno()] = unixd
except Exception as ex:
logger.error("Could not create SSL server: %s", ex)
if not sockets:
logger.error("No UNIX socket server.")
return
logger.info('Server is ready.')
if hasattr(options, 'callback_ready'):
options.callback_ready()
keep_running = True
while keep_running:
try:
rlist, wlist, xlist = select.select(sockets.keys(), [], [], None)
for fd in rlist:
sockets[fd].handle_request()
except select.error as ex:
if ex.args[0] == errno.EINTR:
continue
else:
raise
except socket.error as ex:
if ex.errno == errno.EINTR:
continue
else:
raise
except KeyboardInterrupt:
keep_running = False
logger.info('Server is terminating.')
try:
os.remove(options.socket)
except EnvironmentError as ex:
logger.warning("Failed to delete old socket '%s': %s", options.socket,
ex)
def handle(self, **options):
socket_file = options.get("socket_file")
network_socket = options.get("network_socket")
threading = options.get("threading")
forking = options.get("forking")
if threading and forking:
raise CommandError("Pick one: threading or forking.")
if socket_file and network_socket:
raise CommandError("Only one socket allowed at a time")
if threading:
server_type = "threading"
elif forking:
server_type = "forking"
else:
server_type = "single-threaded"
self.stdout.write("Server type: %s\n" % (server_type, ))
if socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write("Binding to unix socket: %s\n" % (socket_file, ))
if threading:
server = SocketServer.ThreadingUnixStreamServer(
socket_file, EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = ForkingUnixStreamServer(socket_file,
EventNormalizeHandler)
else:
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(":")
port = int(port)
self.stdout.write("Binding to network socket: %s:%s\n" %
(host, port))
if threading:
server = SocketServer.ThreadingTCPServer((host, port),
EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = SocketServer.ForkingTCPServer((host, port),
EventNormalizeHandler)
else:
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError("No connection option specified")
server.serve_forever()
def handle(self, **options):
socket_file = options.get('socket_file')
network_socket = options.get('network_socket')
threading = options.get('threading')
forking = options.get('forking')
if threading and forking:
raise CommandError('Pick one: threading or forking.')
if socket_file and network_socket:
raise CommandError('Only one socket allowed at a time')
if threading:
server_type = 'threading'
elif forking:
server_type = 'forking'
else:
server_type = 'single-threaded'
self.stdout.write('Server type: %s\n' % (server_type, ))
if socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write('Binding to unix socket: %s\n' % (socket_file, ))
if threading:
server = SocketServer.ThreadingUnixStreamServer(
socket_file, EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = ForkingUnixStreamServer(socket_file,
EventNormalizeHandler)
else:
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(':')
port = int(port)
self.stdout.write('Binding to network socket: %s:%s\n' %
(host, port))
if threading:
server = SocketServer.ThreadingTCPServer((host, port),
EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = SocketServer.ForkingTCPServer((host, port),
EventNormalizeHandler)
else:
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError('No connection option specified')
server.serve_forever()
def run():
try:
os.unlink(vconfig.VEHICLE_FILE)
except:
pass
parser = argparse.ArgumentParser(
description=
'Print out vehicle state information. Connects to SITL on local PC by default.'
)
parser.add_argument(
'--connect',
help=
"vehicle connection target string. If not specified, SITL automatically started and used."
)
parser.add_argument('--baudrate',
help="vehicle serial data baudrate. Default is 57600.")
args = parser.parse_args()
connection = args.connect
baudrate = args.baudrate
if not connection:
connection = vconfig.DEVICE
if not baudrate:
baudrate = vconfig.BAUDRATE
else:
baudrate = int(baudrate)
sys.stderr.write(time.ctime() +
" : Connecting to vehicle on: %s\n" % connection)
vconfig.vehicle = connect(connection, wait_ready=False, baud=baudrate)
#print time.time()
vconfig.vehicle.wait_ready(True, timeout=300)
#print time.time()
@vconfig.vehicle.on_message('SYSTEM_TIME')
def listener(self, name, message):
vconfig.gpst = message.time_unix_usec / 1000000.0
rt = threading.Thread(target=readthread)
rt.daemon = True
rt.start()
sv = SocketServer.ThreadingUnixStreamServer(vconfig.VEHICLE_FILE,
servthread)
sv.serve_forever()
def get_server(config, config_section, handler):
SocketServer.TCPServer.allow_reuse_address = True
if config.has_option(config_section, 'socket'):
socket_file = config.get(config_section, 'socket')
if os.path.exists(socket_file):
os.unlink(socket_file)
server = SocketServer.ThreadingUnixStreamServer(
socket_file,
handler
)
else:
server = SocketServer.ThreadingTCPServer(
(
config.get(config_section, 'host'),
config.getint(config_section, 'port')
), handler
)
return server
def run(self):
self.unixserver = SocketServer.ThreadingUnixStreamServer(self.filename, handler)
self.unixserver.serve_forever()
def local_forward(remote_addr, local_addr=('127.0.0.1', 0)):
class Handler(SocketServer.BaseRequestHandler):
@keep_context
def handle(self):
log.debug('New connection to {} from {}'.format(
remote_addr, self.request.getpeername()))
if isinstance(remote_addr, tuple):
# remote is a tcp address
chan = my_remote.tcp_connect(remote_addr)
else:
# remote is a unix socket
chan = my_remote.unix_connect(remote_addr)
while True:
r, _, _ = select.select([self.request, chan], [], [])
if self.request in r:
buf = self.request.recv(4096)
if len(buf) == 0:
# client closed connection, we're done
break
chan.send(buf)
if chan in r:
buf = chan.recv(4096)
if len(buf) == 0:
# server closed connection
break
self.request.send(buf)
log.debug('Closed connection to {} from {}'.format(
remote_addr, self.request.getpeername()))
with contextlib2.ExitStack() as stack:
if isinstance(local_addr, tuple):
server = SocketServer.ThreadingTCPServer(local_addr, Handler)
else:
# assume its a string, denoting a unix domain socket
if not local_addr:
dtmp = stack.enter_context(volatile.dir())
local_addr = os.path.join(dtmp, 'remote.sock')
server = SocketServer.ThreadingUnixStreamServer(
local_addr, Handler)
server.allow_reuse_address = False
server.daemon_threads = True
my_remote = remote._get_current_object()
t = threading.Thread(target=keep_context(server.serve_forever))
t.daemon = True
t.start()
# wait for the server to shutdown
stack.callback(t.join)
stack.callback(server.shutdown)
stack.callback(
log.debug,
'Waiting for shutdown of {}'.format(server.server_address))
log.debug('Forward established: {} => {}'.format(
server.server_address, remote_addr))
yield server.server_address
def unix(options):
"""Run UNIX SOCKET server."""
try:
if os.path.exists(options.socket):
os.remove(options.socket)
except OSError as (err, errmsg):
logger.error("Failed to delete old socket '%s': %s" %
(options.socket, errmsg))
sys.exit(1)
sockets = {}
if options.socket:
try:
unixd = SocketServer.ThreadingUnixStreamServer(
options.socket, StreamHandler)
unixd.daemon_threads = True
sockets[unixd.fileno()] = unixd
except Exception as e:
logger.error("Could not create SSL server: %s" % (e, ))
if not sockets:
logger.error("No UNIX socket server.")
return
logger.info('Server is ready.')
if hasattr(options, 'callback_ready'):
options.callback_ready()
keep_running = True
while keep_running:
try:
#!/usr/bin/python
#coding:utf-8
import SocketServer
import os
import threading
import time
thread_lock_100 = threading.Semaphore(300)
class MyHandler(SocketServer.BaseRequestHandler):
def handle(self):
print self.request.recv(1024)
#self.request.send("welcome!!!")
thread_lock_100.acquire()
with open('./myre.txt', 'a') as fd:
fd.write('a\n')
time.sleep(1)
thread_lock_100.release()
addr_path = './unix.sock'
if os.path.exists(addr_path):
os.remove(addr_path)
#server = SocketServer.UnixStreamServer(addr_path, MyHandler)
server = SocketServer.ThreadingUnixStreamServer(addr_path, MyHandler)
server.serve_forever()
