ó
čEYc@só
dd
ddgZddl
Z
ddlZddlZddlZddlZddlZddlZddlm	Z	
ddl
mZ
ddlm
Z

dd	lmZ
ddlZdd
lmZ
ddlmZ
ddlmZ
dd
lmZ
ejeƒ
ZdZe	jdddddddƒ
g
Zdejf
d„ƒYZ de f
d„ƒYZ!de f
d„ƒYZ"de f
d„ƒYZ#de$f
d„ƒYZ%de$f
d„ƒYZ&ddd„Z(ej)e
j*ƒ
d
ej+e&fd „ƒYƒ
Z,dS(!tExecutorLoadFailuretMessageHandlingServertMessagingServerErrortServerListenErroriÿÿÿÿN(
tcfg(
tservice(
t
eventletutils(
t	timeutils(
tdriver(
tbase(
t_LW(
t
exceptionsitexecutor_thread_pool_sizetdefaulti@tdeprecated_nametrpc_thread_pool_sizethelpsDSize of executor thread pool when executor is threading or eventlet.c
BseZ
dZRS(
s4Base class for all MessageHandlingServer exceptions.(t__name__t
__module__t__doc__(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR=s
c
BseZ
dZd
„ZRS(s&Raised if an executor can't be loaded.cCs<d
|
|f}tt
|ƒj|ƒ

|
|_||_dS(Ns Failed to load executor "%s": %s(tsuperRt__init__texecutortex(tselfRRtmsg((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRDs


	
(RRRR(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRAs
c
BseZ
dZd
„ZRS(s*Raised if we failed to listen on a target.cCs<d
|
|f}tt
|ƒj|ƒ

|
|_||_dS(Ns#Failed to listen on target "%s": %s(RRRttargetR(RRRR((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRNs


	
(RRRR(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRKs
tTaskTimeoutc
BseZ
dZRS(
s6Raised if we timed out waiting for a task to complete.(RRR(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRUs
t_OrderedTaskcBsSeZ
dZd
ZdZdZd„Zd„Zed„ƒ
Z	d„Z
d„ZRS(	s»
A task which must be executed in a particular order.

    A caller may wait for this task to complete by calling
    `wait_for_completion`.

    A caller may run this task with `run_once`, which will ensure that however
    many times the task is called it only runs once. Simultaneous callers will
    block until the running task completes, which means that any caller can be
    sure that the task has completed after run_once returns.
    ii
icCs;tt
|ƒjƒ
|
|_tjƒ|_|j|_d
S(sfCreate a new _OrderedTask.

        :param name: The name of this task. Used in log messages.
        N(	RRRt_namet	threadingt	Conditiont_condtINITt_state(Rtname((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRis	

cCs4
d}|d
kr1t
jd|ƒ
}|jƒ
nxü|
ƒr/
|dk	r|jƒrtjtdƒ
|ƒ
tjdj	t
jƒƒ
ƒ

d}n|dk	r·|jƒr·t|ƒ
‚
ng}|dk	rß|j
|jƒƒ

n|dk	r

|j
|jƒƒ

nd}|r
t|ƒ
}n|jj|ƒ

q4WdS(sÆWait while condition() is true. Write a log message if condition()
        has not become false within `log_after` seconds. Raise TaskTimeout if
        timeout_timer expires while waiting.
        itdurationsPossible hang: %stN(tNoneRt	StopWatchtstarttexpiredtLOGtwarningR
tdebugtjoint	tracebacktformat_stackRtappendtleftovertminR twait(Rt	conditionRt	log_aftert
timeout_timert	log_timerttimeoutsR3((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyt_waitts(






	







c

Cs|j|j
kS(
N(R"tCOMPLETE(
R((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytcomplete•sc	sFˆj7
d
|
ˆj
f}ˆj‡f
d†|||ƒ
WdQXdS(sg
Wait until this task has completed.

        :param caller: The name of the task which is waiting.
        :param log_after: Emit a log message if waiting longer than `log_after`
                          seconds.
        :param timeout_timer: Raise TaskTimeout if StopWatch object
                              `timeout_timer` expires while waiting.
        s %s is waiting for %s to completec
sˆjS(
N(
R;((
R(sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyt<lambda>¤sN(R RR9(RtcallerR5R6R((
RsJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytwait_for_completion™s	



c	sòˆjã
ˆj
ˆjkr§ˆjˆ_
ˆjjƒ
z
|
ƒ}Wd
ˆjjƒ
ˆjˆ_
ˆjjƒ
X|d
k	rèˆjjƒ
z|ƒ
Wd
ˆjjƒ
XqènAˆj
ˆjkrèdˆj	}ˆj
‡f
d†|||ƒ
nWd
QXd
S(s×Run a task exactly once. If it is currently running in another
        thread, wait for it to complete. If it has already run, return
        immediately without running it again.

        :param fn: The task to run. It must be a callable taking no arguments.
                   It may optionally return another callable, which also takes
                   no arguments, which will be executed after completion has
                   been signaled to other threads.
        :param log_after: Emit a log message if waiting longer than `log_after`
                          seconds.
        :param timeout_timer: Raise TaskTimeout if StopWatch object
                              `timeout_timer` expires while waiting.
        Ns,%s is waiting for another thread to completecsˆjˆj
kS(
N(R"tRUNNING((
R(sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR<Ïs(R R"R!R?treleasetacquireR:t
notify_allR&RR9(RtfnR5R6tpost_fnR((
RsJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytrun_once§s&


















(RRRR!R?R:RR9tpropertyR;R>RE(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRYs


		!	t_OrderedTaskRunnercBs/eZ
dZd
„Zd„Zed„ƒ
ZRS(s/Mixin for a class which executes ordered tasks.c
Os‚tt
|ƒj|
|Ž
gtj|ƒ
D]3\}}tj|ƒ
r)t|d
tƒr)|^q)|_|j	ƒ
t
jƒ|_dS(Nt_ordered(
RRGRtinspectt
getmemberstismethodtgetattrtFalset_taskstreset_statesRtLockt_reset_lock(RtargstkwargsR#tmember((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRÖs



!

c

Csd
„|jDƒ
|_
dS(Nc
Ssi|]}
t|
ƒ
|
“qS((
R(t.0ttask((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pys
<dictcomp>ås	(RNt_states(
R((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyROãscs+tj
ˆ
ƒ
‡‡
‡‡fd
†ƒ
}|S(Nc
sêˆj.
ˆdk	r3ˆjˆjr3ˆjƒ
nWdQXˆj}ˆ
jd
tƒ}ˆ
jddƒ}d}|dk	r—tjd|ƒ
}|j	ƒ
nˆdk	r½|ˆj
ˆ||ƒ
n|ˆj‡‡‡
‡fd†||ƒ
dS(NR5ttimeoutR$csˆ
ˆˆˆŽ
S(
N(((RRRCRSR(sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR<

s(RQR&RWR;ROtpoptDEFAULT_LOG_AFTERRR'R(R>RE(RRRRStstatesR5RXR6(tafterRCtreset_aftertstate(RRRSRsJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytwrapperês 




	









(t	functoolstwraps(RCR^R\R]R_((R\RCR]R^sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytdecorate_orderedçs'%(RRRRROtstaticmethodRb(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRGÓs
	
	cs‡‡
fd
†}|S(s>A method which will be executed as an ordered task. The method will be
    called exactly once, however many times it is called. If it is called
    multiple times simultaneously it will only be called once, but all callers
    will wait until execution is complete.

    If `after` is given, this method will not run until `after` has completed.

    If `reset_after` is given and the target method has completed, allow this
    task to run again by resetting all task states.

    :param after: Optionally, the name of another `ordered` method. Wait for
                  the completion of `after` before executing this method.
    :param reset_after: Optionally, the name of another `ordered` method. Reset
                        all states when calling this method if `reset_after`
                        has completed.
    c
s/t|d
t
ƒ
|j}
tj||
ˆˆ
ƒS(NRH(tsetattrtTrueRRGRb(RCR^(R\R](sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRH#
s
	
((R\R]RH((R\R]sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytordered
scBs›eZ
dZd
d„
Zd„Zejd„ƒ
Zejd„ƒ
Ze	ddƒ
dd„
ƒ
Ze	d	d
ƒ
d„ƒ
Ze	d	dƒ
d„ƒ
Z
d
„ZRS(s½Server for handling messages.

    Connect a transport to a dispatcher that knows how to process the
    message using an executor that knows how the app wants to create
    new tasks.
    tblockingcCs
|
j|_|jj
tƒ

|
|_||_||_|jd
krhtjddddddtƒ

n+|jdkr“t	j
d	d
g
ddƒ
nd|_yt
jd
|jƒ}Wn%tk
rÜ
}
t|j|ƒ‚
n
X|j
|_d|_t|_tt|ƒjƒ
dS(sUConstruct a message handling server.

        The dispatcher parameter is a DispatcherBase instance which is used
        for routing request to endpoint for processing.

        The executor parameter controls how incoming messages will be received
        and dispatched. By default, the most simple executor is used - the
        blocking executor. It handles only one message at once. It's
        recommended to use threading or eventlet.

        :param transport: the messaging transport
        :type transport: Transport
        :param dispatcher: has a dispatch() method which is invoked for each
                           incoming request
        :type dispatcher: DispatcherBase
        :param executor: name of message executor - available values are
                         'eventlet' and 'threading'
        :type executor: str
        Rgsoblocking executor is deprecated. Executor default will be removed. Use explicitly threading or eventlet insteadtversiontpiketremoval_versiontrockytcategoryteventlettexpected_patched_modulestthreadtwhats&the 'oslo.messaging eventlet executor'soslo.messaging.executorsN(tconft
register_optst
_pool_optst	transportt
dispatchert
executor_typet
debtcollectort	deprecatet
FutureWarningRtwarn_eventlet_not_patchedR&tlistenerRt
DriverManagertRuntimeErrorRt
_executor_clst_work_executorRMt_startedRR
R(RRtRuRtmgrR((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR6
s0
	
	
	






	
	

	
	


		cCs|jj
|j|
ƒ
d
S(sNHandles on_incoming event

        :param incoming: incoming request.
        N(Rtsubmitt_process_incoming(Rtincoming((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyt_on_incomingk
sc
Csd
S(sXPerform processing incoming request

        :param incoming: incoming request.
        N((RR„((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyRƒr
sc


Csd
S(s]Creates listener object for polling requests
        :return: MessageListenerAdapter
        N((
R((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyt_create_listenery
sR]tstopcCsÿ|jrt
jtd
ƒ
ƒ

nt|_i}|jdkrV|
pL|jj|d<n|j||_	y|j
ƒ|_Wn(tj
k
r¥
}
t|j|ƒ‚
n
Xt|jdƒrè|jj}t|dƒrè|j|j_qèn|jj|jƒ

dS(	s˜Start handling incoming messages.

        This method causes the server to begin polling the transport for
        incoming messages and passing them to the dispatcher. Message
        processing will continue until the stop() method is called.

        The executor controls how the server integrates with the applications
        I/O handling strategy - it may choose to poll for messages in a new
        process, thread or co-operatively scheduled coroutine or simply by
        registering a callback with an event loop. Similarly, the executor may
        choose to dispatch messages in a new thread, coroutine or simply the
        current thread.
        sØRestarting a MessageHandlingServer is inherently racy. It is deprecated, and will become a noop in a future release of oslo.messaging. If you need to restart MessageHandlingServer you should instantiate a new object.RRmtmax_workerst_poll_style_listenert_message_operations_handlerN(s	threadingseventlet(R€R*R+R
ReRvRqRR~RR†R{tdriver_basetTransportDriverErrorRRthasattrR‰RŠt	_executorR(R…(Rtoverride_pool_sizet
executor_optsRt
l((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR(
s 	
	




R\R(c

Cs|jj
ƒ
t|_d
S(sP
Stop handling incoming messages.

        Once this method returns, no new incoming messages will be handled by
        the server. However, the server may still be in the process of handling
        some messages, and underlying driver resources associated to this
        server are still in use. See 'wait' for more details.
        N(R{R‡RMR€(
R((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR‡²
s	

c

Cs$|jj
d
tƒ

|jjƒ
dS(s‘
Wait for message processing to complete.

        After calling stop(), there may still be some existing messages
        which have not been completely processed. The wait() method blocks
        until all message processing has completed.

        Once it's finished, the underlying driver resources associated to this
        server are released (like closing useless network connections).
        R3N(RtshutdownReR{tcleanup(
R((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR3¾
sc


Csd
S(s_Reset service.

        Called in case service running in daemon mode receives SIGHUP.
        N((
R((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pytresetÎ
sN(RRRRR…tabctabstractmethodRƒR†RfR&R(R‡R3R”(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyR
-
s5	
2(-t__all__R•R`RItloggingRR.Rwtoslo_configRtoslo_serviceRt
oslo_utilsRRtsixt	stevedoreRtoslo_messaging._driversR	R‹toslo_messaging._i18nR
toslo_messagingRt	getLoggerRR*RZtIntOptRstMessagingExceptionRRRRtobjectRRGR&Rft
add_metaclasstABCMetatServiceBaseR
(((sJ/home/tvault/.virtenv/lib/python2.7/site-packages/oslo_messaging/server.pyt<module>sD


	

















z?