def worker(address, port, password):
listener = Listener(address, authkey=password)
conn = listener.accept()
print 'connection accepted from', listener.last_accepted
conn.send_bytes('hello')
conn.close()
listener.close()
def run(self):
print ('MSocket receiver thread starts...')
while not self.terminate:
try:
address = ('localhost', self.port) # family is deduced to be 'AF_INET'
listener = Listener(address, authkey = b'your_password')
print ("Listening on port {}..".format(self.port))
conn = listener.accept() # blocking
print ('Connection accepted from {}'.format (listener.last_accepted))
except Exception as e:
print("MSocket error. Quitting :")
print (e)
return
while not self.terminate:
try:
self.message = conn.recv() # blocking
self.data_ready = True
print (self.message)
if self.message == 'exit': # quit inner loop
break
except Exception as e:
print(e)
break
print ('closing client connection..')
conn.close()
listener.close()
if self.message == 'exit': # quit outer loop
break
print ('shutting down Msock server..')
conn.close()
listener.close()
print ('MSocket receiver thread exits.')
def controller(system):
address = ('localhost', 6000)
listener = Listener(address, authkey=b'secret')
conn = listener.accept()
print('connection accepted from ', listener.last_accepted)
while True:
msg = conn.recv()
# do something with msg
if msg == 'measure':
conn.send(system.get_measurement())
elif msg == 'command':
u = conn.recv()
try:
u = float(u)
system.set_u(u)
except:
raise ValueError(f"Command {u} not allowed")
elif msg == 'disturbance':
disturbance = conn.recv()
print(f'disturbance: {disturbance}')
try:
disturbance = float(disturbance)
system.disturbance = disturbance
except:
raise ValueError(f"Disturbance {disturbance} not allowed")
elif msg == 'reset':
system.state = system.init_state()
system.u = 0.0
if msg == 'close':
conn.close()
break
listener.close()
def create_ipc_server(self):
listener = Listener((self.ipc_address, self.ipc_port), authkey=self.ipc_authkey)
self.is_ipc_alive = True
while True:
conn = listener.accept()
start_time = time.time()
print(f"New Connection: {listener.last_accepted}")
while True:
msg = conn.recv()
if debug:
print(msg)
if "FILE|" in msg:
file = msg.split("FILE|")[1].strip()
if file:
event_system.push_gui_event(["create_tab_from_ipc", None, file])
conn.close()
break
if msg == 'close connection':
conn.close()
break
if msg == 'close server':
conn.close()
break
# NOTE: Not perfect but insures we don't lockup the connection for too long.
end_time = time.time()
if (end - start) > self.ipc_timeout:
conn.close()
listener.close()
def interrupt_experiment(experiment_script, lifecycle_stage):
"""Interrupt the experiment and verify no children processes remain."""
args = ['python', experiment_script]
# The pre-executed function setpgrp allows to create a process group
# so signals are propagated to all the process in the group.
proc = subprocess.Popen(args, preexec_fn=os.setpgrp)
launcher_proc = psutil.Process(proc.pid)
# This socket connects with the client in the algorithm, so we're
# notified of the different stages in the experiment lifecycle.
address = ('localhost', 6000)
listener = Listener(address)
conn = listener.accept()
while True:
msg = conn.recv()
if msg == lifecycle_stage:
# Notice that we're asking for the children of the launcher, not
# the children of this test script, since there could be other
# children processes attached to the process running this test
# that are not part of the launcher.
children = launcher_proc.children(recursive=True)
# Remove the semaphore tracker from the list of children, since
# we cannot stop its execution.
for child in children:
if any([
'multiprocessing.semaphore_tracker' in cmd
for cmd in child.cmdline()
]):
children.remove(child)
# We append the launcher to the list of children so later we can
# check it has died.
children.append(launcher_proc)
pgrp = os.getpgid(proc.pid)
os.killpg(pgrp, signal.SIGINT)
conn.close()
break
listener.close()
# Once the signal has been sent, all children should die
_, alive = psutil.wait_procs(children, timeout=6)
# If any, notify the zombie and sleeping processes and fail the test
clean_exit = True
error_msg = ''
for child in alive:
error_msg += (
str(child.as_dict(attrs=['pid', 'name', 'status', 'cmdline'])) +
'\n')
clean_exit = False
error_msg = ("These processes didn't die during %s:\n" %
(lifecycle_stage) + error_msg)
for child in alive:
os.kill(child.pid, signal.SIGINT)
assert clean_exit, error_msg
def local_listener():
listener = Listener(local_address_d, authkey="localData")
while True:
conn = listener.accept()
print("[DATA] connection accepted from", listener.last_accepted)
msg = conn.recv()
# TODO: check end validation
assert isinstance(msg, list) and len(msg) == 4
video_id = msg[0]
begin = msg[1]
end = msg[2]
fps = msg[3] # Recently fps can only be 24
if not video_id == "local.h264":
fetch_remote_data(video_id)
cap = cv2.VideoCapture(os.path.join(local_dir, video_id))
frame_id = begin * fps
ret = cap.set(1, frame_id)
if begin == end:
ret, frame = cap.read()
conn.send([frame])
conn.close()
else:
frame_list = list()
for i in xrange((end - begin) * fps):
ret, frame = cap.read()
frame_list.append(frame)
conn.send(frame_list)
conn.close()
listener.close()
class Ipc():
def sendCmd(self, cmd, port):
self.cmdSemaphore.acquire()
address = ('localhost', port)
try:
conn = Client(address, authkey=b'secret password')
conn.send(json.dumps(cmd))
conn.close()
except ConnectionRefusedError as e:
#logging.debug(e)
pass
self.cmdSemaphore.release()
def serverInit(self, port):
address = ('localhost', port) # family is deduced to be 'AF_INET'
self.listener = Listener(address, authkey=b'secret password')
def serverClose(self):
self.listener.close()
def serverGetCmd(self):
conn = self.listener.accept()
msg = conn.recv()
data = json.loads(msg)
return data
def __init__(self):
self.cmdSemaphore = Semaphore()
def loop(self):
listener = Listener(self.address, backlog=5, authkey=self.authkey)
logging.warn('DB server started with %s, listening on %s:%d...',
sys.executable, *self.address)
self.thread.start()
cmd = None
try:
while cmd != 'stop':
try:
conn = listener.accept()
except KeyboardInterrupt:
break
except:
# unauthenticated connection, for instance by a port
# scanner such as the one in manage.py
continue
cmd_ = conn.recv() # a tuple (name, arg1, ... argN)
cmd, args = cmd_[0], cmd_[1:]
if cmd.startswith('@'): # slow command, run in process
cmd = cmd[1:] # strip @
proc = Process(
target=run_command, name=cmd, args=(cmd, args, conn))
proc.start()
logging.warn('Started %s%s in process %d',
cmd, args, proc.pid)
else:
queue.put((conn, cmd, args))
finally:
listener.close()
self.thread.join()
def _serve(self, port, path):
data = []
# print 'Server', os.getpid()
address = ('localhost', port)
listener = Listener(address)
loop = True
while loop:
conn = listener.accept()
command, payload = conn.recv()
response_payload = None
if command == 'OPEN':
#print command, payload
path = payload
elif command == 'WRITE':
#print command, payload
data.append(payload)
elif command == 'FETCH':
#print command, payload
response_payload = data
elif command == 'FLUSH':
#print command
json.dump(data, open(path, 'w'))
elif command == 'CLOSE':
#print command
#json.dump(data, open(path, 'w'))
loop = False
conn.send(('OK', response_payload))
conn.close()
listener.close()
class CountApiServer(threading.Thread):
def __init__(self, port, parent):
super(CountApiServer, self).__init__()
self.parent = parent
self.__listener = Listener(('127.0.0.1', port))
def run(self):
conn = self.__listener.accept()
while 1:
if conn.closed:
conn = self.__listener.accept()
try:
msg = conn.recv()
except EOFError:
conn.close()
continue
else:
if msg == 'quit':
conn.close()
break
conn.send(self.parent.key_count)
self.__listener.close()
self.parent.stop()
def run(self, engine, robo_id):
""" Feed the Engine (read/exec/write)"""
listener = Listener(self.address)
con = listener.accept()
self.game_tick = 0
while not con.closed:
try:
cmd = con.recv()
except:
break
self.game_tick += 1
engine.game_timer(self.game_tick)
reply = engine.execute(self.game_tick, robo_id, cmd)
if reply:
try:
b = reply[1][0][0][0]
status = reply[1][0][1]
con.send([b, status, {'active': True}])
except Exception as e:
break
else:
break
try:
con.close()
listener.close()
except Exception:
pass
def runserver():
s, cook = prepare_session()
acwing_socket = websocket.WebSocketApp('wss://www.acwing.com/wss/chat/',
header=socket_header,
cookie=cook,
on_message=on_message,
on_error=on_error,
on_close=on_close)
wst = threading.Thread(target=acwing_socket.run_forever,
kwargs={'ping_interval': 60})
wst.daemon = True
wst.start()
address = ('localhost', 6001) # family is deduced to be 'AF_INET'
listener = Listener(address, authkey=b'1234')
try:
while True:
conn = listener.accept()
send_debug_message(conn, 'welcome')
send_debug_message(conn, str(listener.last_accepted))
t = threading.Thread(target=handle,
args=(conn, acwing_socket, listener))
t.daemon = True
t.start()
except:
pass
listener.close()
def _listen(self):
""" Listen for information from a client and performs
actions related to the windows registry """
registry = Registry()
listener = Listener(('localhost', self.port), authkey=self.password)
conn = listener.accept()
msg = conn.recv()
if type(msg) is list and len(msg) == 2:
# Deleting debugger key
debug_path = self.DEBUG_KEY + msg[0]
k = registry.open_key(HKLM, debug_path)
registry.del_value(k, "debugger")
# Deleting the bad path
k = registry.open_key(HKCU, msg[1])
if k:
self.brush.color("[!!] POSSIBLE UAC BYPASS IN YOUR SYSTEM\n", 'RED')
registry.delete_key(HKCU, msg[1])
ctypes.windll.user32.MessageBoxA(
None, "UAC BYPASS DETECTADO Y MITIGADO. EJECUCION SEGURA DEL BINARIO", "PELIGRO!", 0)
os.system(msg[0])
# Setting the debugger key before breaking connection
k = registry.open_key(HKLM, debug_path)
payload = self.build_payload(msg[0][:-3] + "pyw")
registry.create_value(k,
"debugger",
payload)
print "[+] Closing the listener"
conn.close()
listener.close()
def _serve(self, port, path):
data = []
# print 'Server', os.getpid()
address = ('localhost', port)
listener = Listener(address)
loop = True
while loop:
conn = listener.accept()
command, payload = conn.recv()
response_payload = None
if command == 'OPEN':
#print command, payload
path = payload
elif command == 'WRITE':
#print command, payload
data.append(payload)
elif command == 'FETCH':
#print command, payload
response_payload = data
elif command == 'FLUSH':
#print command
json.dump(data, open(path, 'w'))
elif command == 'CLOSE':
#print command
#json.dump(data, open(path, 'w'))
loop = False
conn.send(('OK', response_payload))
conn.close()
listener.close()
def main():
# type: () -> None
listener = Listener(WORKER_SOCKET_NAME, 'AF_UNIX')
try:
Door.initialize()
name_to_add = None
print('Worker started')
while True:
conn = listener.accept()
print('connection accepted from', listener.last_accepted)
msg = conn.recv()
print('Message: ', msg)
command = msg['type']
value = msg['value']
if command == 'read':
process_read_command(value, name_to_add)
name_to_add = None
elif command == 'add':
name_to_add = process_add_command(value)
else:
Repository.log_message(
'error',
'Unknown command: {}'.format(command))
finally:
Door.cleanup()
listener.close()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--port', default=6000)
parser.add_argument('--authkey', default='adversql')
parser.add_argument('--schemas_path',
default='../../data/spider/tables.json')
parser.add_argument('--models_path',
default='generated_data_augment/saved_models')
parser.add_argument('--glove_path', default='glove')
parser.add_argument('--toy', action='store_true')
args = parser.parse_args()
schemas = load_schemas(args.schemas_path)
model = load_model(args.models_path, args.glove_path, args.toy)
while True:
address = ('localhost', args.port) # family is deduced to be 'AF_INET'
listener = Listener(address, authkey=args.authkey)
print('Listening on port {}...'.format(args.port))
conn = listener.accept()
print('Connection accepted from:', listener.last_accepted)
while True:
msg = conn.recv_bytes()
if msg == 'close':
conn.close()
break
db_name, nlq = msg.split('\t')
sql, conf = translate(model, schemas, db_name, nlq)
conn.send_bytes('{}\t{}'.format(sql, conf))
listener.close()
def issue_credential(data):
address = ('localhost', Constant.PORT_NUMBER)
listener = Listener(address)
listener._listener._socket.settimeout(Constant.TIMEOUT)
proposal_response = send_offer(data)
credential_exchange_id = proposal_response["credential_exchange_id"]
logger.info(f'credential_exchange_id: {credential_exchange_id}')
while True:
try:
conn = listener.accept()
msg = conn.recv()
state = msg["state"]
logger.info(f'waiting state change, current state is: {state}')
conn.close()
if state == 'credential_acked':
print("Congratulation, execute publish successfully!")
listener.close()
break
else:
time.sleep(0.5)
except socket.timeout as e:
logger.error(e)
print(
"vsw: error: request timeout, there might be some issue during publishing"
)
listener.close()
break
def __init_listener(self):
tmp_base = utils.get_tmp_base_path_from_mkfile()
hmi_base_path = os.path.join(tmp_base, self.name)
# Create HMI base path if it does not exist
if not os.path.exists(hmi_base_path):
os.makedirs(hmi_base_path)
address = os.path.join(hmi_base_path, 'mb_socket')
# Ensure that socket does not exist
try:
os.unlink(address)
except OSError:
if os.path.exists(address):
logger.exception('Could not remove socket file.')
# Create listener
listener = Listener(address)
while True:
conn = listener.accept()
msg = conn.recv()
if isinstance(msg, ReadMessage):
conn.send(self.mb_tbls[msg.mb_table][self.actions[0]](
msg.ip, msg.starting_addr))
elif isinstance(msg, WriteMessage):
conn.send(self.mb_tbls[msg.mb_table][self.actions[1]](
msg.ip, msg.starting_addr, msg.values))
elif isinstance(msg, CloseMessage):
conn.close()
break
listener.close()
def local_listener():
listener = Listener(local_address_m, authkey="localModel")
while True:
conn = listener.accept()
print("[MODEL] connection accepted from", listener.last_accepted)
msg = conn.recv()
# print(msg)
assert isinstance(msg, list) and len(msg) == 3
task = msg[0]
frame = msg[1]
nickname = msg[2]
if nickname not in model_dict.get_all_dict().keys():
'''
t_tmp = Thread(target=fetch_remote_model, args=(nickname,), name="tmpDeployRemoteModel")
t_tmp.start()
# Use Default Model
print("Model not found at local, fetch from remote, switch to default model")
nickname = 'deploy_ssd_mobilenet_512'
'''
fetch_remote_model(nickname)
if task == "reid":
ans = model_dict.get_model(nickname).doInference(frame)
else:
ans = model_dict.get_model(nickname).parseResult(
task,
model_dict.get_model(nickname).doInference(frame))
conn.send(ans)
conn.close()
listener.close()
def loop(self):
listener = Listener(self.address, backlog=5, authkey=self.authkey)
logging.warn('DB server started with %s, listening on %s:%d...',
sys.executable, *self.address)
try:
while True:
try:
conn = listener.accept()
except KeyboardInterrupt:
break
except:
# unauthenticated connection, for instance by a port
# scanner such as the one in manage.py
continue
cmd_ = conn.recv() # a tuple (name, arg1, ... argN)
cmd, args = cmd_[0], cmd_[1:]
logging.debug('Got ' + str(cmd_))
if cmd == 'stop':
conn.send((None, None))
conn.close()
break
func = getattr(actions, cmd)
fut = executor.submit(safely_call, func, (self.db, ) + args)
def sendback(fut, conn=conn):
res, etype, _mon = fut.result()
if etype:
logging.error(res)
# send back the result and the exception class
conn.send((res, etype))
conn.close()
fut.add_done_callback(sendback)
finally:
listener.close()
class CommunicationDeamon(QThread):
commandReceived = pyqtSignal(object)
def __init__(self, address):
QThread.__init__(self)
self.listener = Listener(address, authkey=SECRET)
def run(self):
while True:
conn = self.listener.accept()
self.connection = conn
msg = conn.recv()
if msg[0] == 'stop':
self.listener.close()
return
conn.close()
self.commandReceived.emit(msg)
def get_port(self):
return self.listener.address[1]
def get_address(self):
return self.listener.address
def loop(self):
listener = Listener(self.address, backlog=5, authkey=self.authkey)
logging.warn('DB server listening on %s:%d...' % self.address)
self.thread.start()
cmd = None
try:
while cmd != 'stop':
try:
conn = listener.accept()
except KeyboardInterrupt:
break
except:
# unauthenticated connection, for instance by a port
# scanner such as the one in manage.py
continue
cmd_ = conn.recv() # a tuple (name, arg1, ... argN)
cmd, args = cmd_[0], cmd_[1:]
if cmd.startswith('@'): # slow command, run in process
cmd = cmd[1:] # strip @
proc = Process(
target=run_command, name=cmd, args=(cmd, args, conn))
proc.start()
logging.warn('Started %s%s in process %d',
cmd, args, proc.pid)
else:
queue.put((conn, cmd, args))
finally:
listener.close()
self.thread.join()
def loop(self):
listener = Listener(self.address, backlog=5, authkey=self.authkey)
logging.warn('DB server started with %s, listening on %s:%d...',
sys.executable, *self.address)
try:
while True:
try:
conn = listener.accept()
except KeyboardInterrupt:
break
except:
# unauthenticated connection, for instance by a port
# scanner such as the one in manage.py
continue
cmd_ = conn.recv() # a tuple (name, arg1, ... argN)
cmd, args = cmd_[0], cmd_[1:]
logging.debug('Got ' + str(cmd_))
if cmd == 'stop':
conn.send((None, None))
conn.close()
break
func = getattr(actions, cmd)
fut = executor.submit(safely_call, func, (self.db, ) + args)
def sendback(fut, conn=conn):
res, etype, _mon = fut.result()
if etype:
logging.error(res)
# send back the result and the exception class
conn.send((res, etype))
conn.close()
fut.add_done_callback(sendback)
finally:
listener.close()
def startListener(self):
"""
Listen to event triggers
"""
from multiprocessing.connection import Listener
import time
host = "localhost"
port = int(main.params['GENERATOR']['listenerPort'])
address = (host, port)
listener = Listener(address)
main.log.info(
"Event Generator - Event listener start listening on %s:%s" %
(host, port))
while 1:
conn = listener.accept()
t = main.Thread(target=self.handleConnection,
threadID=main.threadID,
name="handleConnection",
args=[conn])
t.start()
with main.variableLock:
main.threadID += 1
listener.close()
class chimeraInterface():
def __init__(self):
'''Initialize variables, create socket, register events and open volume'''
self.vProj = None
self.address = ''
self.port = 6000
self.authkey = 'test'
self.createSocket()
self.registerEvent()
self.openVolume()
def createSocket(self):
'''Create socket and wait for a new client'''
print 'Waiting for client'
self.listener = Listener((self.address, self.port),
authkey=self.authkey)
self.remote_conn = self.listener.accept()
print 'Got client ' + self.listener.last_accepted[0] + ':%d' % (
self.listener.last_accepted[1])
def openVolume(self):
'''Wait for volume data and open in volume viewer'''
try:
while True:
if self.remote_conn.poll():
msg = self.remote_conn.recv()
if type(msg) is numpy.ndarray:
from VolumeData import Array_Grid_Data
grid = Array_Grid_Data(msg)
from VolumeViewer import volume_from_grid_data
self.v = volume_from_grid_data(grid)
break
#else:
#print 'msg: ' + msg
else:
time.sleep(0.01)
except EOFError:
print 'Lost connection to client'
self.listener.close()
#def motionStart(self, trigger, x, file):
#print "Motion Start"
def motionStop(self, trigger, x, file):
'''Event executed when user unclick the volume'''
#print "Motion Stop"
rx, ry, rz, t = self.v.openState.xform.getCoordFrame()
a = numpy.array([[rx[0], ry[0], rz[0]], [rx[1], ry[1], rz[1]],
[rx[2], ry[2], rz[2]]])
self.remote_conn.send(pickle.dumps(a))
def registerEvent(self):
'''Register Events'''
#chimera.triggers.addHandler(chimera.MOTION_START, self.motionStart, None)
chimera.triggers.addHandler(chimera.MOTION_STOP, self.motionStop, None)
def run(self):
"""
Enable the server and perform some function on the inputs from the client.
"""
print("\033[94mServer for Qgis backend running here...\033[0m")
if isinstance(self.cache, dict):
print(
"\u001b[33mInputs and neural network will be cached in RAM.",
"Faster but can be troublesome with large inputs.\033[0m",
)
with open(self.connexion_file, "r") as f:
d = yaml.safe_load(f)
if self.ssh_server:
address_server = tuple(d["ssh"]["address_server"])
address_client = tuple(d["ssh"]["address_client"])
else:
address_server = tuple(d["local"]["address_server"])
address_client = tuple(d["local"]["address_client"])
while True:
listener = Listener(address_server, authkey=b"Who you gonna call?")
try:
conn = listener.accept() # ends once it has found a client
except KeyboardInterrupt:
print_warning("Keyboard interrupt.")
exit()
data = conn.recv() # receive data
conn.close()
listener.close()
if data["task"] == "Semantic segmentation":
func = self.segmentation
else:
return "Only semantic segmentation task currently implemented."
try:
print(f"\u001b[36mRunning a {data['task'].lower()} task...\033[0m")
tic = time()
result = func(data) # perform all the real work.
toc = time()
time_ = np.round(toc - tic, 1)
if not isinstance(self.cache, dict) and torch.cuda.is_available():
torch.cuda.empty_cache()
if isinstance(result, str):
new_msg = result
else:
new_msg = self.n_classes
print(f"\033[92mDone in {time_} seconds.\033[0m")
except KeyboardInterrupt:
new_msg = "Task interrupted by the user."
print_warning("\n" + new_msg)
except Exception as error:
new_msg = error
print_warning(error)
finally:
conn_client = Client(address_client, authkey=b"ghostbusters")
conn_client.send(new_msg)
conn_client.close()
if isinstance(new_msg, Exception):
raise (new_msg)
else:
print("\u001b[35;1m\nReady for another task \U0001F60E \n\033[0m")
def close(self, blockUntilClosed = True):
'''close may wait 1 second.'''
Listener.close(self)
if self.establish_connection_to_close_lock.acquire(False):
if not blockUntilClosed:
thread_start_new(self._connect_to_pipe_to_close_it, ())
else:
self._connect_to_pipe_to_close_it()
def run(self):
serv = Listener(self.address)
while self.main_thread.is_alive():
client = Child(serv)
client.start()
while self.main_thread.is_alive() and client.is_alive():
pass
serv.close()
def listen(self):
listener = Listener(self.address, authkey=b'secret password')
conn = listener.accept()
print('connection accepted from', listener.last_accepted)
msg = conn.recv()
conn.close()
listener.close()
return msg
def send(msg):
address = ('localhost', 6000)
listener = Listener(address)
conn = listener.accept()
conn.send(msg)
conn.close()
listener.close()
class SingleInstanceApp(BaseJobManager):
def __init__(self, name, session=''):
BaseJobManager.__init__(self)
if sys.platform == 'win32':
self.address = r'\\.\pipe\single_instance_app.'
else:
self.address = '/var/tmp/single_instance_app.pipe'
trans = string.maketrans('\\ ', '__')
self.address += '.'+name.translate(trans)
if session and len(session)>0:
self.address += session.translate(trans)
self.accepting_connection = False
def _accept_connection(self):
while self.accepting_connection:
conn = self.listener.accept()
args = conn.recv()
conn.close()
self.queue_launch_instance(*args)
def try_start_instance(self, *args):
try:
conn = Client(self.address, authkey='secret password')
conn.send(args)
conn.close()
#print "sent my args(%s)"%(', '.join(args))
return False
except:
self.queue_launch_instance(*args)
self.listener = Listener(self.address, authkey='secret password')
self.accepting_connection = True
self.listener_tread = threading.Thread(target=self._accept_connection)
self.listener_tread.daemon = True #because of listener.accept() blocks
self.listener_tread.start()
return True
def stop_accepting(self):
self.accepting_connection = False
self.listener.close()
self.listener_tread.join(0.01)
def queue_launch_instance(self, *args):
fancy_log(sys.stdout, 'queued instance launch with args: '+str(args))
self.add_job(*args)
#override
#def do_the_job(self, *args):
# print 'calls instance with args: ',args
# self.update_job()
def job_is_updated(self, *args, **kwargs):
fancy_log(sys.stdout,'calls instance with args: '+str(args)+'\n kwargs: '+str(kwargs))
pass
class server():
def __init__(self,
sock=8000,
ip='localhost',
authkey='secret password',
MAX=3):
self.sock = sock
self.ip = ip
self.authkey = authkey
self.connections = []
self.scale = MAX
self.jobs = []
self.outputs = []
self.socket = None
def setScale(self, scale):
self.scale = scale
def addJobs(self, _list):
self.jobs.extend(_list)
def _listen(self):
scale = self.scale
while True:
if scale:
scale -= 1
conn = self.socket.accept()
self.connections.append(conn)
#print 'connection accepted from', conn.last_accepted
else:
break
def start(self):
self.socket = Listener((self.ip, self.sock), authkey=self.authkey)
self._listen()
next = self.scale - 1
scheduler = chunks(self.jobs, self.scale)
if len(self.jobs) is 0:
print "Please add some jobs before you start me !!"
return
for each in scheduler:
self.connections[next].send(each)
next -= 1
if next < 0:
break
now = time.time()
for conn in self.connections:
x = conn.recv()
self.outputs.extend(x)
conn.close()
self.socket.close()
t = time.time() - now
X = []
X.append(["time", t])
print tabulate(X, tablefmt='rst')
#print str("Took me " + str(t) + " time")
return self.outputs
def doorTriggerLoop():
for door in cfg.GARAGE_DOORS:
state = get_garage_door_state(door['pin'])
status = cfg.HOMEAWAY
address = (cfg.NETWORK_IP, int(cfg.NETWORK_PORT))
listener = Listener(address, authkey='secret password')
while True:
conn = listener.accept()
# print 'connection accepted from', listener.last_accepted
received = conn.recv_bytes()
response = 'unknown command'
trigger = False
if received == 'trigger':
trigger = True
if state == 'open':
response = 'closing garage door'
else:
response = 'opening garage door'
elif received == 'open':
if state == 'open':
response = 'garage door already open'
else:
response = 'opening garage door'
trigger = True
elif received == 'close':
if state == 'open':
response = 'closing garage door'
trigger = True
else:
response = 'garage door alredy closed'
elif received == 'state':
response = 'the garage door is' + state
elif received == 'home':
cfg.HOMEAWAY = 'home'
response = 'alert status set to HOME'
elif received == 'away':
cfg.HOMEAWAY = 'away'
response = 'alert status set to AWAY'
conn.send_bytes(response)
print 'Received command to ' + received + ' the garage door. Response was ' + response
if trigger:
# GPIO.setup('7', GPIO.OUT)
print 'Door triggered'
# GPIO.setup('7', GPIO.IN)
trigger = False
time.sleep(1)
conn.close()
listener.close()
def doorTriggerLoop():
address = (cfg.NETWORK_IP, int(cfg.NETWORK_PORT))
listener = Listener(address)
while True:
# Receive incomming communications and set defaults
conn = listener.accept()
received_raw = ''
received_raw = conn.recv_bytes()
received = received_raw.lower()
response = 'unknown command'
trigger = False
if received == 'trigger':
trigger = True
if state == 'open':
response = 'closing'
else:
response = 'opening'
elif received == 'open' or received == 'up':
if state == 'open':
response = 'already open'
else:
response = 'opening'
trigger = True
elif received == 'close' or received == 'down':
if state == 'open':
response = 'closing'
trigger = True
else:
response = 'already closed'
elif received == 'home' or received == 'set to home':
cfg.HOMEAWAY = 'home'
response = 'set to home'
elif received == 'away' or received == 'set to away':
cfg.HOMEAWAY = 'away'
response = 'set to away'
elif received == 'state' or received == 'status':
response = get_garage_door_state() + ' and ' + cfg.HOMEAWAY
elif received.startswith('firebase:'):
cfg.FIREBASE_ID = received_raw.replace('firebase:','')
response = 'ok'
conn.send_bytes(response)
print 'received ' + received_raw + '. ' + response
if trigger:
GPIO.output(26, GPIO.LOW)
time.sleep(2)
GPIO.output(26, GPIO.HIGH)
trigger = False
time.sleep(1)
conn.close()
listener.close()
def __init_listener(self):
def on_connect(client, userdata, flags, rc):
logger.info("MQTT client [name=%s] connected with result code %s.",
self.name, str(rc))
self.is_connected = True
def disconnect():
self.client.loop_stop()
self.client.disconnect()
self.is_connected = False
# Create MQTT client
self.client = mqtt.Client()
self.client.on_connect = on_connect
tmp_base = utils.get_tmp_base_path_from_mkfile()
dev_base_path = os.path.join(tmp_base, self.name)
# Create device base path if it does not exist
if not os.path.exists(dev_base_path):
os.makedirs(dev_base_path)
address = os.path.join(dev_base_path, 'mqtt_socket')
# Ensure that socket does not exist
try:
os.unlink(address)
except OSError:
if os.path.exists(address):
logger.exception('Could not remove socket file.')
# Create listener
listener = Listener(address)
while True:
conn = listener.accept()
msg = conn.recv()
if isinstance(msg, ConnectMessage):
if msg.auth is not None:
username = msg.auth['username']
password = msg.auth['password']
if username is None:
logger.error(
"Could not authenticate MQTT client [name=%s], " +
"because username has no username has been provided.",
self.name)
else:
self.client.username_pw_set(username,
password=password)
self.client.connect(msg.host, msg.port, msg.keepalive,
msg.bind_address)
self.client.loop_start()
elif isinstance(msg, PublishMessage):
self.client.publish(msg.topic, msg.payload, msg.qos,
msg.retain)
elif isinstance(msg, DisconnectMessage):
disconnect()
elif isinstance(msg, CloseMessage):
disconnect()
conn.close()
break
listener.close()
class server():
def __init__(self, sock=8000, ip='localhost', authkey='secret password', MAX=3):
self.sock = sock
self.ip = ip
self.authkey = authkey
self.connections = []
self.scale = MAX
self.jobs = []
self.outputs = []
self.socket = None
def setScale(self, scale):
self.scale = scale
def addJobs(self, _list):
self.jobs.extend(_list)
def _listen(self):
scale = self.scale
while True:
if scale:
scale -= 1
conn = self.socket.accept()
self.connections.append(conn)
#print 'connection accepted from', conn.last_accepted
else:
break
def start(self):
self.socket = Listener((self.ip, self.sock), authkey=self.authkey)
self._listen()
next = self.scale-1
scheduler = chunks(self.jobs, self.scale)
if len(self.jobs) is 0:
print "Please add some jobs before you start me !!"
return
for each in scheduler:
self.connections[next].send(each)
next -= 1
if next < 0:
break
now = time.time()
for conn in self.connections:
x = conn.recv()
self.outputs.extend(x)
conn.close()
self.socket.close()
t = time.time() - now
X = []
X.append(["time", t])
print tabulate(X, tablefmt='rst')
#print str("Took me " + str(t) + " time")
return self.outputs
def experiment_thread(self, db, schema, tsq, literals, ready, tsq_level,
gold):
address = ('', self.port)
listener = Listener(address, authkey=self.authkey)
ready.set()
print(f'DuoquestServer listening on port {self.port}...')
conn = listener.accept()
print('DuoquestServer connection accepted from:',
listener.last_accepted)
self.verifier.init_stats()
while True:
msg = conn.recv_bytes()
try:
if msg.decode('utf-8') == 'close':
conn.close()
break
except Exception:
pass
protolist = ProtoQueryList()
protolist.ParseFromString(msg)
response = ProtoResult()
for query in protolist.queries:
if query.done_query:
if tsq_level == 'nlq_only':
result = Tribool(True)
else:
result = self.verifier.verify(db, schema, query, tsq,
literals)
else:
if tsq_level == 'nlq_only' or tsq_level == 'chain':
result = Tribool(None)
else:
result = self.verifier.verify(db, schema, query, tsq,
literals)
if result.value is None:
response.results.append(UNKNOWN)
elif result.value:
response.results.append(TRUE)
if matches_gold(gold, query):
response.answer_found = True
else:
response.results.append(FALSE)
conn.send_bytes(response.SerializeToString())
pprint(self.verifier.stats)
listener.close()
def start_serve(self):
"""start the server"""
while True:
listener = Listener(self.address)
conn = listener.accept()
process = ClientModuleConnect(listener.last_accepted, conn)
process.start()
listener.close()
def transient_server(address, authkey, seconds):
class TimeoutException(Exception):
pass
def timeout_handler(signum, frame):
raise TimeoutException('end for listener')
signal.signal(signal.SIGALRM, timeout_handler)
server = Listener(address, authkey=authkey)
try:
yield server
except TimeoutException:
server.close()
def run(self):
address = ("localhost", 6000)
listener = Listener(address, authkey="secret password")
conn = listener.accept()
while True:
command = self.queue.get()
conn.send_bytes(command)
self.queue.task_done()
if command == "quit":
break
conn.close()
listener.close()
class Visualizer(object):
def __init__(self, din = {}):
import plotter
self.dict = {
'plotter': plotter.SubplotAnimation(),
}
self.dict.update(din)
print "[IPC-S] Server process ID ", os.getpid()
self.init_communication()
self.__run__()
def init_communication(self):
print "[IPC-S] Opening Server socket ... ",
address = ('localhost', 6000) # family is deduced to be 'AF_INET'
self.listener = Listener(address)
print "done!"
print "[IPC-S] Waiting Client ... ",
self.conn = self.listener.accept()
print 'connection accepted from', self.listener.last_accepted
def close_communication(self):
print "[IPC-S] Closing interprocess communication ... ",
self.conn.close()
self.listener.close()
print "done!"
def read_msg(self):
return self.conn.recv()
def __run__(self):
while True:
msg = self.read_msg()
# msg format: [os.getpid(), i, time, avg[0], avg[1], avg[2]]
# Process the message
if msg == 'close':
self.close_communication()
break
procID = msg[0]
counter = msg[1]
logTime = msg[2]
avg = msg[3:]
#print os.getpid(), "--- Recived ", msg, " ||| avg ", avg, " ||| counter ", counter
# Plot the data
self.dict['plotter'].draw_frame([logTime, avg[0], avg[1], avg[2]] ) # plots a point every 100 ms
def run(self): listener = Listener(self.address, authkey=self.auth) while True: with listener.accept() as connection: msg = connection.recv() if msg == 'exit': break else: if shared.settings['use_indicator']: GLib.idle_add(getattr(shared.indicator, msg).activate) else: GLib.idle_add(getattr(shared.indicator, msg)) listener.close()
def run_server(address, authkey, mod, q):
serv = Listener(address, authkey =authkey)
while True:
try:
client= serv.accept()
msg= make_work(client, mod, q)
if msg == 'Close': # 关闭监听
serv.close()
return "Close"
else:
client.send(msg)
except Exception:
traceback.print_exc()
serv.close()
def run(self):
print 'Server setup'
try:
listener = Listener((self.host, self.port), authkey=self.pw)
print 'Server address :',listener.address
conn = listener.accept()
print 'connection accepted'
while True:
msg = conn.recv()
resp = self.dispatch(msg)
conn.send(resp)
except EOFError,IOError:
conn.close()
listener.close()
print "Connection terminated by client"
def server():
listener = Listener(address, authkey=b'mypassword')
print('listening..')
from_client = True
while from_client:
conn = listener.accept()
print ('connection accepted from', listener.last_accepted)
conn.send([1,2,3,4])
conn.send_bytes(b'hello')
from_client = conn.recv()
print(from_client)
conn.close()
listener.close()
def run(self):
global loop_data, archive_data, conn, lock
syslog.syslog(syslog.LOG_INFO, "wxdata server started")
syslog.syslog(syslog.LOG_INFO, "wxdata: server process {}".format(os.getpid()))
syslog.syslog(syslog.LOG_INFO, "wxdata: address: '{}' ".format(self.address))
syslog.syslog(syslog.LOG_INFO, "wxdata: key: '{}' ".format(self.key))
listener = Listener(self.address, authkey=self.key)
listener._listener._socket.settimeout(10)
while True:
# try to accept a connection - most likely failure is a timeout
try:
conn = listener.accept()
if self.exit.is_set():
syslog.syslog(syslog.LOG_INFO, "wxdata: server exiting")
break
# syslog.syslog(syslog.LOG_INFO, "wxdata: connection accepted from: " + format(listener.last_accepted))
req = conn.recv()
if isinstance(req,str): # simple request?
if req == "wxloop":
with lock: data = loop_data
elif req == "wxarchive":
with lock: data = archive_data
elif req == "wxname":
data = self.name # station name as string
conn.send(data)
elif isinstance(req,tuple): # request with keys?
keys = req[1:] # extract the key list
req = req[0]
with lock:
if req == "wxloop":
wxdata = loop_data
elif req == "wxarchive":
wxdata = archive_data
# data = {k: wxdata.get(k,'**BadKey**') for k in keys}
dp = wxdata.get('dewpoint','***')
if dp == "***":
syslog.syslog(syslog.LOG_ERR, "wxdata: dewpoint missing".format(len(loop_data)))
data = {k: wxdata.get(k,None) for k in keys}
conn.send(data)
conn.close()
except socket.timeout:
pass
except Exception as e:
syslog.syslog(syslog.LOG_ERR, "wxdata: Exception")
syslog.syslog(syslog.LOG_ERR, "wxdata: error: {0} - {1}".format(type(e), e))
# syslog.syslog(syslog.LOG_ERR, "wxdata: error: {}".format(sys.exc_info()[0]))
listener.close()
syslog.syslog(syslog.LOG_INFO, "wxdata: server ended")
def listener():
address = ('localhost', 8888)
# 为什么加了authkey就会报出OSError:bad message length ? 超出了最大的长度
# listener = Listener(address, backlog=100, authkey=bytes('johnson wu', 'utf-8'))
listener = Listener(address, backlog=100)
while True:
conn = listener.accept()
try:
print(conn) # 根据打印出来的conn对象，只是用到了4个进程
conn.send('hhh')
except Exception as e:
raise e
finally:
conn.close()
listener.close()
def testing():
from multiprocessing.connection import Listener
address = ('localhost', 6000) # family is deduced to be 'AF_INET'
listener = Listener(address, authkey='dp23y4fm')
while True:
conn = listener.accept()
if conn.recv_bytes() == "stop":
print "Stopping Speeking"
global is_stopped
with lock: is_stopped = True
conn.close()
listener.close()
def accept(address):
"""
Accept a connection and return a Connection object.
"""
while True:
try:
listener = Listener(address, authkey=USERPREF['authkey'])
conn = listener.accept()
break
except Exception:
log_warn("The authentication key is not correct")
listener.close()
del listener
time.sleep(.1)
client = listener.last_accepted
return Connection(conn), client[0]
def bare_server(port, logfile):
"""Bare-bones remote server"""
from multiprocessing.connection import Listener
fd = open(logfile, "w", 0)
address = ("", port)
listener = Listener(address)
conn = listener.accept()
fd.write("Connection accepted\n")
# Wait for main server and execute it
msg = conn.recv()
try:
exec(msg)
except Exception as e:
fd.write("ERROR: %r\n" % e)
fd.close()
listener.close()
def main(host='localhost', port=6000, authkey='secret password'):
"Debug a script and accept a remote frontend"
if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
print "usage: pdb.py scriptfile [arg] ..."
sys.exit(2)
mainpyfile = sys.argv[1] # Get script filename
if not os.path.exists(mainpyfile):
print 'Error:', mainpyfile, 'does not exist'
sys.exit(1)
del sys.argv[0] # Hide "pdb.py" from argument list
# Replace pdb's dir with script's dir in front of module search path.
sys.path[0] = os.path.dirname(mainpyfile)
from multiprocessing.connection import Listener
address = (host, port) # family is deduced to be 'AF_INET'
listener = Listener(address, authkey=authkey)
print "qdb debugger backend: waiting for connection at", address
conn = listener.accept()
print 'qdb debugger backend: connected to', listener.last_accepted
# create the backend
qdb = Qdb(conn, redirect_stdio=True, allow_interruptions=True)
try:
print "running", mainpyfile
qdb._runscript(mainpyfile)
print "The program finished"
except SystemExit:
# In most cases SystemExit does not warrant a post-mortem session.
print "The program exited via sys.exit(). Exit status: ",
print sys.exc_info()[1]
raise
except Exception:
traceback.print_exc()
print "Uncaught exception. Entering post mortem debugging"
info = sys.exc_info()
qdb.post_mortem(info)
print "Program terminated!"
finally:
conn.close()
listener.close()
print "qdb debbuger backend: connection closed"
def run(self):
listener = Listener(('localhost', 18273))
connection = listener.accept()
# uuid
connection.recv_bytes().decode('utf-8')
# ServerBreaks
connection.recv_bytes().decode('utf-8')
# Empty breaks
connection.send_bytes(b'{}')
# Continuing
if self.stops:
connection.recv_bytes().decode('utf-8')
connection.send_bytes(b'Continue')
self.lock.acquire()
connection.close()
listener.close()
self.lock.release()
class ApiServer(object):
def __init__(self,address,handler):
self.listener = Listener(address,authkey='secret password')
self.handler = handler
self.done = False
def serve_forever(self):
while not self.done:
conn = self.listener.accept()
print 'connection accepted from', self.listener.last_accepted
handler = self.handler(conn)
handler_thread = threading.Thread(target=handler.handle)
handler_thread.start()
def shutdown(self):
self.done = True
self.listener.close()
def run(self):
while True:
# Start the server
server_shutdown = False
logging.info("Listening on {0} port".format(self.port))
listener = Listener((self.host, self.port))
conn = listener.accept()
logging.info("Connection accepted from {0}".format(listener.last_accepted))
# Handle client requests
while True:
try:
msg = conn.recv()
if not msg: continue
logging.info('Client request: {0}'.format(msg))
if msg[0] == 'start' and self.indexer_running == False:
self.__start_indexer(msg)
elif msg[0] == 'stop' and self.indexer_running == True:
self.__stop_indexer()
elif msg[0] == 'shutdown':
server_shutdown = True
break
else:
logging.warning('Unknown client request.')
except (EOFError):
logging.info('Connection closed.')
conn.close()
listener.close()
break
# Handle shutdown request
if server_shutdown == True:
logging.info('Shutting the indexer down ...')
break
# Clean-up and exit
conn.close()
listener.close()
if self.indexer != None:
if self.indexer_running == True:
self.__stop_indexer()
self.indexer.finalize()
logging.info('Exiting ...')
def run_server(process = lambda x : x):
"""
Runs server (blocking).
"""
print "Listener created at", __address
listener = Listener(__address, authkey='strumamor')
while True:
try:
connection = listener.accept()
except AuthenticationError:
continue
#print "Connection accepted from", listener.last_accepted
result = _process(connection, process)
if result == __quit_command:
break
listener.close()
def startServer(self):
print('Listen starting ...')
serv = Listener(self.address, authkey=self.authkey)
while True:
try:
conn = serv.accept()
msg = conn.recv()
if msg is None:
print('self.lock_dict')
print('revice None ...')
break
print('\n\n')
print(self.lock_dict)
print('revice %s' % str(msg))
self.response(conn, msg)
print(self.lock_dict)
print('\n\n')
conn.close()
except Exception:
traceback.print_exc()
serv.close()
class ProcListener(threading.Thread):
def __init__(self, addr, authkey):
threading.Thread.__init__(self)
self.running = False
self.connections = []
self.bus = None
self.addr = addr
self.authkey = authkey
self.listener = Listener(addr, authkey=authkey)
self.setDaemon(True)
def run(self):
self.bus.log("Listening for incoming connections")
self.running = True
while self.running:
conn = self.listener.accept()
self.connections.append(conn)
def stop(self):
if not self.running:
return
self.bus.log("Stopping listener")
self.running = False
for conn in self.connections:
if conn:
conn.close()
# if the listener is blocked in the accept() call
# it will lock the thread, so by connecting to it
# we unblock it
c = Client(self.addr, authkey=self.authkey)
c.close()
self.connections = []
self.listener.close()
def recv(self):
return self.listener.recv()
def _create_server(self):
self.pid_path = '/tmp/yli-METEOR-pid'
#self.address = ('localhost', 6000)
self.address = '/tmp/yli-METEOR-server'
self.authkey = 'dummy key'
try:
pid = open(self.pid_path).read().strip()
assert 'java' in subprocess.check_output(['ps', '-p', pid, '-o', 'cmd'])
self.listener = None
self.meteor_p = None
except:
# really create server
self.meteor_p = subprocess.Popen(self.meteor_cmd, \
cwd=os.path.dirname(os.path.abspath(__file__)), \
stdin=subprocess.PIPE, \
stdout=subprocess.PIPE, \
stderr=sys.stderr)
self.pid = self.meteor_p.pid
open(self.pid_path, 'w').write(str(self.pid))
if os.fork():
# put to background
# the main process should call _compute_score to
# initialize meteor.jar, which takes longer than 5 seconds
return
else:
while True:
if os.path.exists(self.address):
os.remove(self.address)
listener = Listener(self.address, authkey=self.authkey)
try:
self._handle_listenser(listener)
except Exception as ioe:
print ioe, '65'
pass
finally:
listener.close()
