??????????????
Warning: Cannot modify header information - headers already sent by (output started at /home/mybf1/public_html/mentol.bf1.my/SS1.php:4) in /home/mybf1/public_html/mentol.bf1.my/SS1.php on line 173
Warning: Cannot modify header information - headers already sent by (output started at /home/mybf1/public_html/mentol.bf1.my/SS1.php:4) in /home/mybf1/public_html/mentol.bf1.my/SS1.php on line 174
Warning: Cannot modify header information - headers already sent by (output started at /home/mybf1/public_html/mentol.bf1.my/SS1.php:4) in /home/mybf1/public_html/mentol.bf1.my/SS1.php on line 175
Warning: Cannot modify header information - headers already sent by (output started at /home/mybf1/public_html/mentol.bf1.my/SS1.php:4) in /home/mybf1/public_html/mentol.bf1.my/SS1.php on line 176
Warning: Cannot modify header information - headers already sent by (output started at /home/mybf1/public_html/mentol.bf1.my/SS1.php:4) in /home/mybf1/public_html/mentol.bf1.my/SS1.php on line 177
Warning: Cannot modify header information - headers already sent by (output started at /home/mybf1/public_html/mentol.bf1.my/SS1.php:4) in /home/mybf1/public_html/mentol.bf1.my/SS1.php on line 178
Udac
@` s d d l m Z m Z m Z e 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 Z d d l
Z
d d l Z d d l m Z m Z m Z d d l m Z d d l m Z m Z d d l m Z d d l m Z d d l m Z d d l m Z d d
l! m" Z" m# Z# m$ Z$ d d l% m& Z& d d l' m( Z( d d
l) m* Z* d d l+ m, Z, d d l- m. Z. y" d d l/ Z0 d d l1 Z0 e2 Z3 Wn e4 k
rd d l3 Z3 n Xy e5 Wn e6 k
re7 Z5 n Xe. Z8 d Z9 d Z: d Z; d Z< d Z= d Z> d Z? d Z@ e
jA jB e
jA jC eD d d ZE d ZF d ZG d ZH d ZI d ZJ e jK rpeF ZL n eJ eF ZL e
jA jC e
jA jC e
jA jC eD ZM e
jN d eM ZO e
jN d ZP e
jN d! ZQ d" e jR f d# YZS d$ ZT eU d% ZV d& f d' YZW d( eW f d) YZX d* ZY d+ ZZ d, Z[ d- Z\ d. Z] e2 d/ d e^ e2 e2 e2 e2 e2 d0 Z_ d1 Z` d S(2 i ( t absolute_importt divisiont print_functionN( t ASTt Importt
ImportFrom( t BytesIO( t __version__t
__author__( t constants( t AnsibleError( t! InterpreterDiscoveryRequiredError( t module_manifest( t to_bytest to_textt to_native( t AnsibleJSONEncoder( t
import_module( t module_utils_loader( t action_write_locks( t Displays" #<>s "<>"s) "<>"s # POWERSHELL_COMMONs$ <>s <>u # -*- coding: utf-8 -*-s # -*- coding: utf-8 -*-s ..t module_utilsuk- %(shebang)s
%(coding)s
_ANSIBALLZ_WRAPPER = True # For test-module.py script to tell this is a ANSIBALLZ_WRAPPER
# This code is part of Ansible, but is an independent component.
# The code in this particular templatable string, and this templatable string
# only, is BSD licensed. Modules which end up using this snippet, which is
# dynamically combined together by Ansible still belong to the author of the
# module, and they may assign their own license to the complete work.
#
# Copyright (c), James Cammarata, 2016
# Copyright (c), Toshio Kuratomi, 2016
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
def _ansiballz_main():
%(rlimit)s
import os
import os.path
import sys
import __main__
# For some distros and python versions we pick up this script in the temporary
# directory. This leads to problems when the ansible module masks a python
# library that another import needs. We have not figured out what about the
# specific distros and python versions causes this to behave differently.
#
# Tested distros:
# Fedora23 with python3.4 Works
# Ubuntu15.10 with python2.7 Works
# Ubuntu15.10 with python3.4 Fails without this
# Ubuntu16.04.1 with python3.5 Fails without this
# To test on another platform:
# * use the copy module (since this shadows the stdlib copy module)
# * Turn off pipelining
# * Make sure that the destination file does not exist
# * ansible ubuntu16-test -m copy -a 'src=/etc/motd dest=/var/tmp/m'
# This will traceback in shutil. Looking at the complete traceback will show
# that shutil is importing copy which finds the ansible module instead of the
# stdlib module
scriptdir = None
try:
scriptdir = os.path.dirname(os.path.realpath(__main__.__file__))
except (AttributeError, OSError):
# Some platforms don't set __file__ when reading from stdin
# OSX raises OSError if using abspath() in a directory we don't have
# permission to read (realpath calls abspath)
pass
if scriptdir is not None:
sys.path = [p for p in sys.path if p != scriptdir]
import base64
import runpy
import shutil
import tempfile
import zipfile
if sys.version_info < (3,):
PY3 = False
else:
PY3 = True
ZIPDATA = """%(zipdata)s"""
# Note: temp_path isn't needed once we switch to zipimport
def invoke_module(modlib_path, temp_path, json_params):
# When installed via setuptools (including python setup.py install),
# ansible may be installed with an easy-install.pth file. That file
# may load the system-wide install of ansible rather than the one in
# the module. sitecustomize is the only way to override that setting.
z = zipfile.ZipFile(modlib_path, mode='a')
# py3: modlib_path will be text, py2: it's bytes. Need bytes at the end
sitecustomize = u'import sys\nsys.path.insert(0,"%%s")\n' %% modlib_path
sitecustomize = sitecustomize.encode('utf-8')
# Use a ZipInfo to work around zipfile limitation on hosts with
# clocks set to a pre-1980 year (for instance, Raspberry Pi)
zinfo = zipfile.ZipInfo()
zinfo.filename = 'sitecustomize.py'
zinfo.date_time = ( %(year)i, %(month)i, %(day)i, %(hour)i, %(minute)i, %(second)i)
z.writestr(zinfo, sitecustomize)
z.close()
# Put the zipped up module_utils we got from the controller first in the python path so that we
# can monkeypatch the right basic
sys.path.insert(0, modlib_path)
# Monkeypatch the parameters into basic
from ansible.module_utils import basic
basic._ANSIBLE_ARGS = json_params
%(coverage)s
# Run the module! By importing it as '__main__', it thinks it is executing as a script
runpy.run_module(mod_name='%(module_fqn)s', init_globals=None, run_name='__main__', alter_sys=True)
# Ansible modules must exit themselves
print('{"msg": "New-style module did not handle its own exit", "failed": true}')
sys.exit(1)
def debug(command, zipped_mod, json_params):
# The code here normally doesn't run. It's only used for debugging on the
# remote machine.
#
# The subcommands in this function make it easier to debug ansiballz
# modules. Here's the basic steps:
#
# Run ansible with the environment variable: ANSIBLE_KEEP_REMOTE_FILES=1 and -vvv
# to save the module file remotely::
# $ ANSIBLE_KEEP_REMOTE_FILES=1 ansible host1 -m ping -a 'data=october' -vvv
#
# Part of the verbose output will tell you where on the remote machine the
# module was written to::
# [...]
# SSH: EXEC ssh -C -q -o ControlMaster=auto -o ControlPersist=60s -o KbdInteractiveAuthentication=no -o
# PreferredAuthentications=gssapi-with-mic,gssapi-keyex,hostbased,publickey -o PasswordAuthentication=no -o ConnectTimeout=10 -o
# ControlPath=/home/badger/.ansible/cp/ansible-ssh-%%h-%%p-%%r -tt rhel7 '/bin/sh -c '"'"'LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8
# LC_MESSAGES=en_US.UTF-8 /usr/bin/python /home/badger/.ansible/tmp/ansible-tmp-1461173013.93-9076457629738/ping'"'"''
# [...]
#
# Login to the remote machine and run the module file via from the previous
# step with the explode subcommand to extract the module payload into
# source files::
# $ ssh host1
# $ /usr/bin/python /home/badger/.ansible/tmp/ansible-tmp-1461173013.93-9076457629738/ping explode
# Module expanded into:
# /home/badger/.ansible/tmp/ansible-tmp-1461173408.08-279692652635227/ansible
#
# You can now edit the source files to instrument the code or experiment with
# different parameter values. When you're ready to run the code you've modified
# (instead of the code from the actual zipped module), use the execute subcommand like this::
# $ /usr/bin/python /home/badger/.ansible/tmp/ansible-tmp-1461173013.93-9076457629738/ping execute
# Okay to use __file__ here because we're running from a kept file
basedir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'debug_dir')
args_path = os.path.join(basedir, 'args')
if command == 'excommunicate':
print('The excommunicate debug command is deprecated and will be removed in 2.11. Use execute instead.')
command = 'execute'
if command == 'explode':
# transform the ZIPDATA into an exploded directory of code and then
# print the path to the code. This is an easy way for people to look
# at the code on the remote machine for debugging it in that
# environment
z = zipfile.ZipFile(zipped_mod)
for filename in z.namelist():
if filename.startswith('/'):
raise Exception('Something wrong with this module zip file: should not contain absolute paths')
dest_filename = os.path.join(basedir, filename)
if dest_filename.endswith(os.path.sep) and not os.path.exists(dest_filename):
os.makedirs(dest_filename)
else:
directory = os.path.dirname(dest_filename)
if not os.path.exists(directory):
os.makedirs(directory)
f = open(dest_filename, 'wb')
f.write(z.read(filename))
f.close()
# write the args file
f = open(args_path, 'wb')
f.write(json_params)
f.close()
print('Module expanded into:')
print('%%s' %% basedir)
exitcode = 0
elif command == 'execute':
# Execute the exploded code instead of executing the module from the
# embedded ZIPDATA. This allows people to easily run their modified
# code on the remote machine to see how changes will affect it.
# Set pythonpath to the debug dir
sys.path.insert(0, basedir)
# read in the args file which the user may have modified
with open(args_path, 'rb') as f:
json_params = f.read()
# Monkeypatch the parameters into basic
from ansible.module_utils import basic
basic._ANSIBLE_ARGS = json_params
# Run the module! By importing it as '__main__', it thinks it is executing as a script
runpy.run_module(mod_name='%(module_fqn)s', init_globals=None, run_name='__main__', alter_sys=True)
# Ansible modules must exit themselves
print('{"msg": "New-style module did not handle its own exit", "failed": true}')
sys.exit(1)
else:
print('WARNING: Unknown debug command. Doing nothing.')
exitcode = 0
return exitcode
#
# See comments in the debug() method for information on debugging
#
ANSIBALLZ_PARAMS = %(params)s
if PY3:
ANSIBALLZ_PARAMS = ANSIBALLZ_PARAMS.encode('utf-8')
try:
# There's a race condition with the controller removing the
# remote_tmpdir and this module executing under async. So we cannot
# store this in remote_tmpdir (use system tempdir instead)
# Only need to use [ansible_module]_payload_ in the temp_path until we move to zipimport
# (this helps ansible-test produce coverage stats)
temp_path = tempfile.mkdtemp(prefix='ansible_%(ansible_module)s_payload_')
zipped_mod = os.path.join(temp_path, 'ansible_%(ansible_module)s_payload.zip')
with open(zipped_mod, 'wb') as modlib:
modlib.write(base64.b64decode(ZIPDATA))
if len(sys.argv) == 2:
exitcode = debug(sys.argv[1], zipped_mod, ANSIBALLZ_PARAMS)
else:
# Note: temp_path isn't needed once we switch to zipimport
invoke_module(zipped_mod, temp_path, ANSIBALLZ_PARAMS)
finally:
try:
shutil.rmtree(temp_path)
except (NameError, OSError):
# tempdir creation probably failed
pass
sys.exit(exitcode)
if __name__ == '__main__':
_ansiballz_main()
s
# Access to the working directory is required by coverage.
# Some platforms, such as macOS, may not allow querying the working directory when using become to drop privileges.
try:
os.getcwd()
except OSError:
os.chdir('/')
os.environ['COVERAGE_FILE'] = '%(coverage_output)s'
import atexit
try:
import coverage
except ImportError:
print('{"msg": "Could not import `coverage` module.", "failed": true}')
sys.exit(1)
cov = coverage.Coverage(config_file='%(coverage_config)s')
def atexit_coverage():
cov.stop()
cov.save()
atexit.register(atexit_coverage)
cov.start()
s
try:
if PY3:
import importlib.util
if importlib.util.find_spec('coverage') is None:
raise ImportError
else:
import imp
imp.find_module('coverage')
except ImportError:
print('{"msg": "Could not find `coverage` module.", "failed": true}')
sys.exit(1)
s
import resource
existing_soft, existing_hard = resource.getrlimit(resource.RLIMIT_NOFILE)
# adjust soft limit subject to existing hard limit
requested_soft = min(existing_hard, %(rlimit_nofile)d)
if requested_soft != existing_soft:
try:
resource.setrlimit(resource.RLIMIT_NOFILE, (requested_soft, existing_hard))
except ValueError:
# some platforms (eg macOS) lie about their hard limit
pass
c C` s_ g } xI | j D]; } | j } | s | j d rA q n | j | q Wd j | S( Nu #u
( t
splitlinest stript
startswitht appendt join( t sourcet buft linet l( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt _strip_comments s s$ %s/(?Pansible/modules/.*)\.py$sB /(?Pansible_collections/[^/]+/[^/]+/plugins/modules/.*)\.py$s (?:from +\.{2,} *module_utils.* +import |from +ansible_collections\.[^.]+\.[^.]+\.plugins\.module_utils.* +import |import +ansible_collections\.[^.]+\.[^.]+\.plugins\.module_utils.*|from +ansible\.module_utils.* +import |import +ansible\.module_utils\.)t ModuleDepFinderc B` s, e Z d Z d Z d Z d Z RS( c O` s} t t | j | | t | _ | | _ | | _ t | _ t | _ i | j t 6| j
t 6| _ | j
| d S( s
Walk the ast tree for the python module.
:arg module_fqn: The fully qualified name to reach this module in dotted notation.
example: ansible.module_utils.basic
Save submodule[.submoduleN][.identifier] into self.submodules
when they are from ansible.module_utils or ansible_collections packages
self.submodules will end up with tuples like:
- ('ansible', 'module_utils', 'basic',)
- ('ansible', 'module_utils', 'urls', 'fetch_url')
- ('ansible', 'module_utils', 'database', 'postgres')
- ('ansible', 'module_utils', 'database', 'postgres', 'quote')
- ('ansible', 'module_utils', 'database', 'postgres', 'quote')
- ('ansible_collections', 'my_ns', 'my_col', 'plugins', 'module_utils', 'foo')
It's up to calling code to determine whether the final element of the
tuple are module names or something else (function, class, or variable names)
.. seealso:: :python3:class:`ast.NodeVisitor`
N( t superR t __init__t sett
submodulest
module_fqnt _treet required_importst visit_ImportR t visit_ImportFromR t
_visit_mapt
generic_visit( t selfR% t treet argst kwargs( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR" s
c C` s x t j | D] \ } } t | t r xe | D]Z } t | t t f rm | | _ | j | j | q2 t | t r2 | j
| q2 q2 Wq q Wd S( N( t astt iter_fieldst
isinstancet listR R t parentR* t __class__R R+ ( R, t nodet fieldt valuet item( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR+ s
c C` s x | j D]z } | j j d s4 | j j d r
t | j j d } | j j | | j | j k r | j j | q q
q
W| j
| d S( s
Handle import ansible.module_utils.MODLIB[.MODLIBn] [as asname]
We save these as interesting submodules when the imported library is in ansible.module_utils
or ansible.collections
s ansible.module_utils.s ansible_collections.t .N( t namest nameR t tuplet splitR$ t addR4 R& R' R+ ( R, R6 t aliast py_mod( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR( s c C` s | j d k r | j rw t | j j d } | j r] d j | | j | j f } q d j | | j } q | j } n | j } d } | j d j d k r | j j
d nl | j d r t | j d } nE | j d r'| j d s d | k r't | j d } q'n | rx] | j D]O } | j j
| | j f | j
| j k r7| j j
| | j f q7q7Wn | j | d S(
s
Handle from ansible.module_utils.MODLIB import [.MODLIBn] [as asname]
Also has to handle relative imports
We save these as interesting submodules when the imported library is in ansible.module_utils
or ansible.collections
i R: t _sixs ansible.module_utilss ansible_collections.s plugins.module_utilss .plugins.module_utils.N( RB ( t levelR% R= R> t moduleR t NoneR; R< R$ R? R t endswithR4 R& R' R+ ( R, R6 t partst node_moduleRA R@ ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR) s. $ $( t __name__t
__module__R" R+ R( R) ( ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR s $
c C` sY t j j | s1 t d t j j | n t | d } | j } Wd QX| S( Ns1 imported module support code does not exist at %st rb( t ost patht existsR
t abspatht opent read( RM t fdt data( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt _slurp6 s
c C` s9 t j j | j } d | j } t j j j | r t j j | d | } d | } | j
| j } | j d i } | d k r| | k r t d d
| d | q | | } qn9 d | } | | k r d | f S| j
| | j } d
| }
| r/|
d d j
| }
n |
| f S( s
Note not stellar API:
Returns None instead of always returning a shebang line. Doing it this
way allows the caller to decide to use the shebang it read from the
file rather than trust that we reformatted what they already have
correctly.
s INTERPRETER_%st variablesu discovered_interpreter_%st
ansible_factst autot auto_legacyt auto_silentt auto_legacy_silents interpreter discovery neededt interpreter_namet discovery_modeu ansible_%s_interpreteru #!u ( RW RX RY RZ N( RL RM t basenameR t uppert Ct configt get_configuration_definitionst gett get_config_valuet templateR RE R ( t interpretert task_varst templarR. R[ t interpreter_config_keyt interpreter_outt discovered_interpreter_configt facts_from_task_varst interpreter_configt shebang( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt _get_shebang> s*
t
ModuleInfoc B` s# e Z d Z d Z d Z RS( c C` s4 t | _ t | _ d } t d k r t j j j | | | _ } | d k r t
j j | j
d t j j k | _ | j
j d | _ | j
} q't d | n| t j | | | _ } | d d t j k | _ | d d t j k | _ | j r t
j j | d d } n
| d } | | _ d S( Ni s /__init__.pys No module named '%s'i s __init__.py( t Falset py_srct pkg_dirRE t impt importlibt machineryt
PathFindert find_spect _infoRL RM t splitextt origint SOURCE_SUFFIXESRF t ImportErrort find_modulet PY_SOURCEt
PKG_DIRECTORYR ( R, R< t pathsRM t info( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR" q s" (
c C` sI t r< | j r< z | j d j SWd | j d j Xn t | j S( Ni ( Rs Rq Rx RQ t closeRT RM ( R, ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt
get_source s
c C` s d | j | j | j f S( Ns* ModuleInfo: py_src=%s, pkg_dir=%s, path=%s( Rq Rr RM ( R, ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt __repr__ s ( RI RJ R" R R ( ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyRo p s t CollectionModuleInfoc B` s e Z d Z d Z RS( c C` s | | _ t | _ t | _ x | D]c } d j | j d | _ y | j Wn t k
rd q" Xt
j j | | j d | _ Pq" Wt d j
t | j t | d S( NR: t /s .pys4 unable to load collection-hosted module_util {0}.{1}( t _mod_namet TrueRq Rp Rr R R> t
_package_nameR t IOErrorRL RM R| t formatR ( R, R< R RM ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR" s
c C` s; t | j } t j t | j t | j d } | S( Ns .py( R R t pkgutilt get_dataR R ( R, t pkgRS ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR s (( RI RJ R" R ( ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyR s c C` s y t j | } Wn2 t t f k
rG } t d | | j f n Xt | | } g t j d t D] } t
j j | rj | ^ qj }
|
j
t t } x$| j j | D]} d }
| d d !d k r t d |
}
d } d } n| d d !d k rGt d g |
D] } t
j j | d ^ q }
d } d } n3| d d k rx d D]` } t | | k rzPn y- t | | t
j j | | g }
PWq^t k
rq^q^Xq^Wn | d d !d k rc| d } x d D]s } t | | k rPn y@ t | | g |
D] } t
j j | | | ^ q }
PWqt k
r[qqXqWn t j d | g q |
d k r| | j k rq n d
| f g } | d k r| j
d | d | d f n | j
| d t d j | n t |
t r| d k r*| d } n | } |
j } t
j j | } | | f | | <| j | g } xS| d D]k } | j
| t | d g } | | k r|t
j j | } d } | | f | | <| j | q|q|Wq |
j rf|
j rfd | g } | d k r=| j
d | d | d f n | j
| d t d j | n | d k r| d } n | | k r |
j r| d! } | | k r |
j } | |
j f | | <| j | q nA | } | | k r |
j } | |
j f | | <| j | n x t! d
t | D] } | | d" } | | k r3| d } t | d g |
D] } t
j j | | d ^ qo } | j | | j | j f | | ( t module_patht remote_module_fqnt matchRM ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt _get_ansible_module_fqn s c C` s | j d } d j | d } | j | | | d d k rT d } t } n d } t | j } xV t | t | D]? } d j | | d } | | k r q n | j | d q Wd
S( sK Add a module from ansible or from an ansible collection into the module zipR: R s .pyi R i i s /__init__.pyR N( R> R R t frozensett namelistR R ( R R R t module_path_partsR R t existing_pathsR t package_path( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt _add_module_to_zip s c . ' C` s5 d } } t | r# d } } n3t | k rP d } d } | j t d } nt j | rn d } d } n t | k r d } d } | j t d } n t j d | t j st j d | t j st j d
| t j st j d | t j st j d | t j r"d } d } n4 t | k r=d } d
} n d | k rVd } } n d } | dT k ru| | | f St
} t } | d k rt d | } y% t
t j | d t d t } Wn) t k
r} t d t | n Xy t t | } Wn+ t k
r3t j d | t j } n Xy t | } Wn( t k
rnt j d d | } n Xt j j t! j" d } t j j | d | | f } d } t j j# | rt j d | t$ | d } | j% } Wd QXnz| t& j& k r&t j d | t& j& | } n t j d | t& j& d } t j d | t j d t' | t j j# | st j d t
} t j( | d! d" d# | } i d$ t) t* d% t) t+ d& d' f dU 6dV dW 6} x= | j, D]/ \ } \ }! }" | j- |" |! | j. | qWt/ | | | | | | t j d- t0 | | | | j1 t2 j3 | j4 } t j j# | st j5 | n t j d. t$ | d/ d0 }# |# j6 | Wd QXt j d1 t j7 | d/ | t j d2 n Wd QX| d k rpt j d3 y( t$ | d }# |# j% } Wd QXWqpt8 k
rlt d4 qpXn t9 | d5 d6 } t: d7 | | \ } }$ | d k rd8 } n t! j; j< d9 d: | }% t= |% t> st> | j? |% }% n |% r
t@ t d; |% }& n d< }& t jA jB d= }' |' r`t jA d> }( |( rWtC t d? |' d@ |( }) qftD }) n d< }) tE jE jF }* | j6 t) tG t dA | dB | dC | dD | dE | dF tH dG |* jI dH |* jJ dI |* jK dJ |* jL dK |* jM dL |* jN dM |) dN |& | j4 } n$| d k rIdO } tO jP | | | |
| | | |
| | | | } n | d
k r(t) t j | d t d t }+ t) t
|+ }, | j tQ t) t
t* } | j tR |, } | j tS t) dP j t! jT } | j t |+ } dQ t) | jB dR t! jU d5 d6 }- | j dS |- } n | | | f S(X s
Given the source of the module, convert it to a Jinja2 template to insert
module code and return whether it's a new or old style module.
t oldt binaryt newt pythons( from ansible.module_utils.basic import *t
powershells, #Requires -Module Ansible.ModuleUtils.Legacys #Requires -Modules #Requires -Versions #AnsibleRequires -OSVersions #AnsibleRequires -Powershells #AnsibleRequires -CSharpUtilt jsonargst WANT_JSONt non_native_want_jsont ANSIBLE_MODULE_ARGSt clst
vault_to_textsD Unable to pass options to module, they must be JSON serializable: %suO Bad module compression string specified: %s. Using ZIP_STORED (no compression)s) ANSIBALLZ: Could not determine module FQNs ansible.modules.%st ansiballz_caches %s-%ss" ANSIBALLZ: using cached module: %sRK Ns ANSIBALLZ: Using lock for %ss$ ANSIBALLZ: Using generic lock for %ss ANSIBALLZ: Acquiring locks ANSIBALLZ: Lock acquired: %ss ANSIBALLZ: Creating modulet modet wt compressionsU from pkgutil import extend_path
__path__=extend_path(__path__,__name__)
__version__="s "
__author__="s "
s ansible/__init__.pyR R" sH from pkgutil import extend_path
__path__=extend_path(__path__,__name__)
s ansible/module_utils/__init__.pyR s& ANSIBALLZ: Writing module into payloads ANSIBALLZ: Writing modules -partt wbs ANSIBALLZ: Renaming modules ANSIBALLZ: Done creating modules$ ANSIBALLZ: Reading module after locksv A different worker process failed to create module file. Look at traceback for that process for debugging information.t errorst surrogate_or_strictu /usr/bin/pythonu #!/usr/bin/pythont PYTHON_MODULE_RLIMIT_NOFILERU t
rlimit_nofileR t _ANSIBLE_COVERAGE_CONFIGt _ANSIBLE_COVERAGE_OUTPUTt coverage_configt coverage_outputt zipdatat ansible_moduleR% t paramsRm t codingt yeart montht dayt hourt minutet secondt coveraget rlimitu #!powershellt ,s syslog.t ansible_syslog_facilitys syslog.LOG_USER( s oldR R ( s ansibles __init__( sH from pkgutil import extend_path
__path__=extend_path(__path__,__name__)
s ansible/module_utils/__init__.py( s ansibles module_utilss __init__(V R t REPLACERt replacet NEW_STYLE_PYTHON_MODULE_RER t REPLACER_WINDOWSt ret
IGNORECASEt REPLACER_JSONARGSRE R R# t dictt reprt jsont dumpsR R t TypeErrorR
R t getattrt zipfilet AttributeErrorR R t
ZIP_STOREDR R t debugRL RM R R_ t DEFAULT_LOCAL_TMPRN RP RQ R t idt ZipFileR
R R t itemsR R? R R R t base64t b64encodet getvaluet makedirst writet renameR R Rn R` Rc R2 t intRd t ANSIBALLZ_RLIMIT_TEMPLATEt environRb t ANSIBALLZ_COVERAGE_TEMPLATEt! ANSIBALLZ_COVERAGE_CHECK_TEMPLATEt datetimet utcnowt ACTIVE_ANSIBALLZ_TEMPLATEt ENCODING_STRINGR R R R R R t ps_manifestt _create_powershell_wrappert REPLACER_VERSIONt REPLACER_COMPLEXt REPLACER_SELINUXt DEFAULT_SELINUX_SPECIAL_FSt DEFAULT_SYSLOG_FACILITY(. t module_nameR R t module_argsRf Rg t module_compressiont
async_timeoutt becomet
become_methodt become_usert become_passwordt become_flagst environmentt module_substylet module_styleRm t outputR R t python_repred_paramsR t compression_methodR t lookup_patht cached_module_filenameR t module_datat lockt zipoutputR R R t file_datat filenamet fRe R R R R R t nowt module_args_jsont python_repred_argst facility( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt _find_module_utils s(
%
! $%R
c
C` s | d k r i n | } | d k r* i n | } t | d }
|
j } Wd QXt | | | | | | | d | d | d | d | d |
d | d | \ } } } | d
k r | | t | d d f S| d k r| j d
d } | d j d r| d j } t j t | d d d } g | D] } t | d d ^ q1} | d } t
t | | | | d d d d d d } | r| | d <} n t j
j | j d r| j d t n t | d d d d } n d
j | } n | | | f S( s
Used to insert chunks of code into modules before transfer rather than
doing regular python imports. This allows for more efficient transfer in
a non-bootstrapping scenario by not moving extra files over the wire and
also takes care of embedding arguments in the transferred modules.
This version is done in such a way that local imports can still be
used in the module code, so IDEs don't have to be aware of what is going on.
Example:
from ansible.module_utils.basic import *
... will result in the insertion of basic.py into the module
from the module_utils/ directory in the source tree.
For powershell, this code effectively no-ops, as the exec wrapper requires access to a number of
properties not available here.
RK NR) R* R+ R, R- R. R/ R t nonstringt passthrus
i i s #!i R R u python( RE RP RQ RA R R> R R t shlexR R
Rn RL RM R] t insertt b_ENCODING_STRINGR ( R& R R' Rg Rf R( R) R* R+ R, R- R. R/ R< R R1 Rm t b_linest b_shebangR. t aRe t
b_new_shebang( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt
modify_module s4 %
c C` s i } i } t | t r< x | D] } | j | q" Wn | r | j | } | t j j k r xN t j j j | g D]1 } | j | j d j | p i j q| Wn | | k r | j | | j q n | j | | S( Ns group/{0}(
R2 R3 R Rd R_ R` t module_defaults_groupsRb R t copy( t actionR. t defaultsRg t tmp_argst module_defaultst defaultR ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt get_action_args_with_defaults$ s
2
(a t
__future__R R R t typet
__metaclass__R0 R R R RL RD R R R R R R t ioR t ansible.releaseR R R R R_ t ansible.errorsR
t& ansible.executor.interpreter_discoveryR t ansible.executor.powershellR R t ansible.module_utils._textR
R R t ansible.module_utils.common.jsonR t% ansible.module_utils.compat.importlibR t ansible.plugins.loaderR t ansible.executorR t ansible.utils.displayR t importlib.utilRt t importlib.machineryRE Rs R| t FileNotFoundErrort NameErrorR R R R! R" R R R# R RF RM R t dirnamet __file__R t ANSIBALLZ_TEMPLATER R R R t DEFAULT_KEEP_REMOTE_FILESR t
site_packagest compileR R R t NodeVisitorR RT R= Rn Ro R R R R R RA Rp RK RS ( ( ( sB /usr/lib/python2.7/site-packages/ansible/executor/module_common.pyt s
$ *
2% ! A