Current File : //proc/self/root/usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyo
�
���^c @@ s� d Z d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l m Z d d l
m Z d d l Z d d l Z d d l m Z m Z d d l m Z d d l m Z e Z e e d e � r� e Z n e j e � Z d
e f d � � YZ! e! Z" d � Z# d
� Z$ d e f d � � YZ% d e% f d � � YZ& e& Z' d e% f d � � YZ( e( Z) d � Z* d � Z+ d S( u'
Helpful decorators for module writing
i ( t absolute_importt print_functiont unicode_literalsN( t wraps( t defaultdict( t CommandExecutionErrort SaltConfigurationError( t
LOG_LEVELS( t sixu getwindowsversiont Dependsc B@ sM e Z d Z e d � � Z d � Z d � Z e d � � Z e d � � Z
RS( u�
This decorator will check the module when it is loaded and check that the
dependencies passed in are in the globals of the module. If not, it will
cause the function to be unloaded (or replaced).
c C@ s
t t � S( N( R t dict( ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt <lambda>( s c O@ s) t j d | | � | | _ | | _ d S( uz
The decorator is instantiated with a list of dependencies (string of
global name)
An example use of this would be:
.. code-block:: python
@depends('modulename')
def test():
return 'foo'
OR
@depends('modulename', fallback_function=function)
def test():
return 'foo'
.. code-block:: python
This can also be done with the retcode of a command, using the
``retcode`` argument:
@depends('/opt/bin/check_cmd', retcode=0)
def test():
return 'foo'
It is also possible to check for any nonzero retcode using the
``nonzero_retcode`` argument:
@depends('/opt/bin/check_cmd', nonzero_retcode=True)
def test():
return 'foo'
.. note::
The command must be formatted as a string, not a list of args.
Additionally, I/O redirection and other shell-specific syntax are
not supported since this uses shell=False when calling
subprocess.Popen().
u@ Depends decorator instantiated with dep list of %s and kwargs %sN( t logt tracet dependenciest params( t selfR t kwargs( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt __init__* s
*
c C@ s� y{ t j � d d } | j d j d d � \ } } } | j } x5 | j D]* } | | j f | j | | | | f <qL WWn t k
r� } t j
d � n X| S( u�
The decorator is "__call__"d with the function, we take that function
and determine which module and function name it is to store in the
class wide dependency_dict
i i u __name__u .i uN Exception encountered when attempting to inspect frame in dependency decorator( t inspectt stackt f_globalst rsplitt __name__R R t dependency_dictt ExceptionR t exception( R t functiont framet _t kindt mod_namet fun_namet dept exc( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt __call__[ s " , c C@ s� d j | | � } t j d | | � t rI t j j j | d t �} n t j j j | � } t j d | � t j
| d t d t j d t j �} | j
� d } | j } t j d | | � t j d
| | � | S( Nu {0}.{1}u Running '%s' for '%s't posixu Command after shlex_split: %st shellt stdoutt stderri u Output from '%s': %su Retcode from '%s': %d( t formatR R
t
IS_WINDOWSt saltt utilst argst shlex_splitt Falset
subprocesst Popent PIPEt STDOUTt communicatet
returncode( t
dependencyR t func_namet full_nameR, t proct outputt retcode( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt run_commands s c
C@ s� x}t j | j | � D]e\ } } xVt j | � D]E\ \ } } \ } } | | k r] q3 n d | k su d | k rPy | j | | | � }
WnW t k
r� } | j t j k r� t j d | | j � n t j d | | � d }
n Xd | k r
| d |
k rMq3 qMq�d | k r�| d r8|
d k rJq3 qJqM|
d k rMq3 qMq�n\ | t
k rut j d | | � q3 n7 | | j k s�| | j k r�t j d | | � q3 n t j d | | | � | r3 y | j d
| } Wn t
t f k
r�n Xd j | | � } | | k rq3 n y3 | j d � }
|
d k rF|
| | <n | | =Wqxt
k
rtt j d
| � q3 qxXq3 q3 Wq Wd S( u�
This is a class global method to enforce the dependencies that you
currently know about.
It will modify the "functions" dict and remove/replace modules that
are missing dependencies.
u retcodeu nonzero_retcodeu& Failed to run command %s, %s not foundu Failed to run command '%s': %si����i u* Dependency for %s.%s exists, not unloadingu2 Dependency (%s) already loaded inside %s, skippingu2 Unloading %s.%s because dependency (%s) is not metu __func_alias__u {0}.{1}u fallback_functionu %s already removed, skippingN( R t iteritemsR R; t OSErrort errnot ENOENTR R
t filenamet TrueR t f_localst AttributeErrort KeyErrorR( t gett None( t clst functionsR t tgt_modR5 t dependent_dictR R6 R R R: R" t mod_keyt fallback_function( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt enforce_dependencies� sl #(
( R t
__module__t __doc__R R R R# t staticmethodR; t classmethodRM ( ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR ! s 1 c @ s t � � � f d � � } | S( uI
Decorator wrapper to log execution time, for profiling purposes
c @ s� t j � } � | t j j j | � � } t j � } � j j d � rX � j d } n � j } d j t j j
� } t j | | � j
| | � | S( Nu salt.loaded.int.i u- Function %s.%s took %.{0}f seconds to execute( t timeR* R+ R, t clean_kwargsRN t
startswithR( t syst
float_infot digR t profileR ( R, R t
start_timet rett end_timeR t fstr( R ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt wrapped� s ( R ( R R] ( ( R sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt timing� s c @ s( i � t � � � � f d � � } | S( u�
Memoize aka cache the return output of a function
given a specific set of arguments
.. versionedited:: 2016.3.4
Added **kwargs support.
c @ s� g } xF | D]> } t | t j � s> | j t j | � � q
| j | � q
Wd j t | � g t | � D] } d j | | | � ^ qk � } | � k r� � | | � � | <n � | S( Nu ,u {0}={1}( t
isinstanceR t string_typest appendt text_typet joint listt sortedR( ( R, R t str_argst argt kt args_( t cachet func( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt _memoize� s
B ( R ( Rk Rl ( ( Rj Rk sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt memoize� s t _DeprecationDecoratorc B@ s> e Z d Z d Z d Z d � Z d � Z d � Z d � Z RS( u}
Base mix-in class for the deprecation decorator.
Takes care of a common functionality, used in its derivatives.
i i c C@ sh d d l m } m } | | _ | | _ | j | j � | _ | j | _ d | _
d | _ d | _ d S( u�
Constructor.
:param globals: Module globals. Important for finding out replacement functions
:param version: Expiration version
:return:
i ( t SaltStackVersiont __saltstack_version__N(
t salt.versionRo Rp t _globalst _exp_version_namet from_namet _exp_versiont infot
_curr_versionRF t _raise_latert _functiont _orig_f_name( R t globalst versionRo Rp ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR s c C@ s( t � } t j j j | � } | | f S( u
Discard all keywords which aren't function-specific from the kwargs.
:param kwargs:
:return:
( Rd R* R+ R, RS ( R R t _argst _kwargs( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt _get_args) s c C@ s� | j r | j � n | j r� | j | � \ } } y | j | | � SWq� t k
r� } t j | � j | j | j � } t j d | j | � | j j
St k
r� } t j d | j j | � | � q� Xn t
d � � d S( uQ
Call target function that has been decorated.
:return:
u) Function "%s" was not properly called: %su0 Unhandled exception occurred in function "%s: %suA Function is deprecated, but the successor function was not found.N( Rx Ry R t TypeErrorR Rb t replaceRz R t errorRO R R R ( R R R, R� ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt _call_function5 s$ !
c C@ s | | _ | j j | _ d S( u�
Callable method of the decorator object when
the decorated function is gets called.
:param function:
:return:
N( Ry R Rz ( R R ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR# R s ( R RN RO t OPT_INt OPT_OUTR R R� R# ( ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyRn s t
_IsDeprecatedc B@ s# e Z d Z d d � Z d � Z RS( u_
This decorator should be used only with the deprecated functions
to mark them as deprecated and alter its behavior a corresponding way.
The usage is only suitable if deprecation process is renaming
the function from one to another. In case function name or even function
signature stays the same, please use 'with_deprecated' decorator instead.
It has the following functionality:
1. Put a warning level message to the log, informing that
the deprecated function has been in use.
2. Raise an exception, if deprecated function is being called,
but the lifetime of it already expired.
3. Point to the successor of the deprecated function in the
log messages as well during the blocking it, once expired.
Usage of this decorator as follows. In this example no successor
is mentioned, hence the function "foo()" will be logged with the
warning each time is called and blocked completely, once EOF of
it is reached:
from salt.util.decorators import is_deprecated
@is_deprecated(globals(), "Beryllium")
def foo():
pass
In the following example a successor function is mentioned, hence
every time the function "bar()" is called, message will suggest
to use function "baz()" instead. Once EOF is reached of the function
"bar()", an exception will ask to use function "baz()", in order
to continue:
from salt.util.decorators import is_deprecated
@is_deprecated(globals(), "Beryllium", with_successor="baz")
def bar():
pass
def baz():
pass
c C@ s t j | | | � | | _ d S( u�
Constructor of the decorator 'is_deprecated'.
:param globals: Module globals
:param version: Version to be deprecated
:param with_successor: Successor function (optional)
:return:
N( Rn R t
_successor( R R{ R| t with_successor( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR � s c @ s/ t j � | � t | � � f d � � } | S( u�
Callable method of the decorator object when
the decorated function is gets called.
:param function:
:return:
c @ s� � j � j k rw d j d � j j d � j � g } � j r^ | j d j d � j � � n t j d j
| � � nn d j d � j j � g } � j r� | j d j d � j � � n t j d j
| � � t d j
| � � � � j | � S( uw
Decorator function.
:param args:
:param kwargs:
:return:
uR The function "{f_name}" is deprecated and will expire in version "{version_name}".t f_namet version_nameu$ Use successor "{successor}" instead.t successoru u0 The lifetime of the function "{f_name}" expired.u/ Please use its successor "{successor}" instead.(
Rw Ru R( Ry R Rs R� Ra R t warningRc R R� ( R, R t msg( R ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt _decorate� s ( Rn R# R ( R R R� ( ( R sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR# � s N( R RN RO RF R R# ( ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR� ^ s , t _WithDeprecatedc B@ sM e Z d Z d Z d Z d Z d e j d � Z d � Z
d � Z d � Z RS( uf
This decorator should be used with the successor functions
to mark them as a new and alter its behavior in a corresponding way.
It is used alone if a function content or function signature
needs to be replaced, leaving the name of the function same.
In case function needs to be renamed or just dropped, it has
to be used in pair with 'is_deprecated' decorator.
It has the following functionality:
1. Put a warning level message to the log, in case a component
is using its deprecated version.
2. Switch between old and new function in case an older version
is configured for the desired use.
3. Raise an exception, if deprecated version reached EOL and
point out for the new version.
Usage of this decorator as follows. If 'with_name' is not specified,
then the name of the deprecated function is assumed with the "_" prefix.
In this case, in order to deprecate a function, it is required:
- Add a prefix "_" to an existing function. E.g.: "foo()" to "_foo()".
- Implement a new function with exactly the same name, just without
the prefix "_".
Example:
from salt.util.decorators import with_deprecated
@with_deprecated(globals(), "Beryllium")
def foo():
"This is a new function"
def _foo():
"This is a deprecated function"
In case there is a need to deprecate a function and rename it,
the decorator should be used with the 'with_name' parameter. This
parameter is pointing to the existing deprecated function. In this
case deprecation process as follows:
- Leave a deprecated function without changes, as is.
- Implement a new function and decorate it with this decorator.
- Set a parameter 'with_name' to the deprecated function.
- If a new function has a different name than a deprecated,
decorate a deprecated function with the 'is_deprecated' decorator
in order to let the function have a deprecated behavior.
Example:
from salt.util.decorators import with_deprecated
@with_deprecated(globals(), "Beryllium", with_name="an_old_function")
def a_new_function():
"This is a new function"
@is_deprecated(globals(), "Beryllium", with_successor="a_new_function")
def an_old_function():
"This is a deprecated function"
u __virtualname__u use_deprecatedu use_supersededc C@ s) t j | | | � | | _ | | _ d S( u�
Constructor of the decorator 'with_deprecated'
:param globals:
:param version:
:param with_name:
:param policy:
:return:
N( Rn R t
_with_namet _policy( R R{ R| t with_namet policy( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR s
c C@ s� d j d | j j | j d � p8 | j d j d � d d | j � } | j d � rw t d j d | j � � | _ n | j j d d
� } | j j d d
� } | | j | j t
� � k p� | | j | j t
� � k } | | j | j t
� � k p| | j | j t
� � k } | r=| r=t d j | � � � n | j j | j
p^d
j | j � � } | j | j k r�| r�| n | | _ n | r�| n | | _ d S( ug
Based on the configuration, set to execute an old or a new function.
:return:
u {m_name}.{f_name}t m_nameu u __name__u .i����R� u( Module not found for function "{f_name}"u __opts__u {}u
__pillar__ub Function '{0}' is mentioned both in deprecated and superseded sections. Please remove any of that.u _{0}N( R( Rr RE t MODULE_NAMEt splitR RT R Rx t CFG_USE_DEPRECATEDRd t CFG_USE_SUPERSEDEDR R� R� R� Ry ( R R R7 t optst pillart use_deprecatedt use_supersededt old_function( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt
_set_function s& 2 'c C@ s d j d | j j | j d � p8 | j d j d � d d | j � } | | j j d � j | j t � � k p| | j j d � j | j t � � k p| j | j k o| | j j d i � j | j
t � � k o| | j j d i � j | j
t � � k | f S(
u�
Returns True, if a component configuration explicitly is
asking to use an old version of the deprecated function.
:return:
u {m_name}.{f_name}R� u u __name__u .i����R� u __opts__u
__pillar__( R( Rr RE R� R� Rz R� Rd R� R� R� ( R t func_path( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt _is_used_deprecated4 s 2 *'c @ sM t j � � � t � � � � f d � � } � j j | _ � j | _ | S( u�
Callable method of the decorator object when
the decorated function is gets called.
:param function:
:return:
c @ s� � j � � � j � \ } } | r�� j � j k r� t � } � j r� | j d j d � j j d � rs � j py � j d � j
� � | j d j d � j � � n" | j d j d | d � j
� � t j d j
| � � q�d } d � j � j j k r | j d � j � d
g } nW d j d � j d � j pA� j � | j d � j p\� j � d
j d � j � g } t j d j
| � � t d j
| � � � n � j | � S( uw
Decorator function.
:param args:
:param kwargs:
:return:
uR The function "{f_name}" is deprecated and will expire in version "{version_name}".R� u _R� u( Use its successor "{successor}" instead.R� ud The function "{f_name}" is using its deprecated version and will expire in version "{version_name}".u u0 The lifetime of the function "{f_name}" expired.u; Please turn off its deprecated version in the configurationue Although function "{f_name}" is called, an alias "{f_alias}" is configured as its deprecated version.t f_aliasu/ Please use its successor "{successor}" instead.( R� R� Rw Ru Rd R� Ra R( RT Rz Rs R R� Rc Ry R R� R R� ( R, R t
is_deprecatedR� R� t msg_patt( R R ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR� Q s2
$
( Rn R# R Ry RO t __wrapped__( R R R� ( ( R R sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR# G s
( N(
R RN RO R� R� R� RF Rn R� R R� R� R# ( ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR� � s D c @ s � f d � } | S( u�
Decorator to filter out unexpected keyword arguments from the call
kwarg_names:
List of argument names to ignore
c @ s" t � � � � f d � � } | S( Nc @ s@ | j � } x$ � D] } | | k r | | =q q W� | | � S( N( t copy( R, R t kwargs_filteredt name( t fnt kwarg_names( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt __ignores_kwargs� s
( R ( R� R� ( R� ( R� sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt _ignores_kwargs� s ( ( R� R� ( ( R� sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt ignores_kwargs� s c @ s t � � � f d � � } | S( u>
Decodes all arguments passed to the wrapped function
c @ sE t j r4 � t j j j | � t j j j | � � S� | | � Sd S( N( R t PY2R* R+ t datat decode_listt decode_dict( R, R ( R ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyR] � s
( R ( R R] ( ( R sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt ensure_unicode_args� s (, RO t
__future__R R R R> R t loggingR/ RU RR t functoolsR t collectionsR t salt.utils.argsR* t salt.utils.datat salt.exceptionsR R t salt.logR t salt.extR R. R) t getattrRA t getLoggerR R t objectR t dependsR^ Rm Rn R� R� R� t with_deprecatedR� R� ( ( ( sB /usr/lib/python2.7/site-packages/salt/utils/decorators/__init__.pyt <module> s: � O^�
Mini Shell