本文整理汇总了Python中work_queue.WorkQueue类的典型用法代码示例。如果您正苦于以下问题：Python WorkQueue类的具体用法？Python WorkQueue怎么用？Python WorkQueue使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了WorkQueue类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: init_generator
def init_generator(self, module, source, collectors, client_context,
http_port, sandesh_req_uve_pkg_list=None,
discovery_client=None):
self._role = self.SandeshRole.GENERATOR
self._module = module
self._source = source
self._client_context = client_context
self._collectors = collectors
self._rcv_queue = WorkQueue(self._process_rx_sandesh)
self._init_logger(module)
self._stats = SandeshStats()
self._trace = trace.Trace()
self._sandesh_request_dict = {}
self._uve_type_maps = SandeshUVETypeMaps()
if sandesh_req_uve_pkg_list is None:
sandesh_req_uve_pkg_list = []
# Initialize the request handling
# Import here to break the cyclic import dependency
import sandesh_req_impl
sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self)
sandesh_req_uve_pkg_list.append('pysandesh.gen_py')
for pkg_name in sandesh_req_uve_pkg_list:
self._create_sandesh_request_and_uve_lists(pkg_name)
self._http_server = SandeshHttp(self, module, http_port, sandesh_req_uve_pkg_list)
primary_collector = None
secondary_collector = None
if self._collectors is not None:
if len(self._collectors) > 0:
primary_collector = self._collectors[0]
if len(self._collectors) > 1:
secondary_collector = self._collectors[1]
gevent.spawn(self._http_server.start_http_server)
self._client = SandeshClient(self, primary_collector, secondary_collector,
discovery_client)
self._client.initiate()示例2: __init__
def __init__(self, sandesh_instance, server, event_handler, sandesh_msg_handler):
self._sandesh_instance = sandesh_instance
self._logger = sandesh_instance._logger
self._event_handler = event_handler
self._reader = SandeshReader(self, sandesh_msg_handler)
self._writer = SandeshWriter(self)
self._send_queue = WorkQueue(self._send_sandesh, self._is_ready_to_send_sandesh)
TcpSession.__init__(self, server)示例3: run
def run(self, argv):
work_queue = WorkQueue()
servant = MathI(work_queue)
broker = self.communicator()
adapter = broker.createObjectAdapter("MathAdapter")
print adapter.add(servant, broker.stringToIdentity("math1"))
adapter.activate()
work_queue.start()
self.shutdownOnInterrupt()
broker.waitForShutdown()
work_queue.destroy()
return 0示例4: init_generator
def init_generator(self, module, source, node_type, instance_id,
collectors, client_context,
http_port, sandesh_req_uve_pkg_list=None,
discovery_client=None, connect_to_collector=True,
logger_class=None, logger_config_file=None,
host_ip='127.0.0.1', alarm_ack_callback=None):
self._role = self.SandeshRole.GENERATOR
self._module = module
self._source = source
self._node_type = node_type
self._instance_id = instance_id
self._host_ip = host_ip
self._client_context = client_context
self._collectors = collectors
self._connect_to_collector = connect_to_collector
self._rcv_queue = WorkQueue(self._process_rx_sandesh)
self._send_level = SandeshLevel.INVALID
self._init_logger(module, logger_class=logger_class,
logger_config_file=logger_config_file)
self._logger.info('SANDESH: CONNECT TO COLLECTOR: %s',
connect_to_collector)
from sandesh_stats import SandeshMessageStatistics
self._msg_stats = SandeshMessageStatistics()
self._trace = trace.Trace()
self._sandesh_request_map = {}
self._alarm_ack_callback = alarm_ack_callback
self._uve_type_maps = SandeshUVETypeMaps(self._logger)
if sandesh_req_uve_pkg_list is None:
sandesh_req_uve_pkg_list = []
# Initialize the request handling
# Import here to break the cyclic import dependency
import sandesh_req_impl
sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self)
sandesh_req_uve_pkg_list.append('pysandesh.gen_py')
for pkg_name in sandesh_req_uve_pkg_list:
self._create_sandesh_request_and_uve_lists(pkg_name)
self._gev_httpd = None
if http_port != -1:
self._http_server = SandeshHttp(
self, module, http_port, sandesh_req_uve_pkg_list)
self._gev_httpd = gevent.spawn(self._http_server.start_http_server)
primary_collector = None
secondary_collector = None
if self._collectors is not None:
if len(self._collectors) > 0:
primary_collector = self._collectors[0]
if len(self._collectors) > 1:
secondary_collector = self._collectors[1]
if self._connect_to_collector:
self._client = SandeshClient(
self, primary_collector, secondary_collector,
discovery_client)
self._client.initiate()示例5: __init__
def __init__(self, project, port, log_freq=600): # 600 seconds
"""Initialize the QMaster
Parameters
----------
project :
port : int
log_freq : int, optional
frequency to print info about the status of the work queue.
In units of seconds. Default is to print every 10 minutes.
"""
threading.Thread.__init__(self)
self.project = project
self.log_freq = log_freq # print time in seconds
self.wake_freq = 1 # seconds
self.wq = WorkQueue(port, name='MSMAccelerator', catalog=True, exclusive=False)
logger.info('WORK QUEUE MASTER LISTENING ON PORT: %d', self.wq.port)
logger.info('(Start a local worker with >> work_queue_worker -d all localhost %d & )', self.wq.port)
# method controls whether or not we need to bring back solvated_xtc as well
if self.project.method == 'explicit':
self.return_wet_xtc = True
elif self.project.method == 'implicit':
self.return_wet_xtc = False
else:
raise Exception("project.method must be 'explicit' or 'implicit'")
logger.info('Return wet xtc set to %s', self.return_wet_xtc)
# what does this specify algorithm do?
self.wq.specify_algorithm(WORK_QUEUE_SCHEDULE_FCFS)
# fast abort kills jobs that appear to be stragling (taking more than 1.5x average)
#self.wq.activate_fast_abort(1.5)
# setting the stop event signals for the thread to die
self._stop = threading.Event()
# the thread sets the event every time a job returns or there are no waiting jobs
# and it finished post processing. See the wait method
self._mainloop_wake_event_cause = None
self._mainloop_wake_event = threading.Event()
# start the thread
self.start()示例6: init_generator
def init_generator(self, module, source, node_type, instance_id,
collectors, client_context,
http_port, sandesh_req_uve_pkg_list=None,
connect_to_collector=True,
logger_class=None, logger_config_file=None,
host_ip='127.0.0.1', alarm_ack_callback=None,
config=None):
self._role = self.SandeshRole.GENERATOR
self._module = module
self._source = source
self._node_type = node_type
self._instance_id = instance_id
self._sandesh_req_uve_pkg_list = sandesh_req_uve_pkg_list or []
self._host_ip = host_ip
self._client_context = client_context
self._connect_to_collector = connect_to_collector
self._rcv_queue = WorkQueue(self._process_rx_sandesh)
self._init_logger(self._module, logger_class=logger_class,
logger_config_file=logger_config_file)
self._logger.info('SANDESH: CONNECT TO COLLECTOR: %s',
connect_to_collector)
from sandesh_stats import SandeshMessageStatistics
self._msg_stats = SandeshMessageStatistics()
self._trace = trace.Trace()
self._sandesh_request_map = {}
self._alarm_ack_callback = alarm_ack_callback
self._config = config or SandeshConfig.from_parser_arguments()
self._uve_type_maps = SandeshUVETypeMaps(self._logger)
# Initialize the request handling
# Import here to break the cyclic import dependency
import sandesh_req_impl
sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self)
self._sandesh_req_uve_pkg_list.append('pysandesh.gen_py')
for pkg_name in self._sandesh_req_uve_pkg_list:
self._create_sandesh_request_and_uve_lists(pkg_name)
if self._config.disable_object_logs is not None:
self.disable_sending_object_logs(self._config.disable_object_logs)
if self._config.system_logs_rate_limit is not None:
SandeshSystem.set_sandesh_send_rate_limit(
self._config.system_logs_rate_limit)
self._gev_httpd = None
if http_port != -1:
self.run_introspect_server(http_port)
if self._connect_to_collector:
self._client = SandeshClient(self)
self._client.initiate(collectors)示例7: __init__
#.........这里部分代码省略.........
'dst' : State._CONNECT
},
# _DISCONNECT
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._DISCONNECT,
'dst' : State._CONNECT
},
# _CONNECT
{'name' : Event._EV_COLLECTOR_UNKNOWN,
'src' : State._CONNECT,
'dst' : State._DISCONNECT
},
{'name' : Event._EV_TCP_CONNECT_FAIL,
'src' : State._CONNECT,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_CONNECT_TIMER_EXPIRED,
'src' : State._CONNECT,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._CONNECT,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CONNECTED,
'src' : State._CONNECT,
'dst' : State._CLIENT_INIT
},
# _CONNECT_TO_BACKUP
{'name' : Event._EV_BACKUP_COLLECTOR_UNKNOWN,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CONNECT_FAIL,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_CONNECT_TIMER_EXPIRED,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CONNECTED,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._CLIENT_INIT
},
# _CLIENT_INIT
{'name' : Event._EV_CONNECT_TIMER_EXPIRED,
'src' : State._CLIENT_INIT,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CLOSE,
'src' : State._CLIENT_INIT,
'dst' : State._IDLE
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._CLIENT_INIT,
'dst' : State._IDLE
},
{'name' : Event._EV_SANDESH_CTRL_MESSAGE_RECV,
'src' : State._CLIENT_INIT,
'dst' : State._ESTABLISHED
},
# _ESTABLISHED
{'name' : Event._EV_TCP_CLOSE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT
}
],
'callbacks': {
'on' + State._IDLE : _on_idle,
'on' + State._CONNECT : _on_connect,
'on' + State._CONNECT_TO_BACKUP : _on_connect_to_backup,
'on' + State._CLIENT_INIT : _on_client_init,
'on' + State._ESTABLISHED : _on_established,
}
})
self._connection = connection
self._session = None
self._connects = 0
self._idle_hold_timer = None
self._connect_timer = None
self._active_collector = primary_collector
self._backup_collector = secondary_collector
self._logger = logger
self._event_queue = WorkQueue(self._dequeue_event,
self._is_ready_to_dequeue_event)示例8: SandeshStateMachine
#.........这里部分代码省略.........
},
{'name' : Event._EV_SANDESH_CTRL_MESSAGE_RECV,
'src' : State._CLIENT_INIT,
'dst' : State._ESTABLISHED
},
# _ESTABLISHED
{'name' : Event._EV_TCP_CLOSE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT
}
],
'callbacks': {
'on' + State._IDLE : _on_idle,
'on' + State._CONNECT : _on_connect,
'on' + State._CONNECT_TO_BACKUP : _on_connect_to_backup,
'on' + State._CLIENT_INIT : _on_client_init,
'on' + State._ESTABLISHED : _on_established,
}
})
self._connection = connection
self._session = None
self._connects = 0
self._idle_hold_timer = None
self._connect_timer = None
self._active_collector = primary_collector
self._backup_collector = secondary_collector
self._logger = logger
self._event_queue = WorkQueue(self._dequeue_event,
self._is_ready_to_dequeue_event)
#end __init__
# Public functions
def initialize(self):
self.enqueue_event(Event(event = Event._EV_START))
#end initialize
def session(self):
return self._session
#end session
def state(self):
return self._fsm.current
#end state
def shutdown(self):
self.enqueue_event(Event(event = Event._EV_STOP))
#end shutdown
def set_admin_state(self, down):
if down == True:
self.enqueue_event(Event(event = Event._EV_STOP))
else:
self.enqueue_event(Event(event = Event._EV_START))
#end set_admin_state
def connect_count(self):
return self._connects
#end connect_count
示例9: SandeshSession
class SandeshSession(TcpSession):
_KEEPALIVE_IDLE_TIME = 45 # in secs
_KEEPALIVE_INTERVAL = 3 # in secs
_KEEPALIVE_PROBES = 5
def __init__(self, sandesh_instance, server, event_handler, sandesh_msg_handler):
self._sandesh_instance = sandesh_instance
self._logger = sandesh_instance._logger
self._event_handler = event_handler
self._reader = SandeshReader(self, sandesh_msg_handler)
self._writer = SandeshWriter(self)
self._send_queue = WorkQueue(self._send_sandesh, self._is_ready_to_send_sandesh)
TcpSession.__init__(self, server)
# end __init__
# Public functions
def sandesh_instance(self):
return self._sandesh_instance
# end sandesh_instance
def is_send_queue_empty(self):
return self._send_queue.is_queue_empty()
# end is_send_queue_empty
def is_connected(self):
return self._connected
# end is_connected
def enqueue_sandesh(self, sandesh):
self._send_queue.enqueue(sandesh)
# end enqueue_sandesh
def send_queue(self):
return self._send_queue
# end send_queue
# Overloaded functions from TcpSession
def connect(self):
TcpSession.connect(self, timeout=5)
# end connect
def _on_read(self, buf):
if self._reader.read_msg(buf) < 0:
self._logger.error("SandeshReader Error. Close Collector session")
self.close()
# end _on_read
def _handle_event(self, event):
self._event_handler(self, event)
# end _handle_event
def _set_socket_options(self):
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
if hasattr(socket, "TCP_KEEPIDLE"):
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, self._KEEPALIVE_IDLE_TIME)
if hasattr(socket, "TCP_KEEPALIVE"):
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPALIVE, self._KEEPALIVE_IDLE_TIME)
if hasattr(socket, "TCP_KEEPINTVL"):
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, self._KEEPALIVE_INTERVAL)
if hasattr(socket, "TCP_KEEPCNT"):
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, self._KEEPALIVE_PROBES)
# end _set_socket_options
# Private functions
def _send_sandesh(self, sandesh):
if self._send_queue.is_queue_empty():
more = False
else:
more = True
if not self._connected:
self._logger.log(SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log())
return
if sandesh.is_logging_allowed(self._sandesh_instance):
self._logger.log(SandeshLogger.get_py_logger_level(sandesh.level()), sandesh.log())
self._writer.send_msg(sandesh, more)
# end _send_sandesh
def _is_ready_to_send_sandesh(self):
return self._sandesh_instance.is_send_queue_enabled()示例10: Sandesh
class Sandesh(object):
_DEFAULT_LOG_FILE = SandeshLogger._DEFAULT_LOG_FILE
_DEFAULT_SYSLOG_FACILITY = SandeshLogger._DEFAULT_SYSLOG_FACILITY
class SandeshRole:
INVALID = 0
GENERATOR = 1
COLLECTOR = 2
# end class SandeshRole
def __init__(self):
self._context = ''
self._scope = ''
self._module = ''
self._source = ''
self._node_type = ''
self._instance_id = ''
self._timestamp = 0
self._versionsig = 0
self._type = 0
self._hints = 0
self._client_context = ''
self._client = None
self._role = self.SandeshRole.INVALID
self._logger = None
self._level = SandeshLevel.INVALID
self._category = ''
self._send_queue_enabled = True
self._http_server = None
# end __init__
# Public functions
def init_generator(self, module, source, node_type, instance_id,
collectors, client_context,
http_port, sandesh_req_uve_pkg_list=None,
discovery_client=None):
self._role = self.SandeshRole.GENERATOR
self._module = module
self._source = source
self._node_type = node_type
self._instance_id = instance_id
self._client_context = client_context
self._collectors = collectors
self._rcv_queue = WorkQueue(self._process_rx_sandesh)
self._init_logger(source + ':' + module + ':' + node_type + ':' \
+ instance_id)
self._stats = SandeshStats()
self._trace = trace.Trace()
self._sandesh_request_dict = {}
self._uve_type_maps = SandeshUVETypeMaps()
if sandesh_req_uve_pkg_list is None:
sandesh_req_uve_pkg_list = []
# Initialize the request handling
# Import here to break the cyclic import dependency
import sandesh_req_impl
sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self)
sandesh_req_uve_pkg_list.append('pysandesh.gen_py')
for pkg_name in sandesh_req_uve_pkg_list:
self._create_sandesh_request_and_uve_lists(pkg_name)
if http_port != -1:
self._http_server = SandeshHttp(
self, module, http_port, sandesh_req_uve_pkg_list)
gevent.spawn(self._http_server.start_http_server)
primary_collector = None
secondary_collector = None
if self._collectors is not None:
if len(self._collectors) > 0:
primary_collector = self._collectors[0]
if len(self._collectors) > 1:
secondary_collector = self._collectors[1]
self._client = SandeshClient(
self, primary_collector, secondary_collector,
discovery_client)
self._client.initiate()
# end init_generator
def logger(self):
return self._logger
# end logger
def sandesh_logger(self):
return self._sandesh_logger
# end sandesh_logger
def set_logging_params(self, enable_local_log=False, category='',
level=SandeshLevel.SYS_INFO,
file=SandeshLogger._DEFAULT_LOG_FILE,
enable_syslog=False,
syslog_facility=_DEFAULT_SYSLOG_FACILITY):
self._sandesh_logger.set_logging_params(
enable_local_log, category, level, file,
enable_syslog, syslog_facility)
# end set_logging_params
def set_local_logging(self, enable_local_log):
self._sandesh_logger.set_local_logging(enable_local_log)
# end set_local_logging
def set_logging_level(self, level):
#.........这里部分代码省略.........
示例11: QMaster
class QMaster(threading.Thread):
def __init__(self, project, port, log_freq=600): # 600 seconds
"""Initialize the QMaster
Parameters
----------
project :
port : int
log_freq : int, optional
frequency to print info about the status of the work queue.
In units of seconds. Default is to print every 10 minutes.
"""
threading.Thread.__init__(self)
self.project = project
self.log_freq = log_freq # print time in seconds
self.wake_freq = 1 # seconds
self.wq = WorkQueue(port, name='MSMAccelerator', catalog=True, exclusive=False)
logger.info('WORK QUEUE MASTER LISTENING ON PORT: %d', self.wq.port)
logger.info('(Start a local worker with >> work_queue_worker -d all localhost %d & )', self.wq.port)
# method controls whether or not we need to bring back solvated_xtc as well
if self.project.method == 'explicit':
self.return_wet_xtc = True
elif self.project.method == 'implicit':
self.return_wet_xtc = False
else:
raise Exception("project.method must be 'explicit' or 'implicit'")
logger.info('Return wet xtc set to %s', self.return_wet_xtc)
# what does this specify algorithm do?
self.wq.specify_algorithm(WORK_QUEUE_SCHEDULE_FCFS)
# fast abort kills jobs that appear to be stragling (taking more than 1.5x average)
#self.wq.activate_fast_abort(1.5)
# setting the stop event signals for the thread to die
self._stop = threading.Event()
# the thread sets the event every time a job returns or there are no waiting jobs
# and it finished post processing. See the wait method
self._mainloop_wake_event_cause = None
self._mainloop_wake_event = threading.Event()
# start the thread
self.start()
def run(self):
"""Main thread-loop for the QMaster thread"""
last_print = time.time()
while True:
time.sleep(self.wake_freq)
if not self.wq.empty():
t = self.wq.wait(self.wake_freq)
if t:
if t.return_status != 0:
logger.error('Worker returned nonzero exit status for job: %d', t.return_status)
else:
self.on_return(t)
self._mainloop_wake_event_cause = 'job returned'
self._mainloop_wake_event.set()
if self.wq.stats.tasks_waiting == 0 and not self._mainloop_wake_event.is_set():
self._mainloop_wake_event_cause = 'queue empty'
self._mainloop_wake_event.set() # also set the event if there are no tasks in the queue
if self._stop.is_set():
logger.info('Recieved stop signal. Shutting down all workers')
self.wq.shutdown_workers(0) # 0 indicates to shut all of them down
sys.exit(0)
if time.time() - last_print > self.log_freq:
logger.info('workers initialized: %d, ready: %d, busy: %d', self.wq.stats.workers_init, self.wq.stats.workers_ready, self.wq.stats.workers_busy)
logger.info('workers running: %d, waiting: %d, complete: %d', self.wq.stats.tasks_running, self.wq.stats.tasks_waiting, self.wq.stats.tasks_complete)
last_print = time.time()
def num_jobs_waiting(self):
"""Number of jobs waiting to be sent out
This number should be kept at 1, and when it drops to zero a new job
should be generated.
Returns
-------
n : int
The number
"""
return self.wq.stats.tasks_waiting
def num_jobs_in_queue(self):
"""Get the number of jobs currently in the work queue
This includes both the jobs running remotely and the ones waiting
here
#.........这里部分代码省略.........
示例12: __init__
#.........这里部分代码省略.........
'src' : State._DISCONNECT,
'dst' : State._CONNECT
},
# _CONNECT
{'name' : Event._EV_COLLECTOR_UNKNOWN,
'src' : State._CONNECT,
'dst' : State._DISCONNECT
},
{'name' : Event._EV_TCP_CONNECT_FAIL,
'src' : State._CONNECT,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_CONNECT_TIMER_EXPIRED,
'src' : State._CONNECT,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._CONNECT,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CONNECTED,
'src' : State._CONNECT,
'dst' : State._CLIENT_INIT
},
# _CONNECT_TO_BACKUP
{'name' : Event._EV_BACKUP_COLLECTOR_UNKNOWN,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CONNECT_FAIL,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_CONNECT_TIMER_EXPIRED,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CONNECTED,
'src' : State._CONNECT_TO_BACKUP,
'dst' : State._CLIENT_INIT
},
# _CLIENT_INIT
{'name' : Event._EV_CONNECT_TIMER_EXPIRED,
'src' : State._CLIENT_INIT,
'dst' : State._IDLE
},
{'name' : Event._EV_TCP_CLOSE,
'src' : State._CLIENT_INIT,
'dst' : State._IDLE
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._CLIENT_INIT,
'dst' : State._IDLE
},
{'name' : Event._EV_SANDESH_CTRL_MESSAGE_RECV,
'src' : State._CLIENT_INIT,
'dst' : State._ESTABLISHED
},
# _ESTABLISHED
{'name' : Event._EV_TCP_CLOSE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT_TO_BACKUP
},
{'name' : Event._EV_STOP,
'src' : State._ESTABLISHED,
'dst' : State._IDLE
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT
}
],
'callbacks': {
'on' + State._IDLE : _on_idle,
'on' + State._CONNECT : _on_connect,
'on' + State._CONNECT_TO_BACKUP : _on_connect_to_backup,
'on' + State._CLIENT_INIT : _on_client_init,
'on' + State._ESTABLISHED : _on_established,
}
})
self._connection = connection
self._session = None
self._connects = 0
self._disable = False
self._idle_hold_timer = None
self._connect_timer = None
self._active_collector = primary_collector
self._backup_collector = secondary_collector
self._logger = logger
self._event_queue = WorkQueue(self._dequeue_event,
self._is_ready_to_dequeue_event)示例13: set_debug_flag
""" Python-WorkQueue test """
from work_queue import Task, WorkQueue, set_debug_flag
from work_queue import WORK_QUEUE_SCHEDULE_FCFS, WORK_QUEUE_SCHEDULE_FILES
from work_queue import WORK_QUEUE_RANDOM_PORT
from work_queue import WORK_QUEUE_OUTPUT
#from workqueue import WORK_QUEUE_MASTER_MODE_STANDALONE, WORK_QUEUE_WORKER_MODE_SHARED
import os
import sys
import time
set_debug_flag('debug')
set_debug_flag('wq')
wq = WorkQueue(WORK_QUEUE_RANDOM_PORT, name='workqueue_example', catalog=False, exclusive=False)
os.system('work_queue_worker -d all localhost %d &' % wq.port)
print wq.name
wq.specify_algorithm(WORK_QUEUE_SCHEDULE_FCFS)
#wq.specify_name('workqueue_example')
#wq.specify_master_mode(WORK_QUEUE_MASTER_MODE_STANDALONE)
#wq.specify_worker_mode(WORK_QUEUE_WORKER_MODE_SHARED)
if wq.empty():
print 'work queue is empty'
outputs = []
for i in range(5):示例14: Sandesh
class Sandesh(object):
_DEFAULT_LOG_FILE = sand_logger.SandeshLogger._DEFAULT_LOG_FILE
_DEFAULT_SYSLOG_FACILITY = (
sand_logger.SandeshLogger._DEFAULT_SYSLOG_FACILITY)
class SandeshRole:
INVALID = 0
GENERATOR = 1
COLLECTOR = 2
# end class SandeshRole
def __init__(self):
self._context = ''
self._scope = ''
self._module = ''
self._source = ''
self._node_type = ''
self._instance_id = ''
self._timestamp = 0
self._versionsig = 0
self._type = 0
self._hints = 0
self._client_context = ''
self._client = None
self._role = self.SandeshRole.INVALID
self._logger = None
self._level = SandeshLevel.INVALID
self._category = ''
self._send_queue_enabled = True
self._http_server = None
self._connect_to_collector = True
# end __init__
# Public functions
def init_generator(self, module, source, node_type, instance_id,
collectors, client_context,
http_port, sandesh_req_uve_pkg_list=None,
discovery_client=None, connect_to_collector=True,
logger_class=None, logger_config_file=None,
host_ip='127.0.0.1', alarm_ack_callback=None):
self._role = self.SandeshRole.GENERATOR
self._module = module
self._source = source
self._node_type = node_type
self._instance_id = instance_id
self._host_ip = host_ip
self._client_context = client_context
self._collectors = collectors
self._connect_to_collector = connect_to_collector
self._rcv_queue = WorkQueue(self._process_rx_sandesh)
self._send_level = SandeshLevel.INVALID
self._init_logger(module, logger_class=logger_class,
logger_config_file=logger_config_file)
self._logger.info('SANDESH: CONNECT TO COLLECTOR: %s',
connect_to_collector)
from sandesh_stats import SandeshMessageStatistics
self._msg_stats = SandeshMessageStatistics()
self._trace = trace.Trace()
self._sandesh_request_map = {}
self._alarm_ack_callback = alarm_ack_callback
self._uve_type_maps = SandeshUVETypeMaps(self._logger)
if sandesh_req_uve_pkg_list is None:
sandesh_req_uve_pkg_list = []
# Initialize the request handling
# Import here to break the cyclic import dependency
import sandesh_req_impl
sandesh_req_impl = sandesh_req_impl.SandeshReqImpl(self)
sandesh_req_uve_pkg_list.append('pysandesh.gen_py')
for pkg_name in sandesh_req_uve_pkg_list:
self._create_sandesh_request_and_uve_lists(pkg_name)
self._gev_httpd = None
if http_port != -1:
self._http_server = SandeshHttp(
self, module, http_port, sandesh_req_uve_pkg_list)
self._gev_httpd = gevent.spawn(self._http_server.start_http_server)
primary_collector = None
secondary_collector = None
if self._collectors is not None:
if len(self._collectors) > 0:
primary_collector = self._collectors[0]
if len(self._collectors) > 1:
secondary_collector = self._collectors[1]
if self._connect_to_collector:
self._client = SandeshClient(
self, primary_collector, secondary_collector,
discovery_client)
self._client.initiate()
# end init_generator
def uninit(self):
self.kill_httpd()
def kill_httpd(self):
if self._gev_httpd:
try:
self._http_server.stop_http_server()
self._http_server = None
gevent.sleep(0)
self._gev_httpd.kill()
#.........这里部分代码省略.........
示例15: SandeshStateMachine
#.........这里部分代码省略.........
# _ESTABLISHED
{'name' : Event._EV_TCP_CLOSE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT
},
{'name' : Event._EV_STOP,
'src' : State._ESTABLISHED,
'dst' : State._IDLE
},
{'name' : Event._EV_COLLECTOR_CHANGE,
'src' : State._ESTABLISHED,
'dst' : State._CONNECT
}
],
'callbacks': {
'on' + State._IDLE : _on_idle,
'on' + State._CONNECT : _on_connect,
'on' + State._CLIENT_INIT : _on_client_init,
'on' + State._ESTABLISHED : _on_established,
}
})
self._connection = connection
self._session = None
self._connects = 0
self._disable = False
self._idle_hold_timer = None
self._connect_timer = None
self._collectors = collectors
self._collector_name = None
self._collector_index = -1
self._logger = logger
self._event_queue = WorkQueue(self._dequeue_event,
self._is_ready_to_dequeue_event)
#end __init__
# Public functions
def initialize(self):
self.enqueue_event(Event(event = Event._EV_START))
#end initialize
def session(self):
return self._session
#end session
def state(self):
return self._fsm.current
#end state
def shutdown(self):
self._disable = True
self.enqueue_event(Event(event = Event._EV_STOP))
#end shutdown
def set_admin_state(self, down):
if down == True:
self._disable = True
self.enqueue_event(Event(event = Event._EV_STOP))
else:
self._disable = False
self.enqueue_event(Event(event = Event._EV_START))
#end set_admin_state
def connect_count(self):