def _printheader(self, log):
"""Prints header to log file; inspired by that in GPAW."""
log(logo)
log('Amp: Atomistic Machine-learning Package')
log('Developed by Andrew Peterson, Alireza Khorshidi, and others,')
log('Brown University.')
log(' PI Website: http://brown.edu/go/catalyst')
log(' Official repository: http://bitbucket.org/andrewpeterson/amp')
log(' Official documentation: http://amp.readthedocs.org/')
log(' Citation:')
log(' Khorshidi & Peterson, Computer Physics Communications')
log(' doi:10.1016/j.cpc.2016.05.010 (2016)')
log('=' * 70)
log('User: %s' % getuser())
log('Hostname: %s' % gethostname())
log('Date: %s' % now(with_utc=True))
uname = platform.uname()
log('Architecture: %s' % uname[4])
log('PID: %s' % os.getpid())
log('Amp version: %s' % 'NOT NUMBERED YET.') # FIXME/ap. Look at GPAW
ampdirectory = os.path.dirname(os.path.abspath(__file__))
log('Amp directory: %s' % ampdirectory)
commithash, commitdate = get_git_commit(ampdirectory)
log(' Last commit: %s' % commithash)
log(' Last commit date: %s' % commitdate)
log('Python: v{0}.{1}.{2}: %s'.format(*sys.version_info[:3]) %
sys.executable)
log('ASE v%s: %s' % (aseversion, os.path.dirname(ase.__file__)))
log('NumPy v%s: %s' %
(np.version.version, os.path.dirname(np.__file__)))
# SciPy is not a strict dependency.
try:
import scipy
log('SciPy v%s: %s' %
(scipy.version.version, os.path.dirname(scipy.__file__)))
except ImportError:
log('SciPy: not available')
# ZMQ an pxssh are only necessary for parallel calculations.
try:
import zmq
log('ZMQ/PyZMQ v%s/v%s: %s' %
(zmq.zmq_version(), zmq.pyzmq_version(),
os.path.dirname(zmq.__file__)))
except ImportError:
log('ZMQ: not available')
try:
import pxssh
log('pxssh: %s' % os.path.dirname(pxssh.__file__))
except ImportError:
log('pxssh: Not available from pxssh.')
try:
from pexpect import pxssh
except ImportError:
log('pxssh: Not available from pexpect.')
else:
import pexpect
log('pxssh (via pexpect v%s): %s' %
(pexpect.__version__, pxssh.__file__))
log('=' * 70)
def __init__(self, args):
super().__init__()
sys.path.append(args.run_script_dir)
self.logger = set_logger(colored('VENTILATOR', 'red'),
verbose=args.verbose,
logfile=args.logger)
self.logger.info('run_script_dir: %s' % args.run_script_dir)
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(
8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
self.args = args
self.args.device_map = self.__check_arg_device_map()
self.status_args = {
k: (v if k != 'pooling_strategy' else v.value)
for k, v in sorted(vars(args).items())
}
self.status_static = {
'tensorflow_version': _tf_ver_,
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.is_ready = threading.Event()
self.__set_zmq_socket_tmp_dir()
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'))
self.args = args
# ZeroMQ server configuration
self.num_worker = args.num_worker # number of Workers
# restrict number of workers for temporaly
self.num_concurrent_socket = max(16, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
# project configuration
self.model_dir = args.model_dir # alpaca_model per project
self.model = None # pass this model to every sink and worker!!!!
# learning initial configuration
self.batch_size = args.batch_size
self.epoch = args.epoch
self.status_args = {k: v for k, v in sorted(vars(args).items())}
self.status_static = {
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.logger.info('Initialize the alpaca_model... could take a while...')
self.is_ready = threading.Event()
def enable_monitor(self, events=None):
# The standard approach of binding and then connecting does not
# work in this specific case. The event loop does not properly
# detect messages on the inproc transport which means that event
# messages get missed.
# pyzmq's 'get_monitor_socket' method can't be used because this
# performs the actions in the wrong order for use with an event
# loop.
# For more information on this issue see:
# http://lists.zeromq.org/pipermail/zeromq-dev/2015-July/029181.html
if (zmq.zmq_version_info() < (4, ) or zmq.pyzmq_version_info() < (
14,
4,
)):
raise NotImplementedError(
"Socket monitor requires libzmq >= 4 and pyzmq >= 14.4, "
"have libzmq:{}, pyzmq:{}".format(zmq.zmq_version(),
zmq.pyzmq_version()))
if self._monitor is None:
addr = "inproc://monitor.s-{}".format(self._zmq_sock.FD)
events = events or zmq.EVENT_ALL
_, self._monitor = yield from create_zmq_connection(
lambda: _ZmqEventProtocol(self._loop, self._protocol),
zmq.PAIR,
connect=addr,
loop=self._loop)
# bind must come after connect
self._zmq_sock.monitor(addr, events)
yield from self._monitor.wait_ready
def print_info():
log.info("Python version: %s, %s", '.'.join(
(str(e) for e in sys.version_info)), sys.executable)
log.info("zeromq version: %s", zmq.zmq_version())
log.info("pyzmq version: %s", zmq.pyzmq_version())
log.info("track version: %s", str(track_base.version_info))
def __init__(self, address='*', port1='5566', port2='5567'):
print("Current libzmq version is %s" % zmq.zmq_version())
print("Current pyzmq version is %s" % zmq.pyzmq_version())
self.context = Context.instance()
self.url1 = "tcp://{}:{}".format(address, port1)
self.url2 = "tcp://{}:{}".format(address, port2)
self.xpub_xsub_proxy()
def __init__(self,args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR','magenta'),args.verbose)
self.max_seq_len = args.max_seq_len
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(8,args.num_worker * 2)
self.port = args.port
self.args = args
self.status_args = {k:(v if k != 'pooling_strategy' else v.value) for k,v in sorted(vars(args).items())}
self.status_static = {
'tensorflow_version':_tf_ver_,
'python_version':sys.version,
'server_version':__version__,
'pyzmq_version':zmq.pyzmq_version(),
'zmq_version':zmq.zmq_version(),
'server_start_time':str(datetime.now())
}
self.processes = []
# 如果BERT model path 不是空的，那么就启动bert模型
if args.mode == 'BERT':
self.logger.info('freeze,optimize and export graph,could take a while...')
with Pool(processes=1) as pool:
# optimize the graph, must be done in another process
from .graph import optimize_bert_graph
self.graph_path = pool.apply(optimize_bert_graph,(self.args,))
if self.graph_path:
self.logger.info('optimized graph is stored at:%s' % self.graph_path)
else:
raise FileNotFoundError('graph optimization fails and returns empty result')
elif args.mode == "NER":
self.logger.info('loading ner model,could take a while..')
with Pool(processes=1) as pool:
# optimize the graph, must be done in another process
from .graph import optimize_ner_model
num_labels,label2id,id2label = init_predict_var(self.args.model_dir)
self.num_labels = num_labels + 1
self.id2label =id2label
self.graph_path = pool.apply(optimize_ner_model,(self.args,num_labels))
if self.graph_path:
self.logger.info('optimized graph is stored at: %s' % self.graph_path)
else:
raise FileNotFoundError("graph optimization fails and returns empty result")
elif args.mode == 'CLASS':
self.logger.infor("loading classification predict ,could take a while ...")
with Pool(processes=1) as pool:
# optimize the graph, must be done in another process
from .graph import optimize_class_model
num_labels,label2id,id2label=init_predict_var(self.args.model_dir)
self.num_labels = num_labels
self.id2label = id2label
self.logger.info('contain %d labels:%s' % (num_labels,str(id2label.values())))
self.graph_path = pool.apply(optimize_class_model,(self.args,num_labels))
if self.graph_path:
self.logger.info('optimized graph is stored at: %s' % self.graph_path)
else:
raise FileNotFoundError("graph optimization fails and returns empty result")
else:
raise ValueError("args model not special")
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'),
args.verbose)
self.model_dir = args.model_dir
self.max_seq_len = args.max_seq_len
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.port = args.port
self.args = args
self.status_args = {
k: (v if k != 'pooling_strategy' else v.value)
for k, v in sorted(vars(args).items())
}
self.status_static = {
'tensorflow_version': _tf_ver_,
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.logger.info(
'freeze, optimize and export graph, could take a while...')
with Pool(processes=1) as pool:
# optimize the graph, must be done in another process
from .graph import optimize_graph
self.graph_path = pool.apply(optimize_graph, (self.args, ))
self.logger.info('optimized graph is stored at: %s' % self.graph_path)
def run(self):
"""Run the test suite, with nose, or unittest if nose is unavailable"""
# crude check for inplace build:
try:
import zmq
except ImportError:
print_exc()
fatal(
"\n ".join(
[
"Could not import zmq!",
"You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",
"If you did build pyzmq in-place, then this is a real error.",
]
)
)
sys.exit(1)
info("Testing pyzmq-%s with libzmq-%s" % (zmq.pyzmq_version(), zmq.zmq_version()))
if nose is None:
warn("nose unavailable, falling back on unittest. Skipped tests will appear as ERRORs.")
return self.run_unittest()
else:
return self.run_nose()
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'), args.verbose)
self.model_path = args.model_path # Location where BERT model is stored
self.max_seq_len = args.max_seq_len # Model related argument
self.num_worker = args.num_worker # Number of server workers
self.max_batch_size = args.max_batch_size # Maximum batch size
self.num_concurrent_socket = max(8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port # Port of ventilator PULLING users queries
self.args = args
self.status_args = {k: (v if k != 'pooling_strategy' else v.value) for k, v in sorted(vars(args).items())}
self.status_static = {
'python_version' : sys.version,
'server_version' : __version__,
'pyzmq_version' : zmq.pyzmq_version(),
'zmq_version' : zmq.zmq_version(),
'server_start_time' : str(datetime.now()),
}
self.processes = []
self.logger.info('freeze, optimize and export graph, could take a while...')
self.model_params = self.load_model(args.model_path)
self.type_remap = json.load(open(args.type_remap_json))
self.type2id = json.load(open(args.type2id_json))
self.umls2type = pickle.load(open(args.umls2type_file, 'rb'))
self.is_ready = threading.Event()
def run(self):
"""Run the test suite, with nose, or unittest if nose is unavailable"""
# crude check for inplace build:
try:
import zmq
except ImportError:
print_exc()
fatal('\n '.join([
"Could not import zmq!",
"You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",
"If you did build pyzmq in-place, then this is a real error."
]))
sys.exit(1)
info("Testing pyzmq-%s with libzmq-%s" %
(zmq.pyzmq_version(), zmq.zmq_version()))
try:
import nose
except ImportError:
warn(
"nose unavailable, falling back on unittest. Skipped tests will appear as ERRORs."
)
return self.run_unittest()
else:
return self.run_nose()
def main():
# Parse command line args.
parser = argparse.ArgumentParser(description='Calico ACL Manager')
parser.add_argument('-c', '--config-file', dest='config_file')
args = parser.parse_args()
# Read config file.
config = ConfigParser.ConfigParser()
config.read(args.config_file or 'acl_manager.cfg')
plugin_address = config.get('global', 'PluginAddress')
log_file_path = config.get('log', 'LogFilePath')
# Configure logging.
common.mkdir_p(os.path.dirname(log_file_path))
logging.basicConfig(filename=log_file_path, level=logging.DEBUG)
# Create ZeroMQ context.
context = zmq.Context()
log.info("pyzmq version is %s" % zmq.pyzmq_version())
# Create and start components.
acl_store = ACLStore()
network_store = NetworkStore()
publisher = ACLPublisher(context, acl_store)
acl_store.start(publisher)
processor = RuleProcessor(acl_store, network_store)
network_store.add_processor(processor)
subscriber = NetworkSubscriber(context, network_store, plugin_address)
def enable_monitor(self, events=None):
# The standard approach of binding and then connecting does not
# work in this specific case. The event loop does not properly
# detect messages on the inproc transport which means that event
# messages get missed.
# pyzmq's 'get_monitor_socket' method can't be used because this
# performs the actions in the wrong order for use with an event
# loop.
# For more information on this issue see:
# http://lists.zeromq.org/pipermail/zeromq-dev/2015-July/029181.html
if (zmq.zmq_version_info() < (4,) or
zmq.pyzmq_version_info() < (14, 4,)):
raise NotImplementedError(
"Socket monitor requires libzmq >= 4 and pyzmq >= 14.4, "
"have libzmq:{}, pyzmq:{}".format(
zmq.zmq_version(), zmq.pyzmq_version()))
if self._monitor is None:
addr = "inproc://monitor.s-{}".format(self._zmq_sock.FD)
events = events or zmq.EVENT_ALL
_, self._monitor = yield from create_zmq_connection(
lambda: _ZmqEventProtocol(self._loop, self._protocol),
zmq.PAIR, connect=addr, loop=self._loop)
# bind must come after connect
self._zmq_sock.monitor(addr, events)
yield from self._monitor.wait_ready
def __init__(self, port, require_settings=False):
""" Constructor
- port : the 0mq communication port
"""
# Setup the 0mq channel.
self.__context = zmq.Context()
self.__socket = self.__context.socket(zmq.PAIR)
print "{}: (pyzmq version: {}) started on: tcp://127.0.0.1:{}"\
.format(self.__class__.__name__, zmq.pyzmq_version(), port)
self.__socket.connect("{}:{}".format(
BaseService.__HOST_ADDRESS, port))
# Initialize state.
self.__enabled = False
self.__shutting_down = False
self._state = None
self._update_state()
# Setup service if possible.
if not require_settings:
self._setup()
self.__initialized = True
else:
self.__initialized = False
# Setup setting handling.
self.__setting_store = SettingsStore()
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'), args.verbose)
self.model_dir = args.model_dir
self.max_seq_len = args.max_seq_len
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
self.args = args
self.status_args = {k: (v if k != 'pooling_strategy' else v.value) for k, v in sorted(vars(args).items())}
self.status_static = {
'tensorflow_version': _tf_ver_,
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.logger.info('freeze, optimize and export graph, could take a while...')
with Pool(processes=1) as pool:
# optimize the graph, must be done in another process
from .graph import optimize_graph
self.graph_path, self.bert_config = pool.apply(optimize_graph, (self.args,))
# from .graph import optimize_graph
# self.graph_path = optimize_graph(self.args, self.logger)
if self.graph_path:
self.logger.info('optimized graph is stored at: %s' % self.graph_path)
else:
raise FileNotFoundError('graph optimization fails and returns empty result')
self.is_ready = threading.Event()
def __init__(self):
Tool.__init__(self)
# * Initialize ZMQ context and open subscriber, publisher sockets
self.logger.debug("ZMQ version: {}, PyZMQ version: {}".format(zmq.zmq_version(), zmq.pyzmq_version()))
# ** Context
self.zmqContext = zmq.Context()
# ** Subscriber
self.subSocket = self.zmqContext.socket(zmq.SUB)
self.subSocket.connect(self.sub_address)
time.sleep(0.005) # mandatory sleep for ZMQ backend
self.logger.debug("[sub] Connected to {}".format(self.sub_address))
# ** Subscriber topics for input messages
self.subSocket.setsockopt(zmq.SUBSCRIBE, self.sub_topic)
self.subSocket.setsockopt(zmq.LINGER, self.sub_socket_linger)
self.logger.debug("[sub]Subscribed to topic \"{}\"".format(self.sub_topic))
time.sleep(0.005) # mandatory sleep for ZMQ backend
# ** Publisher
self.pubSocket = self.zmqContext.socket(zmq.PUB)
self.pubSocket.bind(self.pub_address)
time.sleep(0.005) # mandatory sleep for ZMQ backend
self.logger.debug("[pub] Bound to {}".format(self.pub_address))
# * Initialize other members
self.valid = False
self.buttons = [0, 0] # primary, secondary
self.transform = hm.translation(hm.identity(), self.position_offset)
#self.position = self.position_offset
self.loop = True # TODO ensure this is properly shared across threads
# * Start sensing loop
self.senseThread = Thread(target=self.senseLoop)
self.senseThread.daemon = True # to prevent indefinite wait on recv()
self.senseThread.start()
time.sleep(0.005) # sleep to allow child thread to run
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'),
args.verbose)
self.max_seq_len = args.max_seq_len
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(
8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
self.args = args
self.status_args = {
k: (v if k != 'pooling_strategy' else v.value)
for k, v in sorted(vars(args).items())
}
self.status_static = {
'tensorflow_version': _tf_ver_,
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'), args.verbose)
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
self.args = args
self.status_args = {k: (v if k != 'pooling_strategy' else v.value) for k, v in sorted(vars(args).items())}
self.status_static = {
'tensorflow_version': _tf_ver_,
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.graph_path, self.config = self.load_graph_config()
if self.graph_path:
self.logger.info('optimized graph is stored at: %s' % self.graph_path)
else:
raise FileNotFoundError('graph optimization fails and returns empty result')
self.is_ready = threading.Event()
def __init__(self, args):
threading.Thread.__init__(self)
self.logger = get_logger()
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(
8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
self.args = args
self.status_args = {
k: (v if k != 'pooling_strategy' else v.value)
for k, v in sorted(vars(args).items())
}
self.status_static = {
'tensorflow_version': _tf_ver_,
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.num_labels = 0
self.id2theme = dict()
self.graph_path = None
self.load_theme_model()
def test_pyzmq_version(self):
vs = zmq.pyzmq_version()
vs2 = zmq.__version__
self.assertTrue(isinstance(vs, str))
if zmq.__revision__:
self.assertEquals(vs, '@'.join(vs2, zmq.__revision__))
else:
self.assertEquals(vs, vs2)
def print_info():
log.info("Python version: %s, %s",
'.'.join((str(e) for e in sys.version_info)),
sys.executable)
log.info("zeromq version: %s", zmq.zmq_version())
log.info("pyzmq version: %s", zmq.pyzmq_version())
log.info("track version: %s", str(track_base.version_info))
def test_pyzmq_version(self):
vs = zmq.pyzmq_version()
vs2 = zmq.__version__
self.assertTrue(isinstance(vs, str))
if zmq.__revision__:
self.assertEquals(vs, '@'.join(vs2, zmq.__revision__))
else:
self.assertEquals(vs, vs2)
def test_pyzmq_version(self):
vs = zmq.pyzmq_version()
vs2 = zmq.__version__
self.assertTrue(isinstance(vs, str))
if zmq.__revision__:
self.assertEqual(vs, '@'.join(vs2, zmq.__revision__))
else:
self.assertEqual(vs, vs2)
if version.VERSION_EXTRA:
self.assertTrue(version.VERSION_EXTRA in vs)
self.assertTrue(version.VERSION_EXTRA in vs2)
def test_pyzmq_version(self):
vs = zmq.pyzmq_version()
vs2 = zmq.__version__
self.assertTrue(isinstance(vs, str))
if zmq.__revision__:
self.assertEqual(vs, '@'.join(vs2, zmq.__revision__))
else:
self.assertEqual(vs, vs2)
if version.VERSION_EXTRA:
self.assertTrue(version.VERSION_EXTRA in vs)
self.assertTrue(version.VERSION_EXTRA in vs2)
def __init__(self, address='127.0.0.1', port='5566'):
print("Current libzmq version is %s" % zmq.zmq_version())
print("Current pyzmq version is %s" % zmq.pyzmq_version())
if len(sys.argv) > 1:
address = sys.argv[1]
if len(sys.argv) > 2:
port = sys.argv[2]
self.context = Context.instance()
self.url = "tcp://{}:{}".format(address, port)
self.hostname = socket.gethostname()
self.pub_ep_time()
def main():
print("worker-dl")
print("pyzmq version:", zmq.pyzmq_version())
if len(sys.argv) != 4:
print('The correct syntax is %s address port_pull port_push' %
sys.argv[0])
sys.exit(1)
_, address, port_pull, port_push = sys.argv
start(address, port_pull, port_push)
def log_versions(logger):
logger.info(
'Versions:\n'
' PyZMQ: %s\n'
' libzmq: %s\n'
' Tornado: %s\n'
' SockJS-Tornado: Not Available\n' # TODO find the verison
' SockJS-ZMQProxy: %s\n',
zmq.pyzmq_version(),
zmq.zmq_version(),
tornado_version,
version
)
def zmq_init():
global PORT
logger.info("zmq: " + zmq.pyzmq_version())
if len(sys.argv) > 1:
PORT = sys.argv[1]
int(PORT)
context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://*:%s" % PORT)
logger.info("bind: " + PORT)
return socket
def run(self):
"""Run the test suite with py.test"""
# crude check for inplace build:
try:
import zmq
except ImportError:
print_exc()
fatal('\n '.join(["Could not import zmq!",
"You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",
"If you did build pyzmq in-place, then this is a real error."]))
sys.exit(1)
info("Testing pyzmq-%s with libzmq-%s" % (zmq.pyzmq_version(), zmq.zmq_version()))
p = Popen([sys.executable, '-m', 'pytest', '-v', os.path.join('zmq', 'tests')])
p.wait()
sys.exit(p.returncode)
def run(self):
"""Run the test suite with py.test"""
# crude check for inplace build:
try:
import zmq
except ImportError:
print_exc()
fatal('\n '.join(["Could not import zmq!",
"You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",
"If you did build pyzmq in-place, then this is a real error."]))
sys.exit(1)
info("Testing pyzmq-%s with libzmq-%s" % (zmq.pyzmq_version(), zmq.zmq_version()))
p = Popen([sys.executable, '-m', 'pytest', '-v', os.path.join('zmq', 'tests')])
p.wait()
sys.exit(p.returncode)
def level_1(info):
# print header (some general info)
info += ["name: %s" % self.job_name]
info += ["version: %s" % getattr(self, '__version__', '')]
info += ["service: %s" % self.service_name]
info += ["pid: %i" % os.getpid()]
info += ["started: %s" % strftime(getattr(self, 'started', ''))]
info += ["status: %s" % getattr(self, 'status', '')]
info += ["time-consumed: %s" % ' '.join(map(str, os.times()[:4]))]
info += ["info-period: %s" % self.stats_period]
info += ["info-written: %s" % strftime(time.time())]
info += ["platform: %s" % platform.platform()]
info += ["python: %s" % platform.python_version()]
info += ["skytools: %s" % skytools.__version__]
info += ["libzmq: %s" % zmq.zmq_version()]
info += ["pyzmq: %s" % zmq.pyzmq_version()]
info += [""]
def level_1(info):
# print header (some general info)
info += ["name: %s" % self.job_name]
info += ["version: %s" % getattr(self, "__version__", "")]
info += ["service: %s" % self.service_name]
info += ["pid: %i" % os.getpid()]
info += ["started: %s" % strftime(getattr(self, "started", ""))]
info += ["status: %s" % getattr(self, "status", "")]
info += ["time-consumed: %s" % " ".join(map(str, os.times()[:4]))]
info += ["info-period: %s" % self.stats_period]
info += ["info-written: %s" % strftime(time.time())]
info += ["platform: %s" % platform.platform()]
info += ["python: %s" % platform.python_version()]
info += ["skytools: %s" % skytools.__version__]
info += ["libzmq: %s" % zmq.zmq_version()]
info += ["pyzmq: %s" % zmq.pyzmq_version()]
info += [""]
def __init__(self, providerLocation):
self._providerLocation = providerLocation
self._context = zmq.Context()
self._socket = self._context.socket(zmq.REQ)
self._socket.connect(providerLocation)
self._socket.setsockopt(zmq.LINGER, 0)
self._lock = threading.Lock()
self._closed = False
self._activeAllocations = []
self.call("handshake", versionInfo=dict(
ASSET_VERSION=api.VERSION,
ZERO_MQ=dict(
PYZMQ_VERSION=zmq.pyzmq_version(),
VERSION=zmq.VERSION,
VERSION_MAJOR=zmq.VERSION_MAJOR,
VERSION_MINOR=zmq.VERSION_MINOR,
VERSION_PATCH=zmq.VERSION_PATCH)))
self._connectionToProviderInterrupted = suicide.killSelf
self._heartbeat = heartbeat.HeartBeat(self)
def __init__(self, port=5558, port_out=5559, n_workers=1, verbose=False,
max_batch_size=32, task='coref'):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'), verbose)
self.port = port
self.port_out = port_out
self.processes = []
self.is_ready = threading.Event()
self.n_workers = n_workers
self.n_concurrent_sockets = max(8, n_workers * 2)
self.max_batch_size = max_batch_size
self.status_static = {
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.Worker = WorkerRegistry[task]
def log_sysinfo(app: Flask, config: Config):
app.logger.info("ZMQ:")
app.logger.info(" zmq version: %s", zmq.zmq_version())
app.logger.info(" pyzmq version: %s", zmq.pyzmq_version())
app.logger.info(" zmq includes: %s", zmq.get_includes())
app.logger.info(" zmq library dirs: %s", zmq.get_library_dirs())
app.logger.info(" has: %s", [c for c in ZMQ_CAPABILITIES if zmq.has(c)])
app.logger.info("socket:")
app.logger.info(" fqdn: %s", socket.getfqdn())
app.logger.info(" has_ipv6: %s", socket.has_ipv6)
app.logger.info(" hostname: %s", socket.gethostname())
app.logger.info(" interfaces: %s", [i[1] for i in socket.if_nameindex()])
app.logger.info("os:")
app.logger.info(" ctermid: %s", os.ctermid())
app.logger.info(" cwd: %s", os.getcwd())
app.logger.info(" groups: %s", os.getgroups())
app.logger.info(" pgid: %d", os.getpgid(0))
app.logger.info(" pgrp: %d", os.getpgrp())
app.logger.info(" pid: %d", os.getpid())
app.logger.info(" ppid: %d", os.getppid())
app.logger.info(" priority_process: %d",
os.getpriority(os.PRIO_PROCESS, 0))
app.logger.info(" priority_pgrp: %d", os.getpriority(os.PRIO_PGRP, 0))
app.logger.info(" priority_user: %d", os.getpriority(os.PRIO_USER, 0))
app.logger.info(" resuid: ruid=%d, euid=%d, suid=%d", *os.getresuid())
app.logger.info(" resgid: rgid=%d, egid=%d, sgid=%d", *os.getresgid())
app.logger.info(" sid: %d", os.getsid(0))
app.logger.info(" supports_bytes_environ: %s", os.supports_bytes_environ)
app.logger.info(" uname: %s", os.uname())
app.logger.info(" cpu_count: %d", os.cpu_count())
app.logger.info("platform:")
app.logger.info(" %s", platform.platform())
app.logger.info(" python_build: %s", platform.python_build())
app.logger.info(" python_compiler: %s", platform.python_compiler())
app.logger.info(" python_branch: %s", platform.python_branch())
app.logger.info(" python_implementation: %s",
platform.python_implementation())
app.logger.info(" python_revision: %s", platform.python_revision())
app.logger.info(" python_version: %s", platform.python_version())
app.logger.info("getpass:"******" user: %s", getpass.getuser())
def __init__(self, args, hardprocesser=WKRHardWorker):
super().__init__()
self.hardprocessor_skeleton = hardprocesser
if not issubclass(self.hardprocessor_skeleton, WKRHardWorker):
raise AssertionError(
'hardprocesser must inherit from class WKRHardWorker')
self.model_dir = args.model_dir
self.num_worker = args.num_worker
self.device_map = args.device_map
self.gpu_memory_fraction = args.gpu_memory_fraction
self.all_cpu = args.cpu
self.num_concurrent_postsocket = max(8, args.num_worker * 2)
self.batch_size = args.batch_size
self.total_concurrent_socket = self.num_concurrent_postsocket
self.port = args.port
self.args = args
self.transfer_protocol = args.protocol
self.status_args = {k: v for k, v in sorted(vars(args).items())}
self.status_static = {
'python_version': sys.version,
'server_version': __version__,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.logdir = args.log_dir
self.logger = set_logger(colored('NAVIGATOR', 'red'),
logger_dir=self.logdir,
verbose=args.verbose)
self.logger.info(
'freeze, optimize and export graph, could take a while...')
self.is_ready = threading.Event()
def _get_master_uri(master_ip, master_port, source_ip=None, source_port=None):
'''
Return the ZeroMQ URI to connect the Minion to the Master.
It supports different source IP / port, given the ZeroMQ syntax:
// Connecting using a IP address and bind to an IP address
rc = zmq_connect(socket, "tcp://192.168.1.17:5555;192.168.1.1:5555"); assert (rc == 0);
Source: http://api.zeromq.org/4-1:zmq-tcp
'''
libzmq_version_tup = tuple(map(int, zmq.zmq_version().split('.')))
pyzmq_version_tup = tuple(map(int, zmq.pyzmq_version().split('.')))
if libzmq_version_tup >= (4, 1, 6) and pyzmq_version_tup >= (16, 0, 1):
# The source:port syntax for ZeroMQ has been added in libzmq 4.1.6
# which is included in the pyzmq wheels starting with 16.0.1.
if source_ip or source_port:
if source_ip and source_port:
return 'tcp://{source_ip}:{source_port};{master_ip}:{master_port}'.format(
source_ip=source_ip,
source_port=source_port,
master_ip=master_ip,
master_port=master_port)
elif source_ip and not source_port:
return 'tcp://{source_ip}:0;{master_ip}:{master_port}'.format(
source_ip=source_ip,
master_ip=master_ip,
master_port=master_port)
elif not source_ip and source_port:
return 'tcp://0.0.0.0:{source_port};{master_ip}:{master_port}'.format(
source_port=source_port,
master_ip=master_ip,
master_port=master_port)
if source_ip or source_port:
log.warning(
'Unable to connect to the Master using a specific source IP / port'
)
log.warning(
'Consider upgrading to pyzmq >= 16.0.1 and libzmq >= 4.1.6')
return 'tcp://{master_ip}:{master_port}'.format(master_ip=master_ip,
master_port=master_port)
def __init__(self, args):
super().__init__()
self.logger = set_logger(colored('VENTILATOR', 'magenta'), args.verbose)
# self.model_dir = args.model_dir
# self.max_seq_len = args.max_seq_len
self.num_worker = args.num_worker
self.max_batch_size = args.max_batch_size
self.num_concurrent_socket = max(8, args.num_worker * 2) # optimize concurrency for multi-clients
self.port = args.port
self.args = args
self.status_args = {k: (v if k != 'pooling_strategy' else v.value) for k, v in sorted(vars(args).items())}
self.status_static = {
'python_version': sys.version,
'pyzmq_version': zmq.pyzmq_version(),
'zmq_version': zmq.zmq_version(),
'server_start_time': str(datetime.now()),
}
self.processes = []
self.logger.info('freeze, optimize and export graph, could take a while...')
self.is_ready = threading.Event()
def directory_server(store: DirectoryServerStore, zmq_context: Context):
# pylint: disable=no-member # These zmq.ROUTER and zmq.PUB must be actually exists
print("Starting on libzmq {} with PyZMQ {}".format(zmq.zmq_version(),
zmq.pyzmq_version()))
entrypoint: Socket = zmq_context.socket(zmq.ROUTER)
entrypoint.bind("tcp://127.0.0.1:5350") # This is just a PROTOTYPE!
pub_file_changes: Socket = zmq_context.socket(zmq.PUB)
pub_file_changes.bind("tcp://127.0.0.1:5351")
poller = Poller()
poller.register(entrypoint, flags=zmq.POLLIN)
print(
"Directory server is started on 127.0.0.1:5350 (commands) and 127.0.0.1:5351 (file_changes_push)"
)
while True:
events: List[Tuple[Socket, int]] = poller.poll()
for socket, _ in events:
frames: List[Frame] = socket.recv_multipart(copy=False)
id_frame: Frame = frames.pop(0)
empty_frame: Frame = frames.pop(0)
assert (len(empty_frame.bytes) == 0)
command_frame: Frame = frames.pop(0)
command = str(command_frame.bytes, encoding='utf8')
if command == 'ping':
ping_handler(store, socket, frames, id_frame)
elif command == 'device.cast_address':
casting_address_handler(store, socket, frames, id_frame)
elif command == 'device.get_addresses':
get_addresses_handler(store, socket, frames, id_frame)
elif command == 'fs.list':
file_list_handler(store, socket, id_frame)
elif command == 'fs.declare':
file_declare_handler(store, socket, frames, id_frame,
pub_file_changes)
elif command == 'fs.disown':
file_disown_handler(store, socket, frames, id_frame,
pub_file_changes)
elif command == 'fs.get':
file_get_handler(store, socket, frames, id_frame)
def __init__(self):
Tool.__init__(self)
# * Initialize ZMQ context and open subscriber, publisher sockets
self.logger.debug("ZMQ version: {}, PyZMQ version: {}".format(
zmq.zmq_version(), zmq.pyzmq_version()))
# ** Context
self.zmqContext = zmq.Context()
# ** Subscriber
self.subSocket = self.zmqContext.socket(zmq.SUB)
self.subSocket.connect(self.sub_address)
time.sleep(0.005) # mandatory sleep for ZMQ backend
self.logger.debug("[sub] Connected to {}".format(self.sub_address))
# ** Subscriber topics for input messages
self.subSocket.setsockopt(zmq.SUBSCRIBE, self.sub_topic)
self.subSocket.setsockopt(zmq.LINGER, self.sub_socket_linger)
self.logger.debug("[sub]Subscribed to topic \"{}\"".format(
self.sub_topic))
time.sleep(0.005) # mandatory sleep for ZMQ backend
# ** Publisher
self.pubSocket = self.zmqContext.socket(zmq.PUB)
self.pubSocket.bind(self.pub_address)
time.sleep(0.005) # mandatory sleep for ZMQ backend
self.logger.debug("[pub] Bound to {}".format(self.pub_address))
# * Initialize other members
self.valid = False
self.buttons = [0, 0] # primary, secondary
self.transform = hm.translation(hm.identity(), self.position_offset)
#self.position = self.position_offset
self.loop = True # TODO ensure this is properly shared across threads
# * Start sensing loop
self.senseThread = Thread(target=self.senseLoop)
self.senseThread.daemon = True # to prevent indefinite wait on recv()
self.senseThread.start()
time.sleep(0.005) # sleep to allow child thread to run
import zmq print(zmq.pyzmq_version())
import zmq
STATE_PRIMARY = 1
STATE_BACKUP = 2
STATE_ACTIVE = 3
STATE_PASSIVE = 4
PEER_PRIMARY = 1
PEER_BACKUP = 2
PEER_ACTIVE = 3
PEER_PASSIVE = 4
CLIENT_REQUEST = 5
HEARTBEAT = 1000
pyzmq_version = tuple(map(int, zmq.pyzmq_version().split('.')))
if pyzmq_version <= (2, 1, 7):
zmq.ROUTER = zmq.XREP
class BStarState(object):
def __init__(self, state, event, peer_expiry):
self.state = state
self.event = event
self.peer_expiry = peer_expiry
class BStarException(Exception):
pass
fsm_states = {
def print_info():
log.info("zeromq version: %s" % zmq.zmq_version())
log.info("pyzmq version: %s" % zmq.pyzmq_version())
log.info("track version: %s" % str(track_base.version_info))
def __init__(self, handler):
usage = "usage: %prog [options] <start|stop|restart|quit>"
parser = OptionParser(usage=usage)
parser.add_option("-u", "--username", dest="username",
metavar="USERNAME",
help="name of the login to be used")
parser.add_option("-s", "--server", dest="servername",
metavar="SERVER-IP",
help="meddle server domain or address")
parser.add_option("-p", "--port", dest="serverport",
metavar="PORT-NR",
help="meddle server tcp port")
(options, args) = parser.parse_args()
_meddle_default_config_filename = os.path.join(
pymeddle_common.meddle_directory(), '.meddle-default')
self._meddle_config_filename = os.path.join(
pymeddle_common.system_user_directory(), '.meddle')
logging.info("using environment:")
logging.info(" Python version %s", tuple(sys.version_info))
logging.info(" ZeroMQ version %s", zmq.zmq_version())
logging.info(" pyzmq version %s", zmq.pyzmq_version())
logging.info(" home directory: %s", pymeddle_common.system_user_directory())
logging.info(" meddle directory: %s", pymeddle_common.meddle_directory())
logging.info(" default config file: %s", _meddle_default_config_filename)
logging.info(" user config file: %s", self._meddle_config_filename)
self._perstitent_settings = {}
self._perstitent_settings['tags'] = []
self._channel_friendly_names = {}
try:
self._perstitent_settings.update(
ast.literal_eval(open(_meddle_default_config_filename).read()))
except Exception as e:
print(e)
try:
self._perstitent_settings.update(
ast.literal_eval(open(self._meddle_config_filename).read()))
except Exception as e:
print(e)
# print(self._perstitent_settings)
self.context = zmq.Context()
self._handler = handler
self._my_id = 0
self._subscriptions = []
self._preliminary_username = False
if options.username:
self._username = options.username
else:
if 'username' in self._perstitent_settings:
self._username = self._perstitent_settings['username']
else:
self._username = system_username()
self._preliminary_username = True
if options.servername:
self._servername = options.servername
else:
self._servername = find_first_available_server(self._perstitent_settings)
self._serverport = options.serverport if options.serverport else 32100
self._mutex_rpc_socket = Lock()
self._connection_status = None
self._version = pymeddle_common.get_version()
def __init__(self, pgm_group, screens=0, name=None, context=None,
error_handler=None):
LOGGER.debug("ZMQ version: {0} PYZMQ version: {1}".\
format(zmq.zmq_version(), zmq.pyzmq_version()))
# Check pgm_group
if not pgm_group:
pgm_group = 1
pgm_ip = '239.128.128.{0}:5555'.format(pgm_group)
LOGGER.debug('PGM IP {0}'.format(pgm_ip))
#Create context
self.context = context if context else zmq.Context()
self.context.setsockopt(zmq.LINGER, 0) # Set default linger value.
#Create publisher
self.publisher = self.context.socket(zmq.PUB)
self.publisher_loopback = self.context.socket(zmq.PUB)
self.ip = utils.GetLocalIPAddress(diwavars.STORAGE)
LOGGER.info('Own IP: %s', self.ip)
if self.ip:
self.id = self.ip.split('.')[3]
else:
self.id = random.randint(1, 154)
self.node = Node(int(self.id), int(screens), name)
self.online = True
# Prevent overflowing slow subscribers
self.publisher.setsockopt(zmq.LINGER, 0)
self.publisher.setsockopt(zmq.RATE, 1000000)
self.publisher.set_hwm(5)
self.publisher_loopback.setsockopt(zmq.LINGER, 0)
self.publisher_loopback.set_hwm(50)
# Bind publisher
self.tladdr = 'epgm://' + self.ip + ';' + pgm_ip
self.ipraddr = 'inproc://mcast_loopback'
self.publisher.bind(self.tladdr)
self.publisher_loopback.bind(self.ipraddr)
# Subscriber threads
targs = ([self.tladdr, self.ipraddr], )
self.sub_thread = SWNP.start_sub_routine(None, self.sub_routine,
'Sub thread', targs)
self.sub_thread_sys = SWNP.start_sub_routine(None,
self.sub_routine_sys,
'Sub sys thread', targs)
LOGGER.debug('Bound listeners on: %s', str(self.tladdr))
join_str = '{id}_SCREENS_{screens}_NAME_{name}_DATA_{_data}'
join_str = join_str.format(**self.node.__dict__)
self.send('SYS', PREFIX_CHOICES[0], join_str)
self.last_joined = self.id
self.NODE_LIST.add(self.node)
self.do_ping()
#heartbeat
self.ping_stop = threading.Event()
self.ping_thread = threading.Thread(
target=self.ping_routine,
name='Ping thread',
args=(error_handler,)
)
self.ping_thread.daemon = True
self.ping_thread.start()
self.timeout_stop = threading.Event()
self.timeout_thread = threading.Thread(target=self.timeout_routine,
name='timeout thread')
self.timeout_thread.daemon = True
self.timeout_thread.start()
def main():
"""Main here."""
args = parse_cmdline_args()
# decide on logging severity level
severity_level = logging.ERROR if args.silent else logging.DEBUG if args.verbose else logging.INFO
# set up logging
logging.basicConfig(stream=sys.stderr, level=severity_level, format="%(message)s")
# debug-print the parsed arguments
logging.debug(args)
# debug-print zmq version info
logging.info("zmq version=%s", zmq.zmq_version())
logging.info("pyzmq version=%s", zmq.pyzmq_version())
# set up zmq machinery
zctx = zmq.Context()
zsck_ctrl = zctx.socket(zmq.PULL)
ctrl_addr = args.ctrl_address or "tcp://*:17267"
zsck_ctrl.bind(ctrl_addr)
zsck_status = zctx.socket(zmq.PUB)
status_addr = args.status_address or "tcp://*:17268"
zsck_status.bind(status_addr)
recorder = FfmpegRecorder()
recorder.debug_show_video = args.show_video
# main loop frequency
frequency = args.frequency or 30.0
# last status, to send messages on change only
recording = recorder.running
paused = recorder.paused
has_crashed = recorder.has_crashed
# whether full status has been requested, initially true
status_requested = True
should_stop = False
while not should_stop:
# check if an incoming message is available
events = zsck_ctrl.poll(1000.0 / frequency)
if events & zmq.POLLIN:
zmsg = zsck_ctrl.recv()
msg = FfmpegControl()
msg.ParseFromString(zmsg)
logging.debug("recved ctrl:\n%s", msg)
if msg.opcode == FfmpegControl.RECORD:
recorder.run()
elif msg.opcode == FfmpegControl.IDLE:
recorder.stop()
elif msg.opcode == FfmpegControl.PAUSE:
recorder.pause()
elif msg.opcode == FfmpegControl.UNPAUSE:
recorder.unpause()
elif msg.opcode == FfmpegControl.SHUTDOWN:
recorder.stop()
should_stop = True
elif msg.opcode == FfmpegControl.PING:
status_requested = True
# update recording parameters
if msg.HasField("capture_x"):
recorder.capture_x = msg.capture_x
if msg.HasField("capture_y"):
recorder.capture_y = msg.capture_y
if msg.HasField("capture_width"):
recorder.capture_width = msg.capture_width
if msg.HasField("capture_height"):
recorder.capture_height = msg.capture_height
if msg.HasField("capture_fps"):
recorder.capture_fps = msg.capture_fps
if msg.HasField("audio_device"):
recorder.audio_device = msg.audio_device
if msg.HasField("video_device"):
recorder.video_device = msg.video_device
if msg.HasField("scale"):
recorder.scale = msg.scale
if msg.HasField("output_file"):
recorder.output_file = msg.output_file
if msg.HasField("debug_show_video"):
recorder.debug_show_video = msg.debug_show_video
# dispatch kbhit commands
if not args.nostdin:
cmd = msvcrt.getch() if msvcrt.kbhit() else 0
if cmd == "r":
recorder.run()
elif cmd == "t":
recorder.stop()
elif cmd == "p":
recorder.pause()
elif cmd == "P":
recorder.unpause()
elif cmd == "i":
status_requested = True
elif cmd == "X":
recorder.stop()
should_stop = True
elif cmd == "/":
print "Usage:"
print "r -- start recording"
print "t -- stop"
print "p -- pause"
print "P -- resume"
print "i -- request explicit status"
print "X -- shutdown"
# send full status on shutdown
if should_stop:
status_requested = True
# publish status
status = FfmpegStatus()
dirty = False
if recorder.running != recording:
recording = recorder.running
status.is_recording = recorder.running
dirty = True
if recorder.paused != paused:
paused = recorder.paused
status.is_paused = recorder.paused
dirty = True
if recorder.has_crashed != has_crashed:
has_crashed = recorder.has_crashed
status.has_crashed = recorder.has_crashed
dirty = True
# whether status message has been requested explicitly
if status_requested:
status.is_recording = recorder.running
status.is_paused = recorder.paused
status.has_crashed = recorder.has_crashed
status_requested = False
dirty = True
if dirty:
logging.debug("sending status:\n%s", status)
events = zsck_status.poll(0, zmq.POLLOUT)
# TODO what if we can't send? the message will be dropped!
if events & zmq.POLLOUT:
zsck_status.send(status.SerializeToString())
def main():
print zmq.zmq_version()
print zmq.pyzmq_version()
PUB_IP = "127.0.0.1"
PUB_PORT = 5000
SUB_IP = "127.0.0.1"
SUB_PORT = 5001
TCP_IP = "127.0.0.1"
TCP_PORT = 5000
UDP_IP = "127.0.0.1"
UDP_PORT = 5005
BUFFER_SIZE = 1024
print ("ZMQ Subsystem")
print (" Init ZMQ system with version: %s" % zmq.pyzmq_version())
context = zmq.Context()
print (" ZMQ context created ")
print (" Init ZMQ PUB")
socketPub = context.socket(zmq.PUB)
socketPub.bind("tcp://%s:%s" % (PUB_IP, PUB_PORT))
print (" Created ZMQ PUB on tcp://%s:%s" % (PUB_IP, PUB_PORT))
print (" Init ZMQ SUB")
socketSub = context.socket(zmq.SUB)
socketSub.bind("tcp://%s:%s" % (SUB_IP, SUB_PORT))
print (" Created ZMQ SUB on tcp://%s:%s" % (SUB_IP, SUB_PORT))
MESSAGE = '{ "controller_name" : "Python_rulez", "controller_type": "PC", "d2c_port": 54321 }")'
# The socket monitor can be explicitly disabled if necessary.
# yield from ct.disable_monitor()
# If a socket monitor is left enabled on a socket being closed,
# the socket monitor will be closed automatically.
ct.close()
yield from cp.wait_closed
st.close()
yield from sp.wait_closed
def main():
asyncio.get_event_loop().run_until_complete(go())
print("DONE")
if __name__ == '__main__':
# import logging
# logging.basicConfig(level=logging.DEBUG)
if (zmq.zmq_version_info() < (4,) or
zmq.pyzmq_version_info() < (14, 4,)):
raise NotImplementedError(
"Socket monitor requires libzmq >= 4 and pyzmq >= 14.4, "
"have libzmq:{}, pyzmq:{}".format(
zmq.zmq_version(), zmq.pyzmq_version()))
main()
def test_version_available(self):
self.assertIsNotNone(zmq.pyzmq_version())
import zmq
import sys
if len(sys.argv) < 2:
print "usage: python %s <target ip address>" % sys.argv[0]
sys.exit(1)
print "ZMQ=%s pyzmq=%s" % (zmq.zmq_version(), zmq.pyzmq_version())
dest = sys.argv[1]
port = 4711
topics = ["demo", "foo"]
context = zmq.Context()
socket = context.socket(zmq.XSUB)
socket.connect("tcp://%s:%d" % (dest, port))
# subscribe XSUB-style to all topics of interest
for t in topics:
socket.send("\001%s" % t)
while True:
(topic, msg) = socket.recv_multipart()
print "topic='%s' content='%s'" % (topic, msg)
#initialize any zmq libs
import zmq
print zmq.pyzmq_version()
import time
import sys
port = "5556"
#we want to run the server on multiple ports(so request can be distributed)
if len(sys.argv) >1:
port = sys.argv[1]
print port
int(port)
#multiple contexts can be created in an app.
#contexts are thread-safe unlike sockets
context = zmq.Context()
#create REP socket from the context
socket = context.socket(zmq.REP)
#bind socket to port
socket.bind("tcp://*:%s" % port)
while True:
#wait for request
message = socket.recv()
print "Received client request" , message
time.sleep(1)
socket.send("Server got your request, here's your response from %s" %port)
def print_info():
log.info("zeromq version: %s" % zmq.zmq_version())
log.info("pyzmq version: %s" % zmq.pyzmq_version())
import sys
#sys.path.insert(0, "C:\\Users\\berg.ZALF-AD\\GitHub\\monica\\project-files\\Win32\\Release")
#sys.path.insert(0, "C:\\Users\\berg.ZALF-AD\\GitHub\\monica\\src\\python")
#sys.path.insert(0, "C:\\Program Files (x86)\\MONICA")
print sys.path
import gc
import csv
import types
import os
import json
from datetime import datetime
from collections import defaultdict, OrderedDict
import zmq
print "pyzmq version: ", zmq.pyzmq_version(
), " zmq version: ", zmq.zmq_version()
import monica_io
#print "path to monica_io: ", monica_io.__file__
LOCAL_RUN = False
def create_output(cl_res, cl_row, cl_col, s_res, s_row, s_col, crop_id, period,
gcm, result):
"create crop output lines"
out = []
if len(result.get("data", [])) > 0 and len(result["data"][0].get(
"results", [])) > 0:
year_to_vals = defaultdict(dict)
'''
blink_server.py
A server that talks zmq on one end, and pyserial on the other.
Controls an LED on a local RPi via commands over zmq.
By Keenan Fejeran
1/20/2015
'''
import zmq
import serial
import time
#Print the current version of zmq
print "pyzmq version: " + zmq.pyzmq_version()
#Open a serial port (note could be a command line arg)
ser = serial.Serial('/dev/ttyACM0', 9600, timeout = 0)
print ser.name
#Create a ZMQ context
context = zmq.Context()
#Create ZMQ socket, bind it to localhost (for testing)
socket = context.socket(zmq.PAIR)
socket.bind("tcp://*:5556")
#listen to the client, passing a trivial message to arduino
while True:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import zmq
print("zeromq version: %s" % zmq.zmq_version())
print("pyzmq version: %s" % zmq.pyzmq_version())
# how-to-implement-proxy-broker-for-xpub-xsub-messaging-in-zmq
# http://stackoverflow.com/questions/14590122
def main():
context = zmq.Context()
xsub_socket = context.socket(zmq.XSUB)
xsub_socket.bind('tcp://*:6000')
xpub_socket = context.socket(zmq.XPUB)
xpub_socket.bind('tcp://*:6001')
poller = zmq.Poller()
poller.register(xpub_socket, zmq.POLLIN)
poller.register(xsub_socket, zmq.POLLIN)
if True:
while True:
#print('listen..')
try:
events = dict(poller.poll(1000))
except KeyboardInterrupt:
print('KeyboardInterrupt - send quit message')
#xpub_socket.send_multipart([b'quit'])
break
