def run(self):
address = ("localhost", 6000)
conn = Client(address, authkey="secret password")
while True:
command = conn.recv_bytes()
if command == "quit":
break
self.animations[:] = parse_command(command, self.boxs, "receiver")
conn.close()
def get_rps_from_pycounters():
# gets the "request per second" data from counter server via
# multiprocessing Client from Listener which runs in a thread
# fired from possibly another webserver process
try:
rps_client = Client("/tmp/rpssock")
rps = rps_client.recv_bytes()
rps_client.close()
except:
raise
rps = 0
return rps
class NLQClient:
def __init__(self, host, port, authkey, dataset=None, mode=None):
self.host = host
self.port = port
self.authkey = authkey
self.dataset = dataset
self.mode = mode
def connect(self):
address = (self.host, self.port)
while True:
try:
self.conn = Client(address, authkey=self.authkey)
break
except Exception as e:
traceback.print_exc()
time.sleep(2)
pass
def run(self,
tid,
schema,
nlq,
tsq_level,
literals,
timeout=None,
minimal_join_paths=False):
task = ProtoTask()
task.id = str(tid)
task.dataset = self.dataset or ''
task.mode = self.mode or ''
task.tsq_level = tsq_level
task.db_name = schema.db_id
task.timeout = timeout or 0
task.minimal_join_paths = minimal_join_paths
if isinstance(nlq, list):
for token in nlq:
task.nlq_tokens.append(token)
else:
task.nlq_tokens.append(nlq)
task.literals.CopyFrom(literals)
self.conn.send_bytes(task.SerializeToString())
msg = self.conn.recv_bytes()
proto_cands = ProtoCandidates()
proto_cands.ParseFromString(msg)
return proto_cands
def close(self):
self.conn.send_bytes(b'close')
self.conn.close()
class ServiceConnect:
def __delete__(self):
if self.conn:
self.conn.close()
def conntect(self, host="localhost", port=6000):
self.conn = Client((host, port))
def request(self, req):
self.conn.send(req)
items = self.conn.recv_bytes()
result = json.loads(items)
return result
def ask_kb(config, q):
'''
ask kb synchronously
'''
conn = Client((config('kb_host'),
int(config('kb_port'))))
conn.send_bytes(q)
conn.send_bytes('FINISH-TERMS')
recv, resp = '', ''
while recv != 'END':
resp = recv
recv = conn.recv_bytes()
conn.close()
return resp
def on_get(self, req, resp):
resp.set_header('Access-Control-Allow-Origin', '*')
sound = req.get_param('sound')
seconds = req.get_param_as_float('seconds')
nresults = req.get_param_as_int('nresults') or 10
connection = TcpClient(self.index_server_address)
query_data = {'sound': sound, 'seconds': seconds, 'nresults': nresults}
connection.send_bytes(json.dumps(query_data).encode())
raw_resp = connection.recv_bytes()
results = json.loads(raw_resp.decode())
resp.media = {
'total_count': len(results),
'items': results
}
def terms_client(config):
'''
CLI for terms server
'''
while True:
terms = raw_input('>> ')
if terms in ('quit', 'q', 'exit'):
break
conn = Client((config('kb_host'),
int(config('kb_port'))))
conn.send_bytes(terms)
conn.send_bytes('FINISH-TERMS')
recv, resp = '', ''
while recv != 'END':
resp = recv
recv = conn.recv_bytes()
print(recv)
conn.close()
print('bye!')
def do_execute(self, code, silent, store_history=True, user_expressions=None,
allow_stdin=False):
conn = Client((self.host, self.port))
conn.send_bytes(bytes(code, 'UTF-8'))
conn.send_bytes(bytes('FINISH-TERMS', 'UTF-8'))
recv, resp = bytes(), str()
while recv != b'END':
if recv:
resp += ', ' + recv.decode('UTF-8')
recv = conn.recv_bytes()
conn.close()
if not silent:
stream_content = {'name': 'stdout', 'text': resp}
self.send_response(self.iopub_socket, 'stream', stream_content)
return {'status': 'ok',
# The base class increments the execution count
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
def run(self, cmd):
'''
传递命令给server, 同时展示传回信息.
@ cmd: 命令, 以tab分割.
'''
conn = MultiClient(
(config.hostname, config.port),
authkey=config.authkey,
)
# 传送命令
conn.send(cmd)
try:
# 收取信息
recv_data = conn.recv_bytes()
except EOFError:
pass
else:
# 传回的数据是unicode编码的
unicode_recv_data = eval(recv_data)
# 按照设定编码print反馈数据
print unicode_recv_data.encode(config.client_code)
finally:
conn.close()
def setMSGtoListener(msg):
address = ('localhost', 6000)
conn = Client(address, authkey='secret password')
conn.send(msg)
print conn.recv_bytes()
conn.close()
class Wdb(object):
"""Wdb debugger main class"""
_instances = {}
_sockets = []
enabled = True
breakpoints = set()
watchers = defaultdict(list)
@staticmethod
def get(no_create=False):
"""Get the thread local singleton"""
pid = os.getpid()
thread = threading.current_thread()
wdb = Wdb._instances.get((pid, thread))
if not wdb and not no_create:
wdb = object.__new__(Wdb)
Wdb.__init__(wdb)
wdb.pid = pid
wdb.thread = thread
Wdb._instances[(pid, thread)] = wdb
return wdb
@staticmethod
def pop():
"""Remove instance from instance list"""
pid = os.getpid()
thread = threading.current_thread()
Wdb._instances.pop((pid, thread))
def __new__(cls):
return cls.get()
def __init__(self):
log.debug('New wdb instance %r' % self)
self.obj_cache = {}
self.tracing = False
self.begun = False
self.connected = False
self.stepping = False
self.extra_vars = {}
self.last_obj = None
self.reset()
self.uuid = str(uuid4())
self.state = Running(None)
self.full = False
self.below = False
self._socket = None
def run_file(self, filename):
"""Run the file `filename` with trace"""
import __main__
__main__.__dict__.clear()
__main__.__dict__.update({
"__name__": "__main__",
"__file__": filename,
"__builtins__": __builtins__,
})
with open(filename, "rb") as fp:
statement = "exec(compile(%r, %r, 'exec'))" % (
fp.read(), filename)
self.run(statement, filename)
def run(self, cmd, fn=None, globals=None, locals=None):
"""Run the cmd `cmd` with trace"""
if globals is None:
import __main__
globals = __main__.__dict__
if locals is None:
locals = globals
self.reset()
if isinstance(cmd, str):
cmd = compile(cmd, fn or "<wdb>", "exec")
self.start_trace()
self.breakpoints.add(Breakpoint(fn, temporary=True))
try:
execute(cmd, globals, locals)
finally:
self.stop_trace()
def reset(self):
"""Refresh linecache"""
import linecache
linecache.checkcache()
def connect(self):
"""Connect to wdb server"""
log.info('Connecting socket on %s:%d' % (SOCKET_SERVER, SOCKET_PORT))
tries = 0
while not self._socket and tries < 10:
try:
self._socket = Client((SOCKET_SERVER, SOCKET_PORT))
except socket.error:
tries += 1
log.warning(
'You must start wdb.server. '
'(Retrying on %s:%d) [Try #%d]' % (
SOCKET_SERVER, SOCKET_PORT, tries))
if not self._socket:
log.error('Could not connect to server')
sys.exit(2)
Wdb._sockets.append(self._socket)
self._socket.send_bytes(self.uuid.encode('utf-8'))
def trace_dispatch(self, frame, event, arg):
"""This function is called every line,
function call, function return and exception during trace"""
fun = getattr(self, 'handle_' + event)
if fun and (
(event == 'line' and self.breaks(frame)) or
(event == 'exception' and
(self.full or frame == self.state.frame or
(self.below and frame.f_back == self.state.frame))) or
self.state.stops(frame, event)):
fun(frame, arg)
if event == 'return' and frame == self.state.frame:
# Upping state
if self.state.up():
# No more frames
self.stop_trace()
return
# Threading / Multiprocessing support
co = self.state.frame.f_code
if ((
co.co_filename.endswith('threading.py') and
co.co_name.endswith('_bootstrap_inner')
) or (self.state.frame.f_code.co_filename.endswith(
os.path.join('multiprocessing', 'process.py')) and
self.state.frame.f_code.co_name == '_bootstrap')):
# Thread / Process is dead
self.stop_trace()
self.die()
return
if (event == 'call' and not self.stepping and not self.full and
not (self.below and frame.f_back == self.state.frame) and
not self.get_file_breaks(frame.f_code.co_filename)):
# Don't trace anymore here
return
return self.trace_dispatch
def trace_debug_dispatch(self, frame, event, arg):
"""Utility function to add debug to tracing"""
trace_log.info('Frame:%s. Event: %s. Arg: %r' % (
pretty_frame(frame), event, arg))
trace_log.debug('state %r breaks ? %s stops ? %s' % (
self.state,
self.breaks(frame, no_remove=True),
self.state.stops(frame, event)
))
if event == 'return':
trace_log.debug(
'Return: frame: %s, state: %s, state.f_back: %s' % (
pretty_frame(frame), pretty_frame(self.state.frame),
pretty_frame(self.state.frame.f_back)))
if self.trace_dispatch(frame, event, arg):
return self.trace_debug_dispatch
trace_log.debug("No trace %s" % pretty_frame(frame))
def start_trace(self, full=False, frame=None, below=False):
"""Start tracing from here"""
if self.tracing:
return
self.reset()
log.info('Starting trace on %r' % self.thread)
frame = frame or sys._getframe().f_back
# Setting trace without pausing
self.set_trace(frame, break_=False)
self.tracing = True
self.below = below
self.full = full
def set_trace(self, frame=None, break_=True):
"""Break at current state"""
# We are already tracing, do nothing
trace_log.info('Setting trace %s (stepping %s) (current_trace: %s)' % (
pretty_frame(frame or sys._getframe().f_back), self.stepping,
sys.gettrace()))
if self.stepping:
return
self.reset()
trace = (self.trace_dispatch
if trace_log.level >= 30 else self.trace_debug_dispatch)
trace_frame = frame = frame or sys._getframe().f_back
while frame:
frame.f_trace = trace
frame = frame.f_back
self.state = Step(trace_frame) if break_ else Running(trace_frame)
sys.settrace(trace)
def stop_trace(self, frame=None):
"""Stop tracing from here"""
self.tracing = False
self.full = False
frame = frame or sys._getframe().f_back
while frame:
del frame.f_trace
frame = frame.f_back
sys.settrace(None)
log.info('Stopping trace on %r' % self.thread)
def set_until(self, frame, lineno=None):
"""Stop on the next line number."""
self.state = Until(frame, frame.f_lineno)
def set_step(self, frame):
"""Stop on the next line."""
self.state = Step(frame)
def set_next(self, frame):
"""Stop on the next line in current frame."""
self.state = Next(frame)
def set_return(self, frame):
"""Stop when returning from the given frame."""
self.state = Return(frame)
def set_continue(self, frame):
"""Don't stop anymore"""
self.state = Running(frame)
if not self.tracing and not self.breakpoints:
# If we were in a set_trace and there's no breakpoint to trace for
# Run without trace
self.stop_trace()
def get_break(self, filename, lineno, temporary, cond, funcname):
if lineno and not cond:
return LineBreakpoint(filename, lineno, temporary)
elif cond:
return ConditionalBreakpoint(
filename, lineno, cond, temporary)
elif funcname:
return FunctionBreakpoint(filename, funcname, temporary)
else:
return Breakpoint(filename, temporary)
def set_break(self, filename, lineno=None, temporary=False, cond=None,
funcname=None):
"""Put a breakpoint for filename"""
log.info('Setting break fn:%s lno:%s tmp:%s cond:%s fun:%s' % (
filename, lineno, temporary, cond, funcname))
breakpoint = self.get_break(
filename, lineno, temporary, cond, funcname)
self.breakpoints.add(breakpoint)
if not temporary:
self._socket.send_bytes(
b'Server|AddBreak|' + pickle.dumps(breakpoint, protocol=2))
log.info('Breakpoint %r added' % breakpoint)
def clear_break(self, filename, lineno=None, temporary=False, cond=None,
funcname=None):
"""Remove a breakpoint"""
log.info('Removing break fn:%s lno:%s tmp:%s cond:%s fun:%s' % (
filename, lineno, temporary, cond, funcname))
breakpoint = self.get_break(
filename, lineno, temporary or False, cond, funcname)
if temporary is None and breakpoint not in self.breakpoints:
breakpoint = self.get_break(
filename, lineno, True, cond, funcname)
try:
self.breakpoints.remove(breakpoint)
if not temporary:
self._socket.send_bytes(
b'Server|RmBreak|' + pickle.dumps(breakpoint, protocol=2))
log.info('Breakpoint %r removed' % breakpoint)
except:
log.info('Breakpoint %r not removed: not found' % breakpoint)
def safe_repr(self, obj):
"""Like a repr but without exception"""
try:
return repr(obj)
except Exception as e:
return '??? Broken repr (%s: %s)' % (type(e).__name__, e)
def safe_better_repr(self, obj):
"""Repr with inspect links on objects"""
try:
rv = self.better_repr(obj)
except Exception:
rv = None
if rv:
return rv
self.obj_cache[id(obj)] = obj
return '<a href="%d" class="inspect">%s</a>' % (
id(obj), escape(repr(obj)))
def better_repr(self, obj):
"""Repr with html decorations"""
if isinstance(obj, dict):
if type(obj) != dict:
dict_repr = type(obj).__name__ + '({'
closer = '})'
else:
dict_repr = '{'
closer = '}'
if len(obj) > 2:
dict_repr += '<table>'
dict_repr += ''.join([
'<tr><td>' + self.safe_repr(key) + '</td><td>:</td>'
'<td>' + self.safe_better_repr(val) + '</td></tr>'
for key, val in sorted(obj.items(), key=lambda x: x[0])])
dict_repr += '</table>'
else:
dict_repr += ', '.join([
self.safe_repr(key) + ': ' + self.safe_better_repr(val)
for key, val in sorted(obj.items(), key=lambda x: x[0])])
dict_repr += closer
return dict_repr
if any([
isinstance(obj, list),
isinstance(obj, set),
isinstance(obj, tuple)]):
if type(obj) == list:
iter_repr = '['
closer = ']'
elif type(obj) == set:
iter_repr = '{'
closer = '}'
elif type(obj) == tuple:
iter_repr = '('
closer = ')'
else:
iter_repr = escape(obj.__class__.__name__) + '(['
closer = '])'
splitter = ', '
if len(obj) > 2:
splitter += '\n'
iter_repr += '\n'
closer = '\n' + closer
iter_repr += splitter.join(
[self.safe_better_repr(val) for val in obj])
iter_repr += closer
return iter_repr
@contextmanager
def capture_output(self, with_hook=True):
"""Steal stream output, return them in string, restore them"""
self.hooked = ''
def display_hook(obj):
# That's some dirty hack
self.hooked += self.safe_better_repr(obj)
self.last_obj = obj
stdout, stderr = sys.stdout, sys.stderr
if with_hook:
d_hook = sys.displayhook
sys.displayhook = display_hook
sys.stdout, sys.stderr = StringIO(), StringIO()
out, err = [], []
try:
yield out, err
finally:
out.extend(sys.stdout.getvalue().splitlines()[1:])
err.extend(sys.stderr.getvalue().splitlines())
if with_hook:
sys.displayhook = d_hook
sys.stdout, sys.stderr = stdout, stderr
def dmp(self, thing):
"""Dump the content of an object in a dict for wdb.js"""
def safe_getattr(key):
"""Avoid crash on getattr"""
try:
return getattr(thing, key)
except Exception as e:
return 'Error getting attr "%s" from "%s" (%s: %s)' % (
key, thing,
type(e).__name__, e)
return dict(
(escape(key), {
'val': self.safe_better_repr(safe_getattr(key)),
'type': type(safe_getattr(key)).__name__
})
for key in dir(thing)
)
def get_file(self, filename):
"""Get file source from cache"""
import linecache
return to_unicode_string(
''.join(linecache.getlines(filename)), filename)
def get_stack(self, f, t):
"""Build the stack from frame and traceback"""
stack = []
if t and t.tb_frame == f:
t = t.tb_next
while f is not None:
stack.append((f, f.f_lineno))
f = f.f_back
stack.reverse()
i = max(0, len(stack) - 1)
while t is not None:
stack.append((t.tb_frame, t.tb_lineno))
t = t.tb_next
if f is None:
i = max(0, len(stack) - 1)
return stack, i
def get_trace(self, frame, tb):
"""Get a dict of the traceback for wdb.js use"""
import linecache
frames = []
stack, _ = self.get_stack(frame, tb)
current = 0
for i, (stack_frame, lno) in enumerate(stack):
if frame == stack_frame:
current = i
break
for i, (stack_frame, lno) in enumerate(stack):
code = stack_frame.f_code
filename = code.co_filename
linecache.checkcache(filename)
line = linecache.getline(filename, lno, stack_frame.f_globals)
line = to_unicode_string(line, filename)
line = line and line.strip()
startlnos = dis.findlinestarts(code)
lastlineno = list(startlnos)[-1][1]
frames.append({
'file': filename,
'function': code.co_name,
'flno': code.co_firstlineno,
'llno': lastlineno,
'lno': lno,
'code': line,
'level': i,
'current': current == i
})
# While in exception always put the context to the top
current = len(frames) - 1
return stack, frames, current
def send(self, data):
"""Send data through websocket"""
log.debug('Sending %s' % data)
self._socket.send_bytes(data.encode('utf-8'))
def receive(self, pickled=False):
"""Receive data through websocket"""
log.debug('Receiving')
data = self._socket.recv_bytes()
if pickled:
data = pickle.loads(data)
log.debug('Got pickled %r' % data)
return data
log.debug('Got %s' % data)
return data.decode('utf-8')
def interaction(
self, frame, tb=None,
exception='Wdb', exception_description='Stepping',
init=None):
"""User interaction handling blocking on socket receive"""
log.info('Interaction for %r -> %r %r %r %r' % (
self.thread, frame, tb, exception, exception_description))
self.stepping = True
if not self.connected:
self.connect()
log.debug('Launching browser and wait for connection')
web_url = 'http://%s:%d/debug/session/%s' % (
WEB_SERVER or 'localhost',
WEB_PORT or 1984,
self.uuid)
server = WEB_SERVER or '[wdb.server]'
if WEB_PORT:
server += ':%s' % WEB_PORT
if WDB_NO_BROWSER_AUTO_OPEN:
log.warning('You can now launch your browser at '
'http://%s/debug/session/%s' % (
server,
self.uuid))
elif not webbrowser.open(web_url):
log.warning('Unable to open browser, '
'please go to http://%s/debug/session/%s' % (
server,
self.uuid))
self.connected = True
interaction = Interaction(
self, frame, tb, exception, exception_description, init=init)
# For meta debugging purpose
self._ui = interaction
if self.begun:
# Each new state sends the trace and selects a frame
interaction.init()
else:
self.begun = True
interaction.loop()
def handle_call(self, frame, argument_list):
"""This method is called when there is the remote possibility
that we ever need to stop in this function."""
fun = frame.f_code.co_name
log.info('Calling: %r' % fun)
init = 'Echo|%s' % dump({
'for': '__call__',
'val': fun})
self.interaction(
frame, init=init,
exception_description='Calling %s' % fun)
def handle_line(self, frame, arg):
"""This function is called when we stop or break at this line."""
log.info('Stopping at line %s' % pretty_frame(frame))
self.interaction(frame)
def handle_return(self, frame, return_value):
"""This function is called when a return trap is set here."""
self.obj_cache[id(return_value)] = return_value
self.extra_vars['__return__'] = return_value
fun = frame.f_code.co_name
log.info('Returning from %r with value: %r' % (
fun, return_value))
init = 'Echo|%s' % dump({
'for': '__return__',
'val': return_value
})
self.interaction(
frame, init=init,
exception_description='Returning from %s with value %s' % (
fun, return_value))
def handle_exception(self, frame, exc_info):
"""This function is called if an exception occurs,
but only if we are to stop at or just below this level."""
type_, value, tb = exc_info
# Python 3 is broken see http://bugs.python.org/issue17413
_value = value
if not isinstance(_value, BaseException):
_value = type_(value)
fake_exc_info = type_, _value, tb
log.error('Exception during trace', exc_info=fake_exc_info)
self.obj_cache[id(exc_info)] = exc_info
self.extra_vars['__exception__'] = exc_info
exception = type_.__name__
exception_description = str(value)
init = 'Echo|%s' % dump({
'for': '__exception__',
'val': escape('%s: %s') % (
exception, exception_description)})
# User exception is 4 frames away from exception
log.warning(pretty_frame(frame))
frame = frame or sys._getframe().f_back.f_back.f_back.f_back
self.interaction(
frame, tb, exception, exception_description, init=init)
def breaks(self, frame, no_remove=False):
"""Return True if there's a breakpoint at frame"""
for breakpoint in set(self.breakpoints):
if breakpoint.breaks(frame):
if breakpoint.temporary and not no_remove:
self.breakpoints.remove(breakpoint)
return True
return False
def get_file_breaks(self, filename):
"""List all file `filename` breakpoints"""
return [breakpoint for breakpoint in self.breakpoints
if breakpoint.on_file(filename)]
def get_breaks_lno(self, filename):
"""List all line numbers that have a breakpoint"""
return list(
filter(lambda x: x is not None,
[getattr(breakpoint, 'line', None)
for breakpoint in self.breakpoints
if breakpoint.on_file(filename)]))
def die(self):
"""Time to quit"""
log.info('Time to die')
if self.connected:
try:
self.send('Die')
except:
pass
self._socket.close()
self.pop()
def client(msg):
conn = Client(address, authkey=b'mypassword')
conn.send(msg)
print (conn.recv())
print (conn.recv_bytes())
conn.close()
from multiprocessing.connection import Client
from array import array
address = ('localhost', 6000)
conn = Client(address, authkey='secret password')
print conn.recv() # => [2.25, None, 'junk', float]
print conn.recv_bytes() # => 'hello'
arr = array('i', [0, 0, 0, 0, 0])
print conn.recv_bytes_into(arr) # => 8
print arr # => array('i', [42, 1729, 0, 0, 0])
conn.close()
class Environment(object):
"""Supplement server client"""
def __init__(self, executable=None, env=None, logfile=None):
"""Environment constructor
:param executable: path to python executable. May be path to virtualenv interpreter
start script like ``/path/to/venv/bin/python``.
:param env: environment variables dict, e.g. ``DJANGO_SETTINGS_MODULE`` value.
:param logfile: explicit log file, can be passed via environment SUPP_LOG_FILE
"""
self.executable = executable or sys.executable
self.env = env
self.logfile = logfile
self.prepare_thread = None
self.prepare_lock = Lock()
def _run(self):
from subprocess import Popen
from multiprocessing.connection import Client, arbitrary_address
if sys.platform == 'win32':
addr = arbitrary_address('AF_PIPE')
else:
addr = arbitrary_address('AF_UNIX')
supp_server = os.path.join(os.path.dirname(__file__), 'server.py')
args = [self.executable, supp_server, addr]
env = os.environ.copy()
if self.env:
env.update(self.env)
if self.logfile and 'SUPP_LOG_FILE' not in env:
env['SUPP_LOG_FILE'] = self.logfile
self.proc = Popen(args, env=env)
start = time.time()
while True:
try:
self.conn = Client(addr)
except Exception as e:
if time.time() - start > 5:
raise Exception('Supp server launching timeout exceed: ' + str(e))
time.sleep(0.3)
else:
break
def _threaded_run(self):
try:
self._run()
finally:
self.prepare_thread = None
def prepare(self):
with self.prepare_lock:
if self.prepare_thread:
return
if hasattr(self, 'conn'):
return
self.prepare_thread = Thread(target=self._threaded_run)
self.prepare_thread.start()
def run(self):
with self.prepare_lock:
if self.prepare_thread:
self.prepare_thread.join()
if not hasattr(self, 'conn'):
self._run()
def _call(self, name, *args, **kwargs):
try:
self.conn
except AttributeError:
self.run()
self.conn.send_bytes(dumps((name, args, kwargs)))
result, is_ok = loads(self.conn.recv_bytes())
if is_ok:
return result
else:
raise Exception(result[1])
def lint(self, source, filename, syntax_only=False):
return self._call('lint', source, filename, syntax_only)
def assist(self, source, position, filename):
"""Return completion match and list of completion proposals
:param source: code source
:param position: tuple of (line, column)
:param filename: absolute path of file with source code
:returns: tuple (completion match, sorted list of proposals)
"""
return self._call('assist', source, position, filename)
def location(self, source, position, filename):
"""Return position and file path where name under cursor is defined
If position is None location wasn't finded. If file path is None, defenition is located in
the same source.
:param source: code source
:param position: tuple of (line, column)
:param filename: absolute path of file with source code
:returns: tuple ((line, column), file path)
"""
return self._call('location', source, position, filename)
# def get_docstring(self, project_path, source, position, filename):
# """Return signature and docstring for current cursor call context
# Some examples of call context::
# func(|
# func(arg|
# func(arg,|
# func(arg, func2(| # call context is func2
# Signature and docstring can be None
# :param project_path: absolute project path
# :param source: unicode or byte string code source
# :param position: character or byte cursor position
# :param filename: absolute path of file with source code
# :returns: tuple (signarure, docstring)
# """
# return self._call('get_docstring', project_path, source, position, filename)
def configure(self, config):
"""Reconfigure project
:param config: dict with config key/values
"""
return self._call('configure', config)
# def get_scope(self, project_path, source, lineno, filename, continous=True):
# """
# Return scope name at cursor position
# For example::
# class Foo:
# def foo(self):
# pass
# |
# def bar(self):
# pass
# get_scope return Foo.foo if continuous is True and Foo otherwise.
# :param project_path: absolute project path
# :param source: unicode or byte string code source
# :param position: character or byte cursor position
# :param filename: absolute path of file with source code
# :param continous: allow parent scope beetween children if False
# """
# return self._call('get_scope', project_path, source, lineno, filename, continous=continous)
def eval(self, source):
return self._call('eval', source)
def close(self):
"""Shutdown server"""
try:
self.conn
except AttributeError:
pass
else:
self.conn.send_bytes(dumps(('close', (), {}), 2))
self.conn.close()
del self.conn
from multiprocessing.connection import Client
from array import array
address = ('localhost', 6000)
conn = Client(address, authkey='secret password')
print conn.recv() # => [2.25, None, 'junk', float]
print conn.recv_bytes() # => 'hello'
arr = array('i', [0, 0, 0, 0, 0])
print conn.recv_bytes_into(arr) # => 8
print arr # => array('i', [42, 1729, 0, 0, 0])
conn.close()
from multiprocessing.connection import Client
import sys
conn = Client(address=("", 6000))
while True:
line = sys.stdin.readline()
if not line.strip(): break
conn.send_bytes(line)
reply = conn.recv_bytes()
print "Reply: ", reply
conn.close()
class Wdb(object):
"""Wdb debugger main class"""
_instances = {}
_sockets = []
enabled = True
breakpoints = set()
watchers = defaultdict(list)
@staticmethod
def get(no_create=False):
"""Get the thread local singleton"""
pid = os.getpid()
thread = threading.current_thread()
wdb = Wdb._instances.get((pid, thread))
if not wdb and not no_create:
wdb = object.__new__(Wdb)
Wdb.__init__(wdb)
wdb.pid = pid
wdb.thread = thread
Wdb._instances[(pid, thread)] = wdb
return wdb
@staticmethod
def pop():
"""Remove instance from instance list"""
pid = os.getpid()
thread = threading.current_thread()
Wdb._instances.pop((pid, thread))
def __new__(cls):
return cls.get()
def __init__(self):
log.debug('New wdb instance %r' % self)
self.obj_cache = {}
self.tracing = False
self.begun = False
self.connected = False
self.stepping = False
self.extra_vars = {}
self.last_obj = None
self.reset()
self.uuid = str(uuid4())
self.state = Running(None)
self.full = False
self.below = False
self._socket = None
def run_file(self, filename):
"""Run the file `filename` with trace"""
import __main__
__main__.__dict__.clear()
__main__.__dict__.update({
"__name__": "__main__",
"__file__": filename,
"__builtins__": __builtins__,
})
with open(filename, "rb") as fp:
statement = "exec(compile(%r, %r, 'exec'))" % (fp.read(), filename)
self.run(statement, filename)
def run(self, cmd, fn=None, globals=None, locals=None):
"""Run the cmd `cmd` with trace"""
if globals is None:
import __main__
globals = __main__.__dict__
if locals is None:
locals = globals
self.reset()
if isinstance(cmd, str):
cmd = compile(cmd, fn or "<wdb>", "exec")
self.start_trace()
self.breakpoints.add(Breakpoint(fn, temporary=True))
try:
execute(cmd, globals, locals)
finally:
self.stop_trace()
def reset(self):
"""Refresh linecache"""
import linecache
linecache.checkcache()
def connect(self):
"""Connect to wdb server"""
log.info('Connecting socket on %s:%d' % (SOCKET_SERVER, SOCKET_PORT))
tries = 0
while not self._socket and tries < 10:
try:
self._socket = Client((SOCKET_SERVER, SOCKET_PORT))
except socket.error:
tries += 1
log.warning('You must start wdb.server. '
'(Retrying on %s:%d) [Try #%d]' %
(SOCKET_SERVER, SOCKET_PORT, tries))
if not self._socket:
log.error('Could not connect to server')
sys.exit(2)
Wdb._sockets.append(self._socket)
self._socket.send_bytes(self.uuid.encode('utf-8'))
def trace_dispatch(self, frame, event, arg):
"""This function is called every line,
function call, function return and exception during trace"""
fun = getattr(self, 'handle_' + event)
if fun and ((event == 'line' and self.breaks(frame)) or
(event == 'exception' and
(self.full or frame == self.state.frame or
(self.below and frame.f_back == self.state.frame)))
or self.state.stops(frame, event)):
fun(frame, arg)
if event == 'return' and frame == self.state.frame:
# Upping state
if self.state.up():
# No more frames
self.stop_trace()
return
# Threading / Multiprocessing support
co = self.state.frame.f_code
if ((co.co_filename.endswith('threading.py')
and co.co_name.endswith('_bootstrap_inner'))
or (self.state.frame.f_code.co_filename.endswith(
os.path.join('multiprocessing', 'process.py'))
and self.state.frame.f_code.co_name == '_bootstrap')):
# Thread / Process is dead
self.stop_trace()
self.die()
return
if (event == 'call' and not self.stepping and not self.full
and not (self.below and frame.f_back == self.state.frame)
and not self.get_file_breaks(frame.f_code.co_filename)):
# Don't trace anymore here
return
return self.trace_dispatch
def trace_debug_dispatch(self, frame, event, arg):
"""Utility function to add debug to tracing"""
trace_log.info('Frame:%s. Event: %s. Arg: %r' %
(pretty_frame(frame), event, arg))
trace_log.debug('state %r breaks ? %s stops ? %s' %
(self.state, self.breaks(frame, no_remove=True),
self.state.stops(frame, event)))
if event == 'return':
trace_log.debug(
'Return: frame: %s, state: %s, state.f_back: %s' %
(pretty_frame(frame), pretty_frame(
self.state.frame), pretty_frame(self.state.frame.f_back)))
if self.trace_dispatch(frame, event, arg):
return self.trace_debug_dispatch
trace_log.debug("No trace %s" % pretty_frame(frame))
def start_trace(self, full=False, frame=None, below=False):
"""Start tracing from here"""
if self.tracing:
return
self.reset()
log.info('Starting trace on %r' % self.thread)
frame = frame or sys._getframe().f_back
# Setting trace without pausing
self.set_trace(frame, break_=False)
self.tracing = True
self.below = below
self.full = full
def set_trace(self, frame=None, break_=True):
"""Break at current state"""
# We are already tracing, do nothing
trace_log.info('Setting trace %s (stepping %s) (current_trace: %s)' %
(pretty_frame(frame or sys._getframe().f_back),
self.stepping, sys.gettrace()))
if self.stepping:
return
self.reset()
trace = (self.trace_dispatch
if trace_log.level >= 30 else self.trace_debug_dispatch)
trace_frame = frame = frame or sys._getframe().f_back
while frame:
frame.f_trace = trace
frame = frame.f_back
self.state = Step(trace_frame) if break_ else Running(trace_frame)
sys.settrace(trace)
def stop_trace(self, frame=None):
"""Stop tracing from here"""
self.tracing = False
self.full = False
frame = frame or sys._getframe().f_back
while frame:
del frame.f_trace
frame = frame.f_back
sys.settrace(None)
log.info('Stopping trace on %r' % self.thread)
def set_until(self, frame, lineno=None):
"""Stop on the next line number."""
self.state = Until(frame, frame.f_lineno)
def set_step(self, frame):
"""Stop on the next line."""
self.state = Step(frame)
def set_next(self, frame):
"""Stop on the next line in current frame."""
self.state = Next(frame)
def set_return(self, frame):
"""Stop when returning from the given frame."""
self.state = Return(frame)
def set_continue(self, frame):
"""Don't stop anymore"""
self.state = Running(frame)
if not self.tracing and not self.breakpoints:
# If we were in a set_trace and there's no breakpoint to trace for
# Run without trace
self.stop_trace()
def get_break(self, filename, lineno, temporary, cond, funcname):
if lineno and not cond:
return LineBreakpoint(filename, lineno, temporary)
elif cond:
return ConditionalBreakpoint(filename, lineno, cond, temporary)
elif funcname:
return FunctionBreakpoint(filename, funcname, temporary)
else:
return Breakpoint(filename, temporary)
def set_break(self,
filename,
lineno=None,
temporary=False,
cond=None,
funcname=None):
"""Put a breakpoint for filename"""
log.info('Setting break fn:%s lno:%s tmp:%s cond:%s fun:%s' %
(filename, lineno, temporary, cond, funcname))
breakpoint = self.get_break(filename, lineno, temporary, cond,
funcname)
self.breakpoints.add(breakpoint)
if not temporary:
self._socket.send_bytes(b'Server|AddBreak|' +
pickle.dumps(breakpoint))
log.info('Breakpoint %r added' % breakpoint)
def clear_break(self,
filename,
lineno=None,
temporary=False,
cond=None,
funcname=None):
"""Remove a breakpoint"""
log.info('Removing break fn:%s lno:%s tmp:%s cond:%s fun:%s' %
(filename, lineno, temporary, cond, funcname))
breakpoint = self.get_break(filename, lineno, temporary or False, cond,
funcname)
if temporary is None and breakpoint not in self.breakpoints:
breakpoint = self.get_break(filename, lineno, True, cond, funcname)
try:
self.breakpoints.remove(breakpoint)
if not temporary:
self._socket.send_bytes(b'Server|RmBreak|' +
pickle.dumps(breakpoint))
log.info('Breakpoint %r removed' % breakpoint)
except:
log.info('Breakpoint %r not removed: not found' % breakpoint)
def safe_repr(self, obj):
"""Like a repr but without exception"""
try:
return repr(obj)
except Exception as e:
return '??? Broken repr (%s: %s)' % (type(e).__name__, e)
def safe_better_repr(self, obj):
"""Repr with inspect links on objects"""
try:
rv = self.better_repr(obj)
except Exception:
rv = None
if rv:
return rv
self.obj_cache[id(obj)] = obj
return '<a href="%d" class="inspect">%s</a>' % (id(obj),
escape(repr(obj)))
def better_repr(self, obj):
"""Repr with html decorations"""
if isinstance(obj, dict):
if type(obj) != dict:
dict_repr = type(obj).__name__ + '({'
closer = '})'
else:
dict_repr = '{'
closer = '}'
if len(obj) > 2:
dict_repr += '<table>'
dict_repr += ''.join([
'<tr><td>' + self.safe_repr(key) + '</td><td>:</td>'
'<td>' + self.safe_better_repr(val) + '</td></tr>'
for key, val in sorted(obj.items(), key=lambda x: x[0])
])
dict_repr += '</table>'
else:
dict_repr += ', '.join([
self.safe_repr(key) + ': ' + self.safe_better_repr(val)
for key, val in sorted(obj.items(), key=lambda x: x[0])
])
dict_repr += closer
return dict_repr
if any([
isinstance(obj, list),
isinstance(obj, set),
isinstance(obj, tuple)
]):
if type(obj) == list:
iter_repr = '['
closer = ']'
elif type(obj) == set:
iter_repr = '{'
closer = '}'
elif type(obj) == tuple:
iter_repr = '('
closer = ')'
else:
iter_repr = escape(obj.__class__.__name__) + '(['
closer = '])'
splitter = ', '
if len(obj) > 2:
splitter += '\n'
iter_repr += '\n'
closer = '\n' + closer
iter_repr += splitter.join(
[self.safe_better_repr(val) for val in obj])
iter_repr += closer
return iter_repr
@contextmanager
def capture_output(self, with_hook=True):
"""Steal stream output, return them in string, restore them"""
self.hooked = ''
def display_hook(obj):
# That's some dirty hack
self.hooked += self.safe_better_repr(obj)
self.last_obj = obj
stdout, stderr = sys.stdout, sys.stderr
if with_hook:
d_hook = sys.displayhook
sys.displayhook = display_hook
sys.stdout, sys.stderr = StringIO(), StringIO()
out, err = [], []
try:
yield out, err
finally:
out.extend(sys.stdout.getvalue().splitlines()[1:])
err.extend(sys.stderr.getvalue().splitlines())
if with_hook:
sys.displayhook = d_hook
sys.stdout, sys.stderr = stdout, stderr
def dmp(self, thing):
"""Dump the content of an object in a dict for wdb.js"""
def safe_getattr(key):
"""Avoid crash on getattr"""
try:
return getattr(thing, key)
except Exception as e:
return 'Error getting attr "%s" from "%s" (%s: %s)' % (
key, thing, type(e).__name__, e)
return dict((escape(key), {
'val': self.safe_better_repr(safe_getattr(key)),
'type': type(safe_getattr(key)).__name__
}) for key in dir(thing))
def get_file(self, filename):
"""Get file source from cache"""
import linecache
return to_unicode_string(''.join(linecache.getlines(filename)),
filename)
def get_stack(self, f, t):
"""Build the stack from frame and traceback"""
stack = []
if t and t.tb_frame == f:
t = t.tb_next
while f is not None:
stack.append((f, f.f_lineno))
f = f.f_back
stack.reverse()
i = max(0, len(stack) - 1)
while t is not None:
stack.append((t.tb_frame, t.tb_lineno))
t = t.tb_next
if f is None:
i = max(0, len(stack) - 1)
return stack, i
def get_trace(self, frame, tb):
"""Get a dict of the traceback for wdb.js use"""
import linecache
frames = []
stack, _ = self.get_stack(frame, tb)
current = 0
for i, (stack_frame, lno) in enumerate(stack):
if frame == stack_frame:
current = i
break
for i, (stack_frame, lno) in enumerate(stack):
code = stack_frame.f_code
filename = code.co_filename
linecache.checkcache(filename)
line = linecache.getline(filename, lno, stack_frame.f_globals)
line = to_unicode_string(line, filename)
line = line and line.strip()
startlnos = dis.findlinestarts(code)
lastlineno = list(startlnos)[-1][1]
frames.append({
'file': filename,
'function': code.co_name,
'flno': code.co_firstlineno,
'llno': lastlineno,
'lno': lno,
'code': line,
'level': i,
'current': current == i
})
# While in exception always put the context to the top
current = len(frames) - 1
return stack, frames, current
def send(self, data):
"""Send data through websocket"""
log.debug('Sending %s' % data)
self._socket.send_bytes(data.encode('utf-8'))
def receive(self, pickled=False):
"""Receive data through websocket"""
log.debug('Receiving')
data = self._socket.recv_bytes()
if pickled:
data = pickle.loads(data)
log.debug('Got pickled %r' % data)
return data
log.debug('Got %s' % data)
return data.decode('utf-8')
def interaction(self,
frame,
tb=None,
exception='Wdb',
exception_description='Stepping',
init=None):
"""User interaction handling blocking on socket receive"""
log.info('Interaction for %r -> %r %r %r %r' %
(self.thread, frame, tb, exception, exception_description))
self.stepping = True
if not self.connected:
self.connect()
log.debug('Launching browser and wait for connection')
web_url = 'http://%s:%d/debug/session/%s' % (
WEB_SERVER or 'localhost', WEB_PORT or 1984, self.uuid)
server = WEB_SERVER or '[wdb.server]'
if WEB_PORT:
server += ':%s' % WEB_PORT
if WDB_NO_BROWSER_AUTO_OPEN:
log.warning('You can now launch your browser at '
'http://%s/debug/session/%s' % (server, self.uuid))
elif not webbrowser.open(web_url):
log.warning('Unable to open browser, '
'please go to http://%s/debug/session/%s' %
(server, self.uuid))
self.connected = True
interaction = Interaction(self,
frame,
tb,
exception,
exception_description,
init=init)
# For meta debugging purpose
self._ui = interaction
if self.begun:
# Each new state sends the trace and selects a frame
interaction.init()
else:
self.begun = True
interaction.loop()
def handle_call(self, frame, argument_list):
"""This method is called when there is the remote possibility
that we ever need to stop in this function."""
fun = frame.f_code.co_name
log.info('Calling: %r' % fun)
init = 'Echo|%s' % dump({'for': '__call__', 'val': fun})
self.interaction(frame,
init=init,
exception_description='Calling %s' % fun)
def handle_line(self, frame, arg):
"""This function is called when we stop or break at this line."""
log.info('Stopping at line %s' % pretty_frame(frame))
self.interaction(frame)
def handle_return(self, frame, return_value):
"""This function is called when a return trap is set here."""
self.obj_cache[id(return_value)] = return_value
self.extra_vars['__return__'] = return_value
fun = frame.f_code.co_name
log.info('Returning from %r with value: %r' % (fun, return_value))
init = 'Echo|%s' % dump({'for': '__return__', 'val': return_value})
self.interaction(
frame,
init=init,
exception_description='Returning from %s with value %s' %
(fun, return_value))
def handle_exception(self, frame, exc_info):
"""This function is called if an exception occurs,
but only if we are to stop at or just below this level."""
type_, value, tb = exc_info
# Python 3 is broken see http://bugs.python.org/issue17413
_value = value
if not isinstance(_value, BaseException):
_value = type_(value)
fake_exc_info = type_, _value, tb
log.error('Exception during trace', exc_info=fake_exc_info)
self.obj_cache[id(exc_info)] = exc_info
self.extra_vars['__exception__'] = exc_info
exception = type_.__name__
exception_description = str(value)
init = 'Echo|%s' % dump(
{
'for': '__exception__',
'val': escape('%s: %s') % (exception, exception_description)
})
# User exception is 4 frames away from exception
log.warning(pretty_frame(frame))
frame = frame or sys._getframe().f_back.f_back.f_back.f_back
self.interaction(frame,
tb,
exception,
exception_description,
init=init)
def breaks(self, frame, no_remove=False):
"""Return True if there's a breakpoint at frame"""
for breakpoint in set(self.breakpoints):
if breakpoint.breaks(frame):
if breakpoint.temporary and not no_remove:
self.breakpoints.remove(breakpoint)
return True
return False
def get_file_breaks(self, filename):
"""List all file `filename` breakpoints"""
return [
breakpoint for breakpoint in self.breakpoints
if breakpoint.on_file(filename)
]
def get_breaks_lno(self, filename):
"""List all line numbers that have a breakpoint"""
return list(
filter(lambda x: x is not None, [
getattr(breakpoint, 'line', None)
for breakpoint in self.breakpoints
if breakpoint.on_file(filename)
]))
def die(self):
"""Time to quit"""
log.info('Time to die')
if self.connected:
try:
self.send('Die')
except:
pass
self._socket.close()
self.pop()
#m = QueueManager(address=(HOST, PORT), authkey=b'abc')
#m.connect()
#fun = m.get_class()
#
#print(fun('comm_connect',0))
from multiprocessing.connection import Client
from array import array
address = ('localhost', 6000)
conn = Client(address, authkey=b'abc')
print (conn.recv()) # => [2.25, None, 'junk', float])
print( conn.recv_bytes() ) # => 'hello'
arr = array('i', [0, 0, 0, 0, 0])
#print (conn.recv_bytes_into(arr)) # => 8
print (arr ) # => array('i', [42, 1729, 0, 0, 0])
conn.close()
#queue.put('hello')
#print(kiwoom.aa())
# Test Code
#kiwoom = Kiwoom()
# -*- coding: utf-8 -*-
from multiprocessing.connection import Client
address = ('localhost', 8000)
for x in range(0,5):
conn = Client(address, authkey='secret password')
conn.send('这是一个美丽的世界')
print conn.recv_bytes()
conn.close()
class RemoteGdb(object):
def __init__(self, vim, host, port):
self.vim = vim
self.sock = Client((host, port))
self.request_id = 0
self.response = {}
def send_command(self, **kwargs):
self.request_id += 1
try:
self.sock.send_bytes(json.dumps(dict(dict({'dest': 'gdb'}, **kwargs), request_id=self.request_id)).encode('utf-8'))
except IOError:
print "Broken pipe encountered sending to the proxy. Terminating Exterminator."
self.quit()
return self.request_id
def handle_events(self):
if not self.sock.poll():
return
while True:
try:
c = json.loads(self.sock.recv_bytes().decode('utf-8'))
except (IOError, EOFError):
print "Lost connection to GDB"
self.quit()
return
if c['op'] == 'goto':
window = self.find_window('navigation')
if window is None:
self.claim_window('navigation')
c['filename'] = os.path.abspath(c['filename'])
self.vim.command('badd %(filename)s' % c)
self.vim.command("buffer %(filename)s" % c)
self.vim.command("%(line)s" % c)
self.vim.command("%(line)skP" % c)
self.vim.command("norm zz")
elif c['op'] == 'disp':
winnr = int(self.vim.eval("winnr()"))
window = self.find_window('display', 'bot 15new')
self.vim.command("setlocal buftype=nowrite bufhidden=wipe modifiable nobuflisted noswapfile nowrap nonumber")
contents = [ c['expr'], c['contents'] ]
self.vim.current.window.buffer[:] = contents
self.vim.command("setlocal nomodifiable")
self.vim.command("%swincmd w" % winnr)
elif c['op'] == 'response':
self.response[c['request_id']] = c
elif c['op'] == 'refresh':
GDBPlugin = self.vim.bindeval('g:NERDTreeGDBPlugin')
NERDTreeFromJSON = self.vim.Function('NERDTreeFromJSON')
NERDTreeFromJSON(c['expr'], GDBPlugin)
elif c['op'] == 'place':
c['filename'] = os.path.abspath(c['filename'])
self.vim.command("badd %s" % c['filename'].replace('$', '\\$'))
c['bufnr'] = self.vim.eval("bufnr('%(filename)s')" % c)
self.vim.command("sign place %(num)s name=%(name)s line=%(line)s buffer=%(bufnr)s" % c)
elif c['op'] == 'replace':
self.vim.command("sign place %(num)s name=%(name)s file=%(filename)s" % c)
elif c['op'] == 'unplace':
self.vim.command("sign unplace %(num)s" % c)
elif c['op'] == 'quit':
self.quit()
return
if not self.sock.poll():
return
def quit(self):
self.vim.command("sign unplace *")
winnr = int(self.vim.eval("winnr()"))
window = self.find_window('display')
if window is not None:
self.vim.command("q")
self.vim.command("%swincmd w" % winnr)
self.vim.gdb = None
try:
self.send_command(dest='proxy', op='quit')
except:
pass
def send_trap(self):
self.send_command(dest='proxy', op='trap')
def send_quit(self):
self.send_command(op='quit')
def send_continue(self):
self.send_command(op='go')
self.send_trap()
def send_exec(self, comm):
self.send_command(op='exec', comm=comm)
self.send_trap()
def disable_break(self, filename, line):
self.send_command(op='disable', loc=(filename, line))
self.send_trap()
def toggle_break(self, filename, line):
self.send_command(op='toggle', loc=(filename, line))
self.send_trap()
def continue_until(self, filename, line):
self.send_command(op='until', loc=(filename, line))
self.send_trap()
def eval_expr(self, expr):
request_id = self.send_command(op='eval', expr=str(expr))
return self.get_response(request_id)
def get_response(self, request_id):
start = time.time()
while request_id not in self.response:
self.send_trap()
try:
select.select([self.sock], [], [], 1)
self.handle_events()
except select.error:
pass
if time.time() - start > 5:
return None
response = self.response[request_id]
del self.response[request_id]
return response
def fetch_children(self, expr):
try:
v = self.eval_expr(expr)
return [ v['expr'], v['contents'] ]
except:
import traceback
lines = traceback.format_exc().split('\n')
p = len("%d" % len(lines))
return [ "Python client error", { "%0*d: %s" % (p, i, line): {} for i, line in enumerate(lines) } ]
def track_expr(self, expr):
if expr is not None:
GDBPlugin = self.vim.bindeval('g:NERDTreeGDBPlugin')
NERDTreeFromJSON = self.vim.Function('NERDTreeFromJSON')
NERDTreeFromJSON(expr, GDBPlugin)
self.send_command(op='track', expr=expr)
def show_backtrace(self):
request_id = self.send_command(op='bt')
response = self.get_response(request_id)
my_llist = self.vim.List([{ 'filename': filename, 'lnum': line, 'text': contents } for filename, line, contents in response['bt'] ])
setloclist = self.vim.Function('setloclist')
setloclist(0, my_llist)
self.vim.command('lopen')
self.vim.command('GdbBindBufferToFrame')
def claim_window(self, window_name):
self.vim.command('let w:mandrews_output_window = "%s"' % window_name)
def find_window(self, window_name, new_command=None):
winnr = int(self.vim.eval("winnr()"))
while True:
if int(self.vim.eval("exists('w:mandrews_output_window')")) > 0:
if str(self.vim.eval("w:mandrews_output_window")) == window_name:
break
self.vim.command("wincmd w")
if winnr == int(self.vim.eval("winnr()")):
if new_command is not None:
self.vim.command(new_command)
self.claim_window(window_name)
break
return
return self.vim.current.window
def client(msg):
conn = Client(address, authkey=b'mypassword')
conn.send(msg)
print(conn.recv())
print(conn.recv_bytes())
conn.close()
#!/usr/bin/env python
import sys
import os
import socket
from multiprocessing.connection import Client
if len(sys.argv) < 2:
print "You must pass a parameter. (open, close, trigger, away, home, state)"
else:
address = ('192.168.86.9', 6000)
conn = Client(address)
conn.send_bytes(sys.argv[1])
print conn.recv_bytes()
conn.close()
def work(self):
conn = Client(self.address, authkey=self.password)
print conn.recv_bytes()
conn.close()
from multiprocessing.connection import Client
conn = Client(address=("", 6000))
data = conn.recv_bytes()
print data
obj = conn.recv()
print obj
conn.close()
class MicroControlClient:
authkey = b'barracuda'
server = None # subprocess.Popen object
conn = None
lock = threading.Lock()
def __init__(self, port=0):
if port == 0:
port = get_free_port()
self.address = ('localhost', port)
#self.start_server()
def start_connection(self):
time.sleep(1)
with self.lock:
self.conn = Client(self.address, authkey=b'barracuda')
def send_command(self, cmd):
with self.lock:
self.conn.send_bytes(pickle.dumps(cmd, 2))
def read_response(self):
with self.lock:
time.sleep(WAIT_TIME)
response = self.conn.recv_bytes()
response = pickle.loads(response, encoding='bytes')
time.sleep(WAIT_TIME)
return response
def close_server(self):
with self.lock:
self.conn.send_bytes(pickle.dumps('close',2))
self.conn.close()
self.server.terminate()
def start_server(self):
"""
Opens the python2 subprocess that will run the server and micromanager code.
:return:
"""
print(SERVER_FILE)
with self.lock:
self.server = subprocess.Popen([PYTHON2_PATH,
SERVER_FILE, '{}'.format(self.address[1])], stdout=subprocess.PIPE, stdin=subprocess.PIPE)
time.sleep(1)
def open(self):
""" Opens the Python 2 server and starts the connection"""
if self.conn is None:
self.start_server()
self.start_connection()
elif self.conn.closed:
self.start_server()
self.start_connection()
return True
def close(self):
self.close_server()
return True
@staticmethod
def ok_check(response,msg):
""" Checks the response if it was recieved OK."""
if str(response.decode())!= 'Ok':
logging.error('{}. Recieved: {}'.format(msg,response))
return False
return True
def _get_conn(self):
conn_in = Client(self.address, authkey=b'testingToms')
if self.strat == 'pipe':
return conn_in.recv()
buf = io.BytesIO(conn_in.recv_bytes())
return pickle.load(buf)
