diff --git a/.drone.jsonnet b/.drone.jsonnet index 169f6c8..d4d5ab6 100644 --- a/.drone.jsonnet +++ b/.drone.jsonnet @@ -52,7 +52,7 @@ local PipelineTesting = { commands: [ "pip install -r test-requirements.txt -qq", "pip install -qq .", - "bandit -r ./ansiblelater", + "bandit -r ./ansiblelater -x ./ansiblelater/tests", ], depends_on: [ "clone", diff --git a/.drone.yml b/.drone.yml index 1510271..0bc6e78 100644 --- a/.drone.yml +++ b/.drone.yml @@ -69,7 +69,7 @@ steps: commands: - pip install -r test-requirements.txt -qq - pip install -qq . - - bandit -r ./ansiblelater + - bandit -r ./ansiblelater -x ./ansiblelater/tests environment: PY_COLORS: 1 depends_on: diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000..d0f57f6 --- /dev/null +++ b/.flake8 @@ -0,0 +1,8 @@ +[flake8] +# Temp disable Docstring checks D101, D102, D103, D107 +ignore = E501, W503, F401, N813, D101, D102, D103, D107 +max-line-length = 100 +inline-quotes = double +exclude = .git,.tox,__pycache__,build,dist,tests,*.pyc,*.egg-info,.cache,.eggs +application-import-names = ansiblelater +format = ${cyan}%(path)s:%(row)d:%(col)d${reset}: ${red_bold}%(code)s${reset} %(text)s diff --git a/ansiblelater/command/candidates.py b/ansiblelater/command/candidates.py index 1bcf918..e0407cf 100644 --- a/ansiblelater/command/candidates.py +++ b/ansiblelater/command/candidates.py @@ -37,7 +37,6 @@ class Candidate(object): self.filetype = type(self).__name__.lower() self.expected_version = True self.standards = self._get_standards(settings, standards) - self.version = self._get_version(settings) try: with codecs.open(filename, mode="rb", encoding="utf-8") as f: @@ -46,26 +45,29 @@ class Candidate(object): except UnicodeDecodeError: self.binary = True + self.version = self._get_version(settings) + def _get_version(self, settings): - if isinstance(self, RoleFile): - parentdir = os.path.dirname(os.path.abspath(self.path)) - while parentdir != os.path.dirname(parentdir): - meta_file = os.path.join(parentdir, "meta", "main.yml") - if os.path.exists(meta_file): - path = meta_file - break - parentdir = os.path.dirname(parentdir) - else: - path = self.path - + path = self.path version = None - version_re = re.compile(r"^# Standards:\s*([\d.]+)") - with codecs.open(path, mode="rb", encoding="utf-8") as f: - for line in f: - match = version_re.match(line) - if match: - version = match.group(1) + if not self.binary: + if isinstance(self, RoleFile): + parentdir = os.path.dirname(os.path.abspath(self.path)) + while parentdir != os.path.dirname(parentdir): + meta_file = os.path.join(parentdir, "meta", "main.yml") + if os.path.exists(meta_file): + path = meta_file + break + parentdir = os.path.dirname(parentdir) + + version_re = re.compile(r"^# Standards:\s*([\d.]+)") + + with codecs.open(path, mode="rb", encoding="utf-8") as f: + for line in f: + match = version_re.match(line) + if match: + version = match.group(1) if not version: version = utils.standards_latest(self.standards) diff --git a/ansiblelater/settings.py b/ansiblelater/settings.py index 08203e0..bfef8fc 100644 --- a/ansiblelater/settings.py +++ b/ansiblelater/settings.py @@ -1,6 +1,5 @@ """Global settings object definition.""" -import logging import os import anyconfig @@ -58,7 +57,7 @@ class Settings(object): if tmp_dict.get("logging"): for adjustment in tmp_dict["logging"]["level"]: log_level = min(len(levels) - 1, max(log_level + adjustment, 0)) - tmp_dict["logging"]["level"] = logging.getLevelName(levels[log_level]) + tmp_dict["logging"]["level"] = levels[log_level] if len(tmp_dict["rules"]["files"]) == 0: tmp_dict["rules"]["files"] = "*" diff --git a/env_27/bin/activate b/env_27/bin/activate new file mode 100644 index 0000000..c44802c --- /dev/null +++ b/env_27/bin/activate @@ -0,0 +1,78 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + unset -f pydoc >/dev/null 2>&1 + + # reset old environment variables + # ! [ -z ${VAR+_} ] returns true if VAR is declared at all + if ! [ -z "${_OLD_VIRTUAL_PATH+_}" ] ; then + PATH="$_OLD_VIRTUAL_PATH" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then + PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH-}" ] || [ -n "${ZSH_VERSION-}" ] ; then + hash -r 2>/dev/null + fi + + if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then + PS1="$_OLD_VIRTUAL_PS1" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + if [ ! "${1-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="/Users/rkau2905/Devel/python/private/ansible-later/env_27" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +# unset PYTHONHOME if set +if ! [ -z "${PYTHONHOME+_}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then + _OLD_VIRTUAL_PS1="$PS1" + if [ "x" != x ] ; then + PS1="$PS1" + else + PS1="(`basename \"$VIRTUAL_ENV\"`) $PS1" + fi + export PS1 +fi + +# Make sure to unalias pydoc if it's already there +alias pydoc 2>/dev/null >/dev/null && unalias pydoc + +pydoc () { + python -m pydoc "$@" +} + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH-}" ] || [ -n "${ZSH_VERSION-}" ] ; then + hash -r 2>/dev/null +fi diff --git a/env_27/bin/activate.csh b/env_27/bin/activate.csh new file mode 100644 index 0000000..6858c40 --- /dev/null +++ b/env_27/bin/activate.csh @@ -0,0 +1,42 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . + +set newline='\ +' + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV "/Users/rkau2905/Devel/python/private/ansible-later/env_27" + +set _OLD_VIRTUAL_PATH="$PATH:q" +setenv PATH "$VIRTUAL_ENV:q/bin:$PATH:q" + + + +if ("" != "") then + set env_name = "" +else + set env_name = "$VIRTUAL_ENV:t:q" +endif + +# Could be in a non-interactive environment, +# in which case, $prompt is undefined and we wouldn't +# care about the prompt anyway. +if ( $?prompt ) then + set _OLD_VIRTUAL_PROMPT="$prompt:q" +if ( "$prompt:q" =~ *"$newline:q"* ) then + : +else + set prompt = "[$env_name:q] $prompt:q" +endif +endif + +unset env_name + +alias pydoc python -m pydoc + +rehash diff --git a/env_27/bin/activate.fish b/env_27/bin/activate.fish new file mode 100644 index 0000000..5eb7ac4 --- /dev/null +++ b/env_27/bin/activate.fish @@ -0,0 +1,76 @@ +# This file must be used using `source bin/activate.fish` *within a running fish ( http://fishshell.com ) session*. +# Do not run it directly. + +function deactivate -d 'Exit virtualenv mode and return to the normal environment.' + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + # Set an empty local `$fish_function_path` to allow the removal of `fish_prompt` using `functions -e`. + set -l fish_function_path + + # Erase virtualenv's `fish_prompt` and restore the original. + functions -e fish_prompt + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + set -e _OLD_FISH_PROMPT_OVERRIDE + end + + set -e VIRTUAL_ENV + + if test "$argv[1]" != 'nondestructive' + # Self-destruct! + functions -e pydoc + functions -e deactivate + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV "/Users/rkau2905/Devel/python/private/ansible-later/env_27" + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/bin" $PATH + +# Unset `$PYTHONHOME` if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +function pydoc + python -m pydoc $argv +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # Copy the current `fish_prompt` function as `_old_fish_prompt`. + functions -c fish_prompt _old_fish_prompt + + function fish_prompt + # Save the current $status, for fish_prompts that display it. + set -l old_status $status + + # Prompt override provided? + # If not, just prepend the environment name. + if test -n "" + printf '%s%s' "" (set_color normal) + else + printf '%s(%s) ' (set_color normal) (basename "$VIRTUAL_ENV") + end + + # Restore the original $status + echo "exit $old_status" | source + _old_fish_prompt + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" +end diff --git a/env_27/bin/activate.ps1 b/env_27/bin/activate.ps1 new file mode 100644 index 0000000..89dbec6 --- /dev/null +++ b/env_27/bin/activate.ps1 @@ -0,0 +1,150 @@ +# This file must be dot sourced from PoSh; you cannot run it +# directly. Do this: . ./activate.ps1 + +# FIXME: clean up unused vars. +$script:THIS_PATH = $myinvocation.mycommand.path +$script:BASE_DIR = split-path (resolve-path "$THIS_PATH/..") -Parent +$script:DIR_NAME = split-path $BASE_DIR -Leaf + +function global:deactivate ( [switch] $NonDestructive ){ + + if ( test-path variable:_OLD_VIRTUAL_PATH ) { + $env:PATH = $variable:_OLD_VIRTUAL_PATH + remove-variable "_OLD_VIRTUAL_PATH" -scope global + } + + if ( test-path function:_old_virtual_prompt ) { + $function:prompt = $function:_old_virtual_prompt + remove-item function:\_old_virtual_prompt + } + + if ($env:VIRTUAL_ENV) { + $old_env = split-path $env:VIRTUAL_ENV -leaf + remove-item env:VIRTUAL_ENV -erroraction silentlycontinue + } + + if ( !$NonDestructive ) { + # Self destruct! + remove-item function:deactivate + } +} + +# unset irrelevant variables +deactivate -nondestructive + +$VIRTUAL_ENV = $BASE_DIR +$env:VIRTUAL_ENV = $VIRTUAL_ENV + +$global:_OLD_VIRTUAL_PATH = $env:PATH +$env:PATH = "$env:VIRTUAL_ENV/bin:" + $env:PATH +if (! $env:VIRTUAL_ENV_DISABLE_PROMPT) { + function global:_old_virtual_prompt { "" } + $function:_old_virtual_prompt = $function:prompt + function global:prompt { + # Add a prefix to the current prompt, but don't discard it. + write-host "($(split-path $env:VIRTUAL_ENV -leaf)) " -nonewline + & $function:_old_virtual_prompt + } +} + +# SIG # Begin signature block +# MIISeAYJKoZIhvcNAQcCoIISaTCCEmUCAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB +# gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR +# AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUS5reBwSg3zOUwhXf2jPChZzf +# yPmggg6tMIIGcDCCBFigAwIBAgIBJDANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQG +# EwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERp +# Z2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2Vy +# dGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDcxMDI0MjIwMTQ2WhcNMTcxMDI0MjIw +# MTQ2WjCBjDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0ZC4xKzAp +# BgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcxODA2BgNV +# BAMTL1N0YXJ0Q29tIENsYXNzIDIgUHJpbWFyeSBJbnRlcm1lZGlhdGUgT2JqZWN0 +# IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyiOLIjUemqAbPJ1J +# 0D8MlzgWKbr4fYlbRVjvhHDtfhFN6RQxq0PjTQxRgWzwFQNKJCdU5ftKoM5N4YSj +# Id6ZNavcSa6/McVnhDAQm+8H3HWoD030NVOxbjgD/Ih3HaV3/z9159nnvyxQEckR +# ZfpJB2Kfk6aHqW3JnSvRe+XVZSufDVCe/vtxGSEwKCaNrsLc9pboUoYIC3oyzWoU +# TZ65+c0H4paR8c8eK/mC914mBo6N0dQ512/bkSdaeY9YaQpGtW/h/W/FkbQRT3sC +# pttLVlIjnkuY4r9+zvqhToPjxcfDYEf+XD8VGkAqle8Aa8hQ+M1qGdQjAye8OzbV +# uUOw7wIDAQABo4IB6TCCAeUwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC +# AQYwHQYDVR0OBBYEFNBOD0CZbLhLGW87KLjg44gHNKq3MB8GA1UdIwQYMBaAFE4L +# 7xqkQFulF2mHMMo0aEPQQa7yMD0GCCsGAQUFBwEBBDEwLzAtBggrBgEFBQcwAoYh +# aHR0cDovL3d3dy5zdGFydHNzbC5jb20vc2ZzY2EuY3J0MFsGA1UdHwRUMFIwJ6Al +# oCOGIWh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3Nmc2NhLmNybDAnoCWgI4YhaHR0 +# cDovL2NybC5zdGFydHNzbC5jb20vc2ZzY2EuY3JsMIGABgNVHSAEeTB3MHUGCysG +# AQQBgbU3AQIBMGYwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29t +# L3BvbGljeS5wZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29t +# L2ludGVybWVkaWF0ZS5wZGYwEQYJYIZIAYb4QgEBBAQDAgABMFAGCWCGSAGG+EIB +# DQRDFkFTdGFydENvbSBDbGFzcyAyIFByaW1hcnkgSW50ZXJtZWRpYXRlIE9iamVj +# dCBTaWduaW5nIENlcnRpZmljYXRlczANBgkqhkiG9w0BAQUFAAOCAgEAcnMLA3Va +# N4OIE9l4QT5OEtZy5PByBit3oHiqQpgVEQo7DHRsjXD5H/IyTivpMikaaeRxIv95 +# baRd4hoUcMwDj4JIjC3WA9FoNFV31SMljEZa66G8RQECdMSSufgfDYu1XQ+cUKxh +# D3EtLGGcFGjjML7EQv2Iol741rEsycXwIXcryxeiMbU2TPi7X3elbwQMc4JFlJ4B +# y9FhBzuZB1DV2sN2irGVbC3G/1+S2doPDjL1CaElwRa/T0qkq2vvPxUgryAoCppU +# FKViw5yoGYC+z1GaesWWiP1eFKAL0wI7IgSvLzU3y1Vp7vsYaxOVBqZtebFTWRHt +# XjCsFrrQBngt0d33QbQRI5mwgzEp7XJ9xu5d6RVWM4TPRUsd+DDZpBHm9mszvi9g +# VFb2ZG7qRRXCSqys4+u/NLBPbXi/m/lU00cODQTlC/euwjk9HQtRrXQ/zqsBJS6U +# J+eLGw1qOfj+HVBl/ZQpfoLk7IoWlRQvRL1s7oirEaqPZUIWY/grXq9r6jDKAp3L +# ZdKQpPOnnogtqlU4f7/kLjEJhrrc98mrOWmVMK/BuFRAfQ5oDUMnVmCzAzLMjKfG +# cVW/iMew41yfhgKbwpfzm3LBr1Zv+pEBgcgW6onRLSAn3XHM0eNtz+AkxH6rRf6B +# 2mYhLEEGLapH8R1AMAo4BbVFOZR5kXcMCwowggg1MIIHHaADAgECAgIEuDANBgkq +# hkiG9w0BAQUFADCBjDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0 +# ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcx +# ODA2BgNVBAMTL1N0YXJ0Q29tIENsYXNzIDIgUHJpbWFyeSBJbnRlcm1lZGlhdGUg +# T2JqZWN0IENBMB4XDTExMTIwMzE1MzQxOVoXDTEzMTIwMzE0NTgwN1owgYwxIDAe +# BgNVBA0TFzU4MTc5Ni1HaDd4Zkp4a3hRU0lPNEUwMQswCQYDVQQGEwJERTEPMA0G +# A1UECBMGQmVybGluMQ8wDQYDVQQHEwZCZXJsaW4xFjAUBgNVBAMTDUphbm5pcyBM +# ZWlkZWwxITAfBgkqhkiG9w0BCQEWEmphbm5pc0BsZWlkZWwuaW5mbzCCAiIwDQYJ +# KoZIhvcNAQEBBQADggIPADCCAgoCggIBAMcPeABYdN7nPq/AkZ/EkyUBGx/l2Yui +# Lfm8ZdLG0ulMb/kQL3fRY7sUjYPyn9S6PhqqlFnNoGHJvbbReCdUC9SIQYmOEjEA +# raHfb7MZU10NjO4U2DdGucj2zuO5tYxKizizOJF0e4yRQZVxpUGdvkW/+GLjCNK5 +# L7mIv3Z1dagxDKHYZT74HXiS4VFUwHF1k36CwfM2vsetdm46bdgSwV+BCMmZICYT +# IJAS9UQHD7kP4rik3bFWjUx08NtYYFAVOd/HwBnemUmJe4j3IhZHr0k1+eDG8hDH +# KVvPgLJIoEjC4iMFk5GWsg5z2ngk0LLu3JZMtckHsnnmBPHQK8a3opUNd8hdMNJx +# gOwKjQt2JZSGUdIEFCKVDqj0FmdnDMPfwy+FNRtpBMl1sz78dUFhSrnM0D8NXrqa +# 4rG+2FoOXlmm1rb6AFtpjAKksHRpYcPk2DPGWp/1sWB+dUQkS3gOmwFzyqeTuXpT +# 0juqd3iAxOGx1VRFQ1VHLLf3AzV4wljBau26I+tu7iXxesVucSdsdQu293jwc2kN +# xK2JyHCoZH+RyytrwS0qw8t7rMOukU9gwP8mn3X6mgWlVUODMcHTULjSiCEtvyZ/ +# aafcwjUbt4ReEcnmuZtWIha86MTCX7U7e+cnpWG4sIHPnvVTaz9rm8RyBkIxtFCB +# nQ3FnoQgyxeJAgMBAAGjggOdMIIDmTAJBgNVHRMEAjAAMA4GA1UdDwEB/wQEAwIH +# gDAuBgNVHSUBAf8EJDAiBggrBgEFBQcDAwYKKwYBBAGCNwIBFQYKKwYBBAGCNwoD +# DTAdBgNVHQ4EFgQUWyCgrIWo8Ifvvm1/YTQIeMU9nc8wHwYDVR0jBBgwFoAU0E4P +# QJlsuEsZbzsouODjiAc0qrcwggIhBgNVHSAEggIYMIICFDCCAhAGCysGAQQBgbU3 +# AQICMIIB/zAuBggrBgEFBQcCARYiaHR0cDovL3d3dy5zdGFydHNzbC5jb20vcG9s +# aWN5LnBkZjA0BggrBgEFBQcCARYoaHR0cDovL3d3dy5zdGFydHNzbC5jb20vaW50 +# ZXJtZWRpYXRlLnBkZjCB9wYIKwYBBQUHAgIwgeowJxYgU3RhcnRDb20gQ2VydGlm +# aWNhdGlvbiBBdXRob3JpdHkwAwIBARqBvlRoaXMgY2VydGlmaWNhdGUgd2FzIGlz +# c3VlZCBhY2NvcmRpbmcgdG8gdGhlIENsYXNzIDIgVmFsaWRhdGlvbiByZXF1aXJl +# bWVudHMgb2YgdGhlIFN0YXJ0Q29tIENBIHBvbGljeSwgcmVsaWFuY2Ugb25seSBm +# b3IgdGhlIGludGVuZGVkIHB1cnBvc2UgaW4gY29tcGxpYW5jZSBvZiB0aGUgcmVs +# eWluZyBwYXJ0eSBvYmxpZ2F0aW9ucy4wgZwGCCsGAQUFBwICMIGPMCcWIFN0YXJ0 +# Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MAMCAQIaZExpYWJpbGl0eSBhbmQg +# d2FycmFudGllcyBhcmUgbGltaXRlZCEgU2VlIHNlY3Rpb24gIkxlZ2FsIGFuZCBM +# aW1pdGF0aW9ucyIgb2YgdGhlIFN0YXJ0Q29tIENBIHBvbGljeS4wNgYDVR0fBC8w +# LTAroCmgJ4YlaHR0cDovL2NybC5zdGFydHNzbC5jb20vY3J0YzItY3JsLmNybDCB +# iQYIKwYBBQUHAQEEfTB7MDcGCCsGAQUFBzABhitodHRwOi8vb2NzcC5zdGFydHNz +# bC5jb20vc3ViL2NsYXNzMi9jb2RlL2NhMEAGCCsGAQUFBzAChjRodHRwOi8vYWlh +# LnN0YXJ0c3NsLmNvbS9jZXJ0cy9zdWIuY2xhc3MyLmNvZGUuY2EuY3J0MCMGA1Ud +# EgQcMBqGGGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tLzANBgkqhkiG9w0BAQUFAAOC +# AQEAhrzEV6zwoEtKjnFRhCsjwiPykVpo5Eiye77Ve801rQDiRKgSCCiW6g3HqedL +# OtaSs65Sj2pm3Viea4KR0TECLcbCTgsdaHqw2x1yXwWBQWZEaV6EB05lIwfr94P1 +# SFpV43zkuc+bbmA3+CRK45LOcCNH5Tqq7VGTCAK5iM7tvHwFlbQRl+I6VEL2mjpF +# NsuRjDOVrv/9qw/a22YJ9R7Y1D0vUSs3IqZx2KMUaYDP7H2mSRxJO2nADQZBtriF +# gTyfD3lYV12MlIi5CQwe3QC6DrrfSMP33i5Wa/OFJiQ27WPxmScYVhiqozpImFT4 +# PU9goiBv9RKXdgTmZE1PN0NQ5jGCAzUwggMxAgEBMIGTMIGMMQswCQYDVQQGEwJJ +# TDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0 +# YWwgQ2VydGlmaWNhdGUgU2lnbmluZzE4MDYGA1UEAxMvU3RhcnRDb20gQ2xhc3Mg +# MiBQcmltYXJ5IEludGVybWVkaWF0ZSBPYmplY3QgQ0ECAgS4MAkGBSsOAwIaBQCg +# eDAYBgorBgEEAYI3AgEMMQowCKACgAChAoAAMBkGCSqGSIb3DQEJAzEMBgorBgEE +# AYI3AgEEMBwGCisGAQQBgjcCAQsxDjAMBgorBgEEAYI3AgEVMCMGCSqGSIb3DQEJ +# BDEWBBRVGw0FDSiaIi38dWteRUAg/9Pr6DANBgkqhkiG9w0BAQEFAASCAgCInvOZ +# FdaNFzbf6trmFDZKMojyx3UjKMCqNjHVBbuKY0qXwFC/ElYDV1ShJ2CBZbdurydO +# OQ6cIQ0KREOCwmX/xB49IlLHHUxNhEkVv7HGU3EKAFf9IBt9Yr7jikiR9cjIsfHK +# 4cjkoKJL7g28yEpLLkHt1eo37f1Ga9lDWEa5Zq3U5yX+IwXhrUBm1h8Xr033FhTR +# VEpuSz6LHtbrL/zgJnCzJ2ahjtJoYevdcWiNXffosJHFaSfYDDbiNsPRDH/1avmb +# 5j/7BhP8BcBaR6Fp8tFbNGIcWHHGcjqLMnTc4w13b7b4pDhypqElBa4+lCmwdvv9 +# GydYtRgPz8GHeoBoKj30YBlMzRIfFYaIFGIC4Ai3UEXkuH9TxYohVbGm/W0Kl4Lb +# RJ1FwiVcLcTOJdgNId2vQvKc+jtNrjcg5SP9h2v/C4aTx8tyc6tE3TOPh2f9b8DL +# S+SbVArJpuJqrPTxDDoO1QNjTgLcdVYeZDE+r/NjaGZ6cMSd8db3EaG3ijD/0bud +# SItbm/OlNVbQOFRR76D+ZNgPcU5iNZ3bmvQQIg6aSB9MHUpIE/SeCkNl9YeVk1/1 +# GFULgNMRmIYP4KLvu9ylh5Gu3hvD5VNhH6+FlXANwFy07uXks5uF8mfZVxVCnodG +# xkNCx+6PsrA5Z7WP4pXcmYnMn97npP/Q9EHJWw== +# SIG # End signature block diff --git a/env_27/bin/activate_this.py b/env_27/bin/activate_this.py new file mode 100644 index 0000000..444d3fd --- /dev/null +++ b/env_27/bin/activate_this.py @@ -0,0 +1,36 @@ +"""By using execfile(this_file, dict(__file__=this_file)) you will +activate this virtualenv environment. + +This can be used when you must use an existing Python interpreter, not +the virtualenv bin/python +""" + +try: + __file__ +except NameError: + raise AssertionError( + "You must run this like execfile('path/to/activate_this.py', dict(__file__='path/to/activate_this.py'))" + ) +import os +import site +import sys + +old_os_path = os.environ.get("PATH", "") +os.environ["PATH"] = os.path.dirname(os.path.abspath(__file__)) + os.pathsep + old_os_path +base = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if sys.platform == "win32": + site_packages = os.path.join(base, "Lib", "site-packages") +else: + site_packages = os.path.join(base, "lib", "python%s" % sys.version[:3], "site-packages") +prev_sys_path = list(sys.path) + +site.addsitedir(site_packages) +sys.real_prefix = sys.prefix +sys.prefix = base +# Move the added items to the front of the path: +new_sys_path = [] +for item in list(sys.path): + if item not in prev_sys_path: + new_sys_path.append(item) + sys.path.remove(item) +sys.path[:0] = new_sys_path diff --git a/env_27/bin/ansible b/env_27/bin/ansible new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-config b/env_27/bin/ansible-config new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-config @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-connection b/env_27/bin/ansible-connection new file mode 100755 index 0000000..2efb2e7 --- /dev/null +++ b/env_27/bin/ansible-connection @@ -0,0 +1,328 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# Copyright: (c) 2017, Ansible Project +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) +from __future__ import (absolute_import, division, print_function) + +__metaclass__ = type +__requires__ = ['ansible'] + +try: + import pkg_resources +except Exception: + pass + +import fcntl +import hashlib +import os +import signal +import socket +import sys +import time +import traceback +import errno +import json + +from contextlib import contextmanager + +from ansible import constants as C +from ansible.module_utils._text import to_bytes, to_text +from ansible.module_utils.six import PY3 +from ansible.module_utils.six.moves import cPickle, StringIO +from ansible.module_utils.connection import Connection, ConnectionError, send_data, recv_data +from ansible.module_utils.service import fork_process +from ansible.playbook.play_context import PlayContext +from ansible.plugins.loader import connection_loader +from ansible.utils.path import unfrackpath, makedirs_safe +from ansible.utils.display import Display +from ansible.utils.jsonrpc import JsonRpcServer + + +def read_stream(byte_stream): + size = int(byte_stream.readline().strip()) + + data = byte_stream.read(size) + if len(data) < size: + raise Exception("EOF found before data was complete") + + data_hash = to_text(byte_stream.readline().strip()) + if data_hash != hashlib.sha1(data).hexdigest(): + raise Exception("Read {0} bytes, but data did not match checksum".format(size)) + + # restore escaped loose \r characters + data = data.replace(br'\r', b'\r') + + return data + + +@contextmanager +def file_lock(lock_path): + """ + Uses contextmanager to create and release a file lock based on the + given path. This allows us to create locks using `with file_lock()` + to prevent deadlocks related to failure to unlock properly. + """ + + lock_fd = os.open(lock_path, os.O_RDWR | os.O_CREAT, 0o600) + fcntl.lockf(lock_fd, fcntl.LOCK_EX) + yield + fcntl.lockf(lock_fd, fcntl.LOCK_UN) + os.close(lock_fd) + + +class ConnectionProcess(object): + ''' + The connection process wraps around a Connection object that manages + the connection to a remote device that persists over the playbook + ''' + def __init__(self, fd, play_context, socket_path, original_path, ansible_playbook_pid=None): + self.play_context = play_context + self.socket_path = socket_path + self.original_path = original_path + + self.fd = fd + self.exception = None + + self.srv = JsonRpcServer() + self.sock = None + + self.connection = None + self._ansible_playbook_pid = ansible_playbook_pid + + def start(self, variables): + try: + messages = list() + result = {} + + messages.append('control socket path is %s' % self.socket_path) + + # If this is a relative path (~ gets expanded later) then plug the + # key's path on to the directory we originally came from, so we can + # find it now that our cwd is / + if self.play_context.private_key_file and self.play_context.private_key_file[0] not in '~/': + self.play_context.private_key_file = os.path.join(self.original_path, self.play_context.private_key_file) + self.connection = connection_loader.get(self.play_context.connection, self.play_context, '/dev/null', + ansible_playbook_pid=self._ansible_playbook_pid) + self.connection.set_options(var_options=variables) + self.connection._connect() + + self.connection._socket_path = self.socket_path + self.srv.register(self.connection) + messages.extend(sys.stdout.getvalue().splitlines()) + messages.append('connection to remote device started successfully') + + self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self.sock.bind(self.socket_path) + self.sock.listen(1) + messages.append('local domain socket listeners started successfully') + except Exception as exc: + result['error'] = to_text(exc) + result['exception'] = traceback.format_exc() + finally: + result['messages'] = messages + self.fd.write(json.dumps(result)) + self.fd.close() + + def run(self): + try: + while self.connection.connected: + signal.signal(signal.SIGALRM, self.connect_timeout) + signal.signal(signal.SIGTERM, self.handler) + signal.alarm(self.connection.get_option('persistent_connect_timeout')) + + self.exception = None + (s, addr) = self.sock.accept() + signal.alarm(0) + + signal.signal(signal.SIGALRM, self.command_timeout) + while True: + data = recv_data(s) + if not data: + break + + signal.alarm(self.connection.get_option('persistent_command_timeout')) + resp = self.srv.handle_request(data) + signal.alarm(0) + + send_data(s, to_bytes(resp)) + + s.close() + + except Exception as e: + # socket.accept() will raise EINTR if the socket.close() is called + if hasattr(e, 'errno'): + if e.errno != errno.EINTR: + self.exception = traceback.format_exc() + else: + self.exception = traceback.format_exc() + + finally: + # allow time for any exception msg send over socket to receive at other end before shutting down + time.sleep(0.1) + + # when done, close the connection properly and cleanup the socket file so it can be recreated + self.shutdown() + + def connect_timeout(self, signum, frame): + msg = 'persistent connection idle timeout triggered, timeout value is %s secs.\nSee the timeout setting options in the Network Debug and ' \ + 'Troubleshooting Guide.' % self.connection.get_option('persistent_connect_timeout') + display.display(msg, log_only=True) + raise Exception(msg) + + def command_timeout(self, signum, frame): + msg = 'command timeout triggered, timeout value is %s secs.\nSee the timeout setting options in the Network Debug and Troubleshooting Guide.'\ + % self.connection.get_option('persistent_command_timeout') + display.display(msg, log_only=True) + raise Exception(msg) + + def handler(self, signum, frame): + msg = 'signal handler called with signal %s.' % signum + display.display(msg, log_only=True) + raise Exception(msg) + + def shutdown(self): + """ Shuts down the local domain socket + """ + lock_path = unfrackpath("%s/.ansible_pc_lock_%s" % os.path.split(self.socket_path)) + if os.path.exists(self.socket_path): + try: + if self.sock: + self.sock.close() + if self.connection: + self.connection.close() + except: + pass + finally: + if os.path.exists(self.socket_path): + os.remove(self.socket_path) + setattr(self.connection, '_socket_path', None) + setattr(self.connection, '_connected', False) + + if os.path.exists(lock_path): + os.remove(lock_path) + + display.display('shutdown complete', log_only=True) + + +def main(): + """ Called to initiate the connect to the remote device + """ + rc = 0 + result = {} + messages = list() + socket_path = None + + # Need stdin as a byte stream + if PY3: + stdin = sys.stdin.buffer + else: + stdin = sys.stdin + + # Note: update the below log capture code after Display.display() is refactored. + saved_stdout = sys.stdout + sys.stdout = StringIO() + + try: + # read the play context data via stdin, which means depickling it + vars_data = read_stream(stdin) + init_data = read_stream(stdin) + + if PY3: + pc_data = cPickle.loads(init_data, encoding='bytes') + variables = cPickle.loads(vars_data, encoding='bytes') + else: + pc_data = cPickle.loads(init_data) + variables = cPickle.loads(vars_data) + + play_context = PlayContext() + play_context.deserialize(pc_data) + display.verbosity = play_context.verbosity + + except Exception as e: + rc = 1 + result.update({ + 'error': to_text(e), + 'exception': traceback.format_exc() + }) + + if rc == 0: + ssh = connection_loader.get('ssh', class_only=True) + ansible_playbook_pid = sys.argv[1] + cp = ssh._create_control_path(play_context.remote_addr, play_context.port, play_context.remote_user, play_context.connection, ansible_playbook_pid) + + # create the persistent connection dir if need be and create the paths + # which we will be using later + tmp_path = unfrackpath(C.PERSISTENT_CONTROL_PATH_DIR) + makedirs_safe(tmp_path) + + socket_path = unfrackpath(cp % dict(directory=tmp_path)) + lock_path = unfrackpath("%s/.ansible_pc_lock_%s" % os.path.split(socket_path)) + + with file_lock(lock_path): + if not os.path.exists(socket_path): + messages.append('local domain socket does not exist, starting it') + original_path = os.getcwd() + r, w = os.pipe() + pid = fork_process() + + if pid == 0: + try: + os.close(r) + wfd = os.fdopen(w, 'w') + process = ConnectionProcess(wfd, play_context, socket_path, original_path, ansible_playbook_pid) + process.start(variables) + except Exception: + messages.append(traceback.format_exc()) + rc = 1 + + if rc == 0: + process.run() + else: + process.shutdown() + + sys.exit(rc) + + else: + os.close(w) + rfd = os.fdopen(r, 'r') + data = json.loads(rfd.read()) + messages.extend(data.pop('messages')) + result.update(data) + + else: + messages.append('found existing local domain socket, using it!') + conn = Connection(socket_path) + conn.set_options(var_options=variables) + pc_data = to_text(init_data) + try: + messages.extend(conn.update_play_context(pc_data)) + except Exception as exc: + # Only network_cli has update_play context, so missing this is + # not fatal e.g. netconf + if isinstance(exc, ConnectionError) and getattr(exc, 'code', None) == -32601: + pass + else: + result.update({ + 'error': to_text(exc), + 'exception': traceback.format_exc() + }) + + messages.append(sys.stdout.getvalue()) + result.update({ + 'messages': messages, + 'socket_path': socket_path + }) + + sys.stdout = saved_stdout + if 'exception' in result: + rc = 1 + sys.stderr.write(json.dumps(result)) + else: + rc = 0 + sys.stdout.write(json.dumps(result)) + + sys.exit(rc) + + +if __name__ == '__main__': + display = Display() + main() diff --git a/env_27/bin/ansible-console b/env_27/bin/ansible-console new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-console @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-doc b/env_27/bin/ansible-doc new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-doc @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-galaxy b/env_27/bin/ansible-galaxy new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-galaxy @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-inventory b/env_27/bin/ansible-inventory new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-inventory @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-later b/env_27/bin/ansible-later new file mode 100755 index 0000000..0643263 --- /dev/null +++ b/env_27/bin/ansible-later @@ -0,0 +1,12 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# EASY-INSTALL-ENTRY-SCRIPT: 'ansible-later','console_scripts','ansible-later' +__requires__ = 'ansible-later' +import re +import sys +from pkg_resources import load_entry_point + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit( + load_entry_point('ansible-later', 'console_scripts', 'ansible-later')() + ) diff --git a/env_27/bin/ansible-playbook b/env_27/bin/ansible-playbook new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-playbook @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-pull b/env_27/bin/ansible-pull new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-pull @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/ansible-vault b/env_27/bin/ansible-vault new file mode 100755 index 0000000..a717386 --- /dev/null +++ b/env_27/bin/ansible-vault @@ -0,0 +1,163 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__requires__ = ['ansible'] +try: + import pkg_resources +except Exception: + # Use pkg_resources to find the correct versions of libraries and set + # sys.path appropriately when there are multiversion installs. But we + # have code that better expresses the errors in the places where the code + # is actually used (the deps are optional for many code paths) so we don't + # want to fail here. + pass + +import os +import shutil +import sys +import traceback + +from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError +from ansible.module_utils._text import to_text + + +# Used for determining if the system is running a new enough python version +# and should only restrict on our documented minimum versions +_PY3_MIN = sys.version_info[:2] >= (3, 5) +_PY2_MIN = (2, 6) <= sys.version_info[:2] < (3,) +_PY_MIN = _PY3_MIN or _PY2_MIN +if not _PY_MIN: + raise SystemExit('ERROR: Ansible requires a minimum of Python2 version 2.6 or Python3 version 3.5. Current version: %s' % ''.join(sys.version.splitlines())) + + +class LastResort(object): + # OUTPUT OF LAST RESORT + def display(self, msg, log_only=None): + print(msg, file=sys.stderr) + + def error(self, msg, wrap_text=None): + print(msg, file=sys.stderr) + + +if __name__ == '__main__': + + display = LastResort() + + try: # bad ANSIBLE_CONFIG or config options can force ugly stacktrace + import ansible.constants as C + from ansible.utils.display import Display + except AnsibleOptionsError as e: + display.error(to_text(e), wrap_text=False) + sys.exit(5) + + cli = None + me = os.path.basename(sys.argv[0]) + + try: + display = Display() + display.debug("starting run") + + sub = None + target = me.split('-') + if target[-1][0].isdigit(): + # Remove any version or python version info as downstreams + # sometimes add that + target = target[:-1] + + if len(target) > 1: + sub = target[1] + myclass = "%sCLI" % sub.capitalize() + elif target[0] == 'ansible': + sub = 'adhoc' + myclass = 'AdHocCLI' + else: + raise AnsibleError("Unknown Ansible alias: %s" % me) + + try: + mycli = getattr(__import__("ansible.cli.%s" % sub, fromlist=[myclass]), myclass) + except ImportError as e: + # ImportError members have changed in py3 + if 'msg' in dir(e): + msg = e.msg + else: + msg = e.message + if msg.endswith(' %s' % sub): + raise AnsibleError("Ansible sub-program not implemented: %s" % me) + else: + raise + + try: + args = [to_text(a, errors='surrogate_or_strict') for a in sys.argv] + except UnicodeError: + display.error('Command line args are not in utf-8, unable to continue. Ansible currently only understands utf-8') + display.display(u"The full traceback was:\n\n%s" % to_text(traceback.format_exc())) + exit_code = 6 + else: + cli = mycli(args) + cli.parse() + exit_code = cli.run() + + except AnsibleOptionsError as e: + cli.parser.print_help() + display.error(to_text(e), wrap_text=False) + exit_code = 5 + except AnsibleParserError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 4 +# TQM takes care of these, but leaving comment to reserve the exit codes +# except AnsibleHostUnreachable as e: +# display.error(str(e)) +# exit_code = 3 +# except AnsibleHostFailed as e: +# display.error(str(e)) +# exit_code = 2 + except AnsibleError as e: + display.error(to_text(e), wrap_text=False) + exit_code = 1 + except KeyboardInterrupt: + display.error("User interrupted execution") + exit_code = 99 + except Exception as e: + if C.DEFAULT_DEBUG: + # Show raw stacktraces in debug mode, It also allow pdb to + # enter post mortem mode. + raise + have_cli_options = cli is not None and cli.options is not None + display.error("Unexpected Exception, this is probably a bug: %s" % to_text(e), wrap_text=False) + if not have_cli_options or have_cli_options and cli.options.verbosity > 2: + log_only = False + if hasattr(e, 'orig_exc'): + display.vvv('\nexception type: %s' % to_text(type(e.orig_exc))) + why = to_text(e.orig_exc) + if to_text(e) != why: + display.vvv('\noriginal msg: %s' % why) + else: + display.display("to see the full traceback, use -vvv") + log_only = True + display.display(u"the full traceback was:\n\n%s" % to_text(traceback.format_exc()), log_only=log_only) + exit_code = 250 + finally: + # Remove ansible tmpdir + shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) + + sys.exit(exit_code) diff --git a/env_27/bin/anyconfig_cli b/env_27/bin/anyconfig_cli new file mode 100755 index 0000000..3cc2676 --- /dev/null +++ b/env_27/bin/anyconfig_cli @@ -0,0 +1,10 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# -*- coding: utf-8 -*- +import re +import sys + +from anyconfig.cli import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/easy_install b/env_27/bin/easy_install new file mode 100755 index 0000000..9ec59ec --- /dev/null +++ b/env_27/bin/easy_install @@ -0,0 +1,11 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# -*- coding: utf-8 -*- +import re +import sys + +from setuptools.command.easy_install import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/easy_install-2.7 b/env_27/bin/easy_install-2.7 new file mode 100755 index 0000000..9ec59ec --- /dev/null +++ b/env_27/bin/easy_install-2.7 @@ -0,0 +1,11 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# -*- coding: utf-8 -*- +import re +import sys + +from setuptools.command.easy_install import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/flake8 b/env_27/bin/flake8 new file mode 100755 index 0000000..4d16934 --- /dev/null +++ b/env_27/bin/flake8 @@ -0,0 +1,10 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# -*- coding: utf-8 -*- +import re +import sys + +from flake8.main.cli import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/jsonschema b/env_27/bin/jsonschema new file mode 100755 index 0000000..66e7b79 --- /dev/null +++ b/env_27/bin/jsonschema @@ -0,0 +1,10 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# -*- coding: utf-8 -*- +import re +import sys + +from jsonschema.cli import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/pip b/env_27/bin/pip new file mode 100755 index 0000000..450656c --- /dev/null +++ b/env_27/bin/pip @@ -0,0 +1,11 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# -*- coding: utf-8 -*- +import re +import sys + +from pip._internal import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/pip2 b/env_27/bin/pip2 new file mode 100755 index 0000000..450656c --- /dev/null +++ b/env_27/bin/pip2 @@ -0,0 +1,11 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# -*- coding: utf-8 -*- +import re +import sys + +from pip._internal import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/pip2.7 b/env_27/bin/pip2.7 new file mode 100755 index 0000000..450656c --- /dev/null +++ b/env_27/bin/pip2.7 @@ -0,0 +1,11 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# -*- coding: utf-8 -*- +import re +import sys + +from pip._internal import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/pycodestyle b/env_27/bin/pycodestyle new file mode 100755 index 0000000..8d17079 --- /dev/null +++ b/env_27/bin/pycodestyle @@ -0,0 +1,10 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# -*- coding: utf-8 -*- +import re +import sys + +from pycodestyle import _main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(_main()) diff --git a/env_27/bin/pyflakes b/env_27/bin/pyflakes new file mode 100755 index 0000000..68e5ca1 --- /dev/null +++ b/env_27/bin/pyflakes @@ -0,0 +1,10 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# -*- coding: utf-8 -*- +import re +import sys + +from pyflakes.api import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/python b/env_27/bin/python new file mode 100755 index 0000000..9cbfb9e Binary files /dev/null and b/env_27/bin/python differ diff --git a/env_27/bin/python-config b/env_27/bin/python-config new file mode 100755 index 0000000..12dcf6d --- /dev/null +++ b/env_27/bin/python-config @@ -0,0 +1,78 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +import sys +import getopt +import sysconfig + +valid_opts = ['prefix', 'exec-prefix', 'includes', 'libs', 'cflags', + 'ldflags', 'help'] + +if sys.version_info >= (3, 2): + valid_opts.insert(-1, 'extension-suffix') + valid_opts.append('abiflags') +if sys.version_info >= (3, 3): + valid_opts.append('configdir') + + +def exit_with_usage(code=1): + sys.stderr.write("Usage: {0} [{1}]\n".format( + sys.argv[0], '|'.join('--'+opt for opt in valid_opts))) + sys.exit(code) + +try: + opts, args = getopt.getopt(sys.argv[1:], '', valid_opts) +except getopt.error: + exit_with_usage() + +if not opts: + exit_with_usage() + +pyver = sysconfig.get_config_var('VERSION') +getvar = sysconfig.get_config_var + +opt_flags = [flag for (flag, val) in opts] + +if '--help' in opt_flags: + exit_with_usage(code=0) + +for opt in opt_flags: + if opt == '--prefix': + print(sysconfig.get_config_var('prefix')) + + elif opt == '--exec-prefix': + print(sysconfig.get_config_var('exec_prefix')) + + elif opt in ('--includes', '--cflags'): + flags = ['-I' + sysconfig.get_path('include'), + '-I' + sysconfig.get_path('platinclude')] + if opt == '--cflags': + flags.extend(getvar('CFLAGS').split()) + print(' '.join(flags)) + + elif opt in ('--libs', '--ldflags'): + abiflags = getattr(sys, 'abiflags', '') + libs = ['-lpython' + pyver + abiflags] + libs += getvar('LIBS').split() + libs += getvar('SYSLIBS').split() + # add the prefix/lib/pythonX.Y/config dir, but only if there is no + # shared library in prefix/lib/. + if opt == '--ldflags': + if not getvar('Py_ENABLE_SHARED'): + libs.insert(0, '-L' + getvar('LIBPL')) + if not getvar('PYTHONFRAMEWORK'): + libs.extend(getvar('LINKFORSHARED').split()) + print(' '.join(libs)) + + elif opt == '--extension-suffix': + ext_suffix = sysconfig.get_config_var('EXT_SUFFIX') + if ext_suffix is None: + ext_suffix = sysconfig.get_config_var('SO') + print(ext_suffix) + + elif opt == '--abiflags': + if not getattr(sys, 'abiflags', None): + exit_with_usage() + print(sys.abiflags) + + elif opt == '--configdir': + print(sysconfig.get_config_var('LIBPL')) diff --git a/env_27/bin/python2 b/env_27/bin/python2 new file mode 120000 index 0000000..d8654aa --- /dev/null +++ b/env_27/bin/python2 @@ -0,0 +1 @@ +python \ No newline at end of file diff --git a/env_27/bin/python2.7 b/env_27/bin/python2.7 new file mode 120000 index 0000000..d8654aa --- /dev/null +++ b/env_27/bin/python2.7 @@ -0,0 +1 @@ +python \ No newline at end of file diff --git a/env_27/bin/unidiff b/env_27/bin/unidiff new file mode 100755 index 0000000..fa789bf --- /dev/null +++ b/env_27/bin/unidiff @@ -0,0 +1,68 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +from __future__ import print_function, unicode_literals + +import argparse +import codecs +import sys + +from unidiff import DEFAULT_ENCODING, PatchSet + + +PY2 = sys.version_info[0] == 2 +DESCRIPTION = """Unified diff metadata. + +Examples: + $ git diff | unidiff + $ hg diff | unidiff --show-diff + $ unidiff -f patch.diff + +""" + +def get_parser(): + parser = argparse.ArgumentParser( + formatter_class=argparse.RawDescriptionHelpFormatter, + description=DESCRIPTION) + parser.add_argument('--show-diff', action="store_true", default=False, + dest='show_diff', help='output diff to stdout') + parser.add_argument('-f', '--file', dest='diff_file', + type=argparse.FileType('r'), + help='if not specified, read diff data from stdin') + return parser + + +if __name__ == '__main__': + parser = get_parser() + args = parser.parse_args() + + encoding = DEFAULT_ENCODING + if args.diff_file: + diff_file = args.diff_file + else: + encoding = sys.stdin.encoding or encoding + diff_file = sys.stdin + + if PY2: + diff_file = codecs.getreader(encoding)(diff_file) + + patch = PatchSet(diff_file) + + if args.show_diff: + print(patch) + print() + + print('Summary') + print('-------') + additions = 0 + deletions = 0 + for f in patch: + additions += f.added + deletions += f.removed + print('%s:' % f.path, '+%d additions,' % f.added, + '-%d deletions' % f.removed) + + print() + print('%d modified file(s), %d added file(s), %d removed file(s)' % ( + len(patch.modified_files), len(patch.added_files), + len(patch.removed_files))) + print('Total: %d addition(s), %d deletion(s)' % (additions, deletions)) diff --git a/env_27/bin/wheel b/env_27/bin/wheel new file mode 100755 index 0000000..17f1449 --- /dev/null +++ b/env_27/bin/wheel @@ -0,0 +1,11 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python + +# -*- coding: utf-8 -*- +import re +import sys + +from wheel.cli import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/env_27/bin/yamllint b/env_27/bin/yamllint new file mode 100755 index 0000000..390cff6 --- /dev/null +++ b/env_27/bin/yamllint @@ -0,0 +1,10 @@ +#!/Users/rkau2905/Devel/python/private/ansible-later/env_27/bin/python +# -*- coding: utf-8 -*- +import re +import sys + +from yamllint.cli import run + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(run()) diff --git a/env_27/include/python2.7 b/env_27/include/python2.7 new file mode 120000 index 0000000..3fe034f --- /dev/null +++ b/env_27/include/python2.7 @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/include/python2.7 \ No newline at end of file diff --git a/env_27/lib/python2.7/UserDict.py b/env_27/lib/python2.7/UserDict.py new file mode 120000 index 0000000..b735f02 --- /dev/null +++ b/env_27/lib/python2.7/UserDict.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/UserDict.py \ No newline at end of file diff --git a/env_27/lib/python2.7/_abcoll.py b/env_27/lib/python2.7/_abcoll.py new file mode 120000 index 0000000..4a595bc --- /dev/null +++ b/env_27/lib/python2.7/_abcoll.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/_abcoll.py \ No newline at end of file diff --git a/env_27/lib/python2.7/_weakrefset.py b/env_27/lib/python2.7/_weakrefset.py new file mode 120000 index 0000000..b8b09b7 --- /dev/null +++ b/env_27/lib/python2.7/_weakrefset.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/_weakrefset.py \ No newline at end of file diff --git a/env_27/lib/python2.7/abc.py b/env_27/lib/python2.7/abc.py new file mode 120000 index 0000000..87956e5 --- /dev/null +++ b/env_27/lib/python2.7/abc.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/abc.py \ No newline at end of file diff --git a/env_27/lib/python2.7/codecs.py b/env_27/lib/python2.7/codecs.py new file mode 120000 index 0000000..b18c8d6 --- /dev/null +++ b/env_27/lib/python2.7/codecs.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/codecs.py \ No newline at end of file diff --git a/env_27/lib/python2.7/config b/env_27/lib/python2.7/config new file mode 120000 index 0000000..88ddfa1 --- /dev/null +++ b/env_27/lib/python2.7/config @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/config \ No newline at end of file diff --git a/env_27/lib/python2.7/copy_reg.py b/env_27/lib/python2.7/copy_reg.py new file mode 120000 index 0000000..8d0265c --- /dev/null +++ b/env_27/lib/python2.7/copy_reg.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/copy_reg.py \ No newline at end of file diff --git a/env_27/lib/python2.7/distutils/__init__.py b/env_27/lib/python2.7/distutils/__init__.py new file mode 100644 index 0000000..59f55f1 --- /dev/null +++ b/env_27/lib/python2.7/distutils/__init__.py @@ -0,0 +1,116 @@ +import imp +import os +import sys +import warnings + +# opcode is not a virtualenv module, so we can use it to find the stdlib +# Important! To work on pypy, this must be a module that resides in the +# lib-python/modified-x.y.z directory +import opcode + +dirname = os.path.dirname + +distutils_path = os.path.join(os.path.dirname(opcode.__file__), "distutils") +if os.path.normpath(distutils_path) == os.path.dirname(os.path.normpath(__file__)): + warnings.warn("The virtualenv distutils package at %s appears to be in the same location as the system distutils?") +else: + __path__.insert(0, distutils_path) # noqa: F821 + real_distutils = imp.load_module("_virtualenv_distutils", None, distutils_path, ("", "", imp.PKG_DIRECTORY)) + # Copy the relevant attributes + try: + __revision__ = real_distutils.__revision__ + except AttributeError: + pass + __version__ = real_distutils.__version__ + +from distutils import dist, sysconfig # isort:skip + +try: + basestring +except NameError: + basestring = str + +# patch build_ext (distutils doesn't know how to get the libs directory +# path on windows - it hardcodes the paths around the patched sys.prefix) + +if sys.platform == "win32": + from distutils.command.build_ext import build_ext as old_build_ext + + class build_ext(old_build_ext): + def finalize_options(self): + if self.library_dirs is None: + self.library_dirs = [] + elif isinstance(self.library_dirs, basestring): + self.library_dirs = self.library_dirs.split(os.pathsep) + + self.library_dirs.insert(0, os.path.join(sys.real_prefix, "Libs")) + old_build_ext.finalize_options(self) + + from distutils.command import build_ext as build_ext_module + + build_ext_module.build_ext = build_ext + +# distutils.dist patches: + +old_find_config_files = dist.Distribution.find_config_files + + +def find_config_files(self): + found = old_find_config_files(self) + if os.name == "posix": + user_filename = ".pydistutils.cfg" + else: + user_filename = "pydistutils.cfg" + user_filename = os.path.join(sys.prefix, user_filename) + if os.path.isfile(user_filename): + for item in list(found): + if item.endswith("pydistutils.cfg"): + found.remove(item) + found.append(user_filename) + return found + + +dist.Distribution.find_config_files = find_config_files + +# distutils.sysconfig patches: + +old_get_python_inc = sysconfig.get_python_inc + + +def sysconfig_get_python_inc(plat_specific=0, prefix=None): + if prefix is None: + prefix = sys.real_prefix + return old_get_python_inc(plat_specific, prefix) + + +sysconfig_get_python_inc.__doc__ = old_get_python_inc.__doc__ +sysconfig.get_python_inc = sysconfig_get_python_inc + +old_get_python_lib = sysconfig.get_python_lib + + +def sysconfig_get_python_lib(plat_specific=0, standard_lib=0, prefix=None): + if standard_lib and prefix is None: + prefix = sys.real_prefix + return old_get_python_lib(plat_specific, standard_lib, prefix) + + +sysconfig_get_python_lib.__doc__ = old_get_python_lib.__doc__ +sysconfig.get_python_lib = sysconfig_get_python_lib + +old_get_config_vars = sysconfig.get_config_vars + + +def sysconfig_get_config_vars(*args): + real_vars = old_get_config_vars(*args) + if sys.platform == "win32": + lib_dir = os.path.join(sys.real_prefix, "libs") + if isinstance(real_vars, dict) and "LIBDIR" not in real_vars: + real_vars["LIBDIR"] = lib_dir # asked for all + elif isinstance(real_vars, list) and "LIBDIR" in args: + real_vars = real_vars + [lib_dir] # asked for list + return real_vars + + +sysconfig_get_config_vars.__doc__ = old_get_config_vars.__doc__ +sysconfig.get_config_vars = sysconfig_get_config_vars diff --git a/env_27/lib/python2.7/distutils/distutils.cfg b/env_27/lib/python2.7/distutils/distutils.cfg new file mode 100644 index 0000000..1af230e --- /dev/null +++ b/env_27/lib/python2.7/distutils/distutils.cfg @@ -0,0 +1,6 @@ +# This is a config file local to this virtualenv installation +# You may include options that will be used by all distutils commands, +# and by easy_install. For instance: +# +# [easy_install] +# find_links = http://mylocalsite diff --git a/env_27/lib/python2.7/encodings b/env_27/lib/python2.7/encodings new file mode 120000 index 0000000..8732f85 --- /dev/null +++ b/env_27/lib/python2.7/encodings @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/encodings \ No newline at end of file diff --git a/env_27/lib/python2.7/fnmatch.py b/env_27/lib/python2.7/fnmatch.py new file mode 120000 index 0000000..49b6bc0 --- /dev/null +++ b/env_27/lib/python2.7/fnmatch.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/fnmatch.py \ No newline at end of file diff --git a/env_27/lib/python2.7/genericpath.py b/env_27/lib/python2.7/genericpath.py new file mode 120000 index 0000000..7843bce --- /dev/null +++ b/env_27/lib/python2.7/genericpath.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/genericpath.py \ No newline at end of file diff --git a/env_27/lib/python2.7/lib-dynload b/env_27/lib/python2.7/lib-dynload new file mode 120000 index 0000000..24c555e --- /dev/null +++ b/env_27/lib/python2.7/lib-dynload @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload \ No newline at end of file diff --git a/env_27/lib/python2.7/linecache.py b/env_27/lib/python2.7/linecache.py new file mode 120000 index 0000000..1f79a61 --- /dev/null +++ b/env_27/lib/python2.7/linecache.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/linecache.py \ No newline at end of file diff --git a/env_27/lib/python2.7/locale.py b/env_27/lib/python2.7/locale.py new file mode 120000 index 0000000..cc8a5a7 --- /dev/null +++ b/env_27/lib/python2.7/locale.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/locale.py \ No newline at end of file diff --git a/env_27/lib/python2.7/no-global-site-packages.txt b/env_27/lib/python2.7/no-global-site-packages.txt new file mode 100644 index 0000000..e69de29 diff --git a/env_27/lib/python2.7/ntpath.py b/env_27/lib/python2.7/ntpath.py new file mode 120000 index 0000000..af0bbe7 --- /dev/null +++ b/env_27/lib/python2.7/ntpath.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/ntpath.py \ No newline at end of file diff --git a/env_27/lib/python2.7/orig-prefix.txt b/env_27/lib/python2.7/orig-prefix.txt new file mode 100644 index 0000000..2a45120 --- /dev/null +++ b/env_27/lib/python2.7/orig-prefix.txt @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7 \ No newline at end of file diff --git a/env_27/lib/python2.7/os.py b/env_27/lib/python2.7/os.py new file mode 120000 index 0000000..04db928 --- /dev/null +++ b/env_27/lib/python2.7/os.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.py \ No newline at end of file diff --git a/env_27/lib/python2.7/posixpath.py b/env_27/lib/python2.7/posixpath.py new file mode 120000 index 0000000..cc89aa2 --- /dev/null +++ b/env_27/lib/python2.7/posixpath.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.py \ No newline at end of file diff --git a/env_27/lib/python2.7/re.py b/env_27/lib/python2.7/re.py new file mode 120000 index 0000000..b1a8e65 --- /dev/null +++ b/env_27/lib/python2.7/re.py @@ -0,0 +1 @@ +/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/re.py \ No newline at end of file diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/INSTALLER b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/LICENSE b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/LICENSE new file mode 100644 index 0000000..10145a2 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/LICENSE @@ -0,0 +1,31 @@ +Copyright (c) 2009 by the Jinja Team, see AUTHORS for more details. + +Some rights reserved. + +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. + + * The names of the contributors may not be used to endorse or + promote products derived from this software without specific + prior written permission. + +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 +OWNER 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. diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/METADATA b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/METADATA new file mode 100644 index 0000000..fb4a867 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/METADATA @@ -0,0 +1,67 @@ +Metadata-Version: 2.1 +Name: Jinja2 +Version: 2.10.1 +Summary: A small but fast and easy to use stand-alone template engine written in pure python. +Home-page: http://jinja.pocoo.org/ +Author: Armin Ronacher +Author-email: armin.ronacher@active-4.com +License: BSD +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Web Environment +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.6 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing :: Markup :: HTML +Requires-Dist: MarkupSafe (>=0.23) +Provides-Extra: i18n +Requires-Dist: Babel (>=0.8) ; extra == 'i18n' + + +Jinja2 +~~~~~~ + +Jinja2 is a template engine written in pure Python. It provides a +`Django`_ inspired non-XML syntax but supports inline expressions and +an optional `sandboxed`_ environment. + +Nutshell +-------- + +Here a small example of a Jinja template:: + + {% extends 'base.html' %} + {% block title %}Memberlist{% endblock %} + {% block content %} + + {% endblock %} + +Philosophy +---------- + +Application logic is for the controller but don't try to make the life +for the template designer too hard by giving him too few functionality. + +For more informations visit the new `Jinja2 webpage`_ and `documentation`_. + +.. _sandboxed: https://en.wikipedia.org/wiki/Sandbox_(computer_security) +.. _Django: https://www.djangoproject.com/ +.. _Jinja2 webpage: http://jinja.pocoo.org/ +.. _documentation: http://jinja.pocoo.org/2/documentation/ + + diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/RECORD b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/RECORD new file mode 100644 index 0000000..874f422 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/RECORD @@ -0,0 +1,59 @@ +Jinja2-2.10.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +Jinja2-2.10.1.dist-info/LICENSE,sha256=JvzUNv3Io51EiWrAPm8d_SXjhJnEjyDYvB3Tvwqqils,1554 +Jinja2-2.10.1.dist-info/METADATA,sha256=rx0eN8lX8iq8-YVppmCzV1Qx4y3Pj9IWi08mXUCrewI,2227 +Jinja2-2.10.1.dist-info/RECORD,, +Jinja2-2.10.1.dist-info/WHEEL,sha256=HX-v9-noUkyUoxyZ1PMSuS7auUxDAR4VBdoYLqD0xws,110 +Jinja2-2.10.1.dist-info/entry_points.txt,sha256=NdzVcOrqyNyKDxD09aERj__3bFx2paZhizFDsKmVhiA,72 +Jinja2-2.10.1.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7 +jinja2/__init__.py,sha256=V1D-JHQKklZseXOMA-uAW7-BeKe_TfPpOFi9-dV04ZA,2616 +jinja2/__init__.pyc,, +jinja2/_compat.py,sha256=xP60CE5Qr8FTYcDE1f54tbZLKGvMwYml4-8T7Q4KG9k,2596 +jinja2/_compat.pyc,, +jinja2/_identifier.py,sha256=W1QBSY-iJsyt6oR_nKSuNNCzV95vLIOYgUNPUI1d5gU,1726 +jinja2/_identifier.pyc,, +jinja2/asyncfilters.py,sha256=cTDPvrS8Hp_IkwsZ1m9af_lr5nHysw7uTa5gV0NmZVE,4144 +jinja2/asyncsupport.py,sha256=UErQ3YlTLaSjFb94P4MVn08-aVD9jJxty2JVfMRb-1M,7878 +jinja2/bccache.py,sha256=nQldx0ZRYANMyfvOihRoYFKSlUdd5vJkS7BjxNwlOZM,12794 +jinja2/bccache.pyc,, +jinja2/compiler.py,sha256=BqC5U6JxObSRhblyT_a6Tp5GtEU5z3US1a4jLQaxxgo,65386 +jinja2/compiler.pyc,, +jinja2/constants.py,sha256=uwwV8ZUhHhacAuz5PTwckfsbqBaqM7aKfyJL7kGX5YQ,1626 +jinja2/constants.pyc,, +jinja2/debug.py,sha256=WTVeUFGUa4v6ReCsYv-iVPa3pkNB75OinJt3PfxNdXs,12045 +jinja2/debug.pyc,, +jinja2/defaults.py,sha256=Em-95hmsJxIenDCZFB1YSvf9CNhe9rBmytN3yUrBcWA,1400 +jinja2/defaults.pyc,, +jinja2/environment.py,sha256=VnkAkqw8JbjZct4tAyHlpBrka2vqB-Z58RAP-32P1ZY,50849 +jinja2/environment.pyc,, +jinja2/exceptions.py,sha256=_Rj-NVi98Q6AiEjYQOsP8dEIdu5AlmRHzcSNOPdWix4,4428 +jinja2/exceptions.pyc,, +jinja2/ext.py,sha256=atMQydEC86tN1zUsdQiHw5L5cF62nDbqGue25Yiu3N4,24500 +jinja2/ext.pyc,, +jinja2/filters.py,sha256=yOAJk0MsH-_gEC0i0U6NweVQhbtYaC-uE8xswHFLF4w,36528 +jinja2/filters.pyc,, +jinja2/idtracking.py,sha256=2GbDSzIvGArEBGLkovLkqEfmYxmWsEf8c3QZwM4uNsw,9197 +jinja2/idtracking.pyc,, +jinja2/lexer.py,sha256=ySEPoXd1g7wRjsuw23uimS6nkGN5aqrYwcOKxCaVMBQ,28559 +jinja2/lexer.pyc,, +jinja2/loaders.py,sha256=xiTuURKAEObyym0nU8PCIXu_Qp8fn0AJ5oIADUUm-5Q,17382 +jinja2/loaders.pyc,, +jinja2/meta.py,sha256=fmKHxkmZYAOm9QyWWy8EMd6eefAIh234rkBMW2X4ZR8,4340 +jinja2/meta.pyc,, +jinja2/nativetypes.py,sha256=_sJhS8f-8Q0QMIC0dm1YEdLyxEyoO-kch8qOL5xUDfE,7308 +jinja2/nativetypes.pyc,, +jinja2/nodes.py,sha256=L10L_nQDfubLhO3XjpF9qz46FSh2clL-3e49ogVlMmA,30853 +jinja2/nodes.pyc,, +jinja2/optimizer.py,sha256=MsdlFACJ0FRdPtjmCAdt7JQ9SGrXFaDNUaslsWQaG3M,1722 +jinja2/optimizer.pyc,, +jinja2/parser.py,sha256=lPzTEbcpTRBLw8ii6OYyExHeAhaZLMA05Hpv4ll3ULk,35875 +jinja2/parser.pyc,, +jinja2/runtime.py,sha256=DHdD38Pq8gj7uWQC5usJyWFoNWL317A9AvXOW_CLB34,27755 +jinja2/runtime.pyc,, +jinja2/sandbox.py,sha256=UmX8hVjdaERCbA3RXBwrV1f-beA23KmijG5kzPJyU4A,17106 +jinja2/sandbox.pyc,, +jinja2/tests.py,sha256=iJQLwbapZr-EKquTG_fVOVdwHUUKf3SX9eNkjQDF8oU,4237 +jinja2/tests.pyc,, +jinja2/utils.py,sha256=q24VupGZotQ-uOyrJxCaXtDWhZC1RgsQG7kcdmjck2Q,20629 +jinja2/utils.pyc,, +jinja2/visitor.py,sha256=JD1H1cANA29JcntFfN5fPyqQxB4bI4wC00BzZa-XHks,3316 +jinja2/visitor.pyc,, diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/WHEEL b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/WHEEL new file mode 100644 index 0000000..c8240f0 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.33.1) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/entry_points.txt b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/entry_points.txt new file mode 100644 index 0000000..32e6b75 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/entry_points.txt @@ -0,0 +1,4 @@ + + [babel.extractors] + jinja2 = jinja2.ext:babel_extract[i18n] + \ No newline at end of file diff --git a/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/top_level.txt b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/top_level.txt new file mode 100644 index 0000000..7f7afbf --- /dev/null +++ b/env_27/lib/python2.7/site-packages/Jinja2-2.10.1.dist-info/top_level.txt @@ -0,0 +1 @@ +jinja2 diff --git a/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst new file mode 100644 index 0000000..9d227a0 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst @@ -0,0 +1,28 @@ +Copyright 2010 Pallets + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. 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. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +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. diff --git a/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/METADATA b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/METADATA new file mode 100644 index 0000000..b6d72a8 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/METADATA @@ -0,0 +1,103 @@ +Metadata-Version: 2.1 +Name: MarkupSafe +Version: 1.1.1 +Summary: Safely add untrusted strings to HTML/XML markup. +Home-page: https://palletsprojects.com/p/markupsafe/ +Author: Armin Ronacher +Author-email: armin.ronacher@active-4.com +Maintainer: The Pallets Team +Maintainer-email: contact@palletsprojects.com +License: BSD-3-Clause +Project-URL: Code, https://github.com/pallets/markupsafe +Project-URL: Issue tracker, https://github.com/pallets/markupsafe/issues +Project-URL: Documentation, https://markupsafe.palletsprojects.com/ +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Web Environment +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing :: Markup :: HTML +Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.* + +MarkupSafe +========== + +MarkupSafe implements a text object that escapes characters so it is +safe to use in HTML and XML. Characters that have special meanings are +replaced so that they display as the actual characters. This mitigates +injection attacks, meaning untrusted user input can safely be displayed +on a page. + + +Installing +---------- + +Install and update using `pip`_: + +.. code-block:: text + + pip install -U MarkupSafe + +.. _pip: https://pip.pypa.io/en/stable/quickstart/ + + +Examples +-------- + +.. code-block:: pycon + + >>> from markupsafe import Markup, escape + >>> # escape replaces special characters and wraps in Markup + >>> escape('') + Markup(u'<script>alert(document.cookie);</script>') + >>> # wrap in Markup to mark text "safe" and prevent escaping + >>> Markup('Hello') + Markup('hello') + >>> escape(Markup('Hello')) + Markup('hello') + >>> # Markup is a text subclass (str on Python 3, unicode on Python 2) + >>> # methods and operators escape their arguments + >>> template = Markup("Hello %s") + >>> template % '"World"' + Markup('Hello "World"') + + +Donate +------ + +The Pallets organization develops and supports MarkupSafe and other +libraries that use it. In order to grow the community of contributors +and users, and allow the maintainers to devote more time to the +projects, `please donate today`_. + +.. _please donate today: https://palletsprojects.com/donate + + +Links +----- + +* Website: https://palletsprojects.com/p/markupsafe/ +* Documentation: https://markupsafe.palletsprojects.com/ +* License: `BSD-3-Clause `_ +* Releases: https://pypi.org/project/MarkupSafe/ +* Code: https://github.com/pallets/markupsafe +* Issue tracker: https://github.com/pallets/markupsafe/issues +* Test status: + + * Linux, Mac: https://travis-ci.org/pallets/markupsafe + * Windows: https://ci.appveyor.com/project/pallets/markupsafe + +* Test coverage: https://codecov.io/gh/pallets/markupsafe + + diff --git a/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/RECORD b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/RECORD new file mode 100644 index 0000000..58028a5 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/RECORD @@ -0,0 +1,16 @@ +MarkupSafe-1.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +MarkupSafe-1.1.1.dist-info/LICENSE.rst,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475 +MarkupSafe-1.1.1.dist-info/METADATA,sha256=tYljLDaWFctZWfLXDP5ju_68TOlbQzJHNnaaX5-HYsA,3570 +MarkupSafe-1.1.1.dist-info/RECORD,, +MarkupSafe-1.1.1.dist-info/WHEEL,sha256=QxB7VA6yWRa_kkOPUXf8_8tuQuhnGxzF7TcwNarQG6Q,109 +MarkupSafe-1.1.1.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11 +markupsafe/__init__.py,sha256=oTblO5f9KFM-pvnq9bB0HgElnqkJyqHnFN1Nx2NIvnY,10126 +markupsafe/__init__.pyc,, +markupsafe/_compat.py,sha256=uEW1ybxEjfxIiuTbRRaJpHsPFf4yQUMMKaPgYEC5XbU,558 +markupsafe/_compat.pyc,, +markupsafe/_constants.py,sha256=zo2ajfScG-l1Sb_52EP3MlDCqO7Y1BVHUXXKRsVDRNk,4690 +markupsafe/_constants.pyc,, +markupsafe/_native.py,sha256=d-8S_zzYt2y512xYcuSxq0NeG2DUUvG80wVdTn-4KI8,1873 +markupsafe/_native.pyc,, +markupsafe/_speedups.c,sha256=k0fzEIK3CP6MmMqeY0ob43TP90mVN0DTyn7BAl3RqSg,9884 +markupsafe/_speedups.so,sha256=kaCCUiEMqpZtO5MSk_96ntDI9al0vtyk_31K4miFZvU,27108 diff --git a/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL new file mode 100644 index 0000000..3984e91 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.33.1) +Root-Is-Purelib: false +Tag: cp27-cp27m-macosx_10_6_intel + diff --git a/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt new file mode 100644 index 0000000..75bf729 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt @@ -0,0 +1 @@ +markupsafe diff --git a/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/INSTALLER b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/LICENSE.txt b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/LICENSE.txt new file mode 100644 index 0000000..91e18a6 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/LICENSE.txt @@ -0,0 +1,174 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. diff --git a/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/METADATA b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/METADATA new file mode 100644 index 0000000..cfcac0d --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/METADATA @@ -0,0 +1,196 @@ +Metadata-Version: 2.1 +Name: PyNaCl +Version: 1.3.0 +Summary: Python binding to the Networking and Cryptography (NaCl) library +Home-page: https://github.com/pyca/pynacl/ +Author: The PyNaCl developers +Author-email: cryptography-dev@python.org +License: Apache License 2.0 +Platform: UNKNOWN +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Provides-Extra: docs +Provides-Extra: tests +Requires-Dist: six +Requires-Dist: cffi (>=1.4.1) +Provides-Extra: docs +Requires-Dist: sphinx (>=1.6.5); extra == 'docs' +Requires-Dist: sphinx-rtd-theme; extra == 'docs' +Provides-Extra: tests +Requires-Dist: pytest (!=3.3.0,>=3.2.1); extra == 'tests' +Requires-Dist: hypothesis (>=3.27.0); extra == 'tests' + +=============================================== +PyNaCl: Python binding to the libsodium library +=============================================== + +.. image:: https://img.shields.io/pypi/v/pynacl.svg + :target: https://pypi.org/project/PyNaCl/ + :alt: Latest Version + +.. image:: https://travis-ci.org/pyca/pynacl.svg?branch=master + :target: https://travis-ci.org/pyca/pynacl + +.. image:: https://codecov.io/github/pyca/pynacl/coverage.svg?branch=master + :target: https://codecov.io/github/pyca/pynacl?branch=master + +PyNaCl is a Python binding to `libsodium`_, which is a fork of the +`Networking and Cryptography library`_. These libraries have a stated goal of +improving usability, security and speed. It supports Python 2.7 and 3.4+ as +well as PyPy 2.6+. + +.. _libsodium: https://github.com/jedisct1/libsodium +.. _Networking and Cryptography library: https://nacl.cr.yp.to/ + +Features +-------- + +* Digital signatures +* Secret-key encryption +* Public-key encryption +* Hashing and message authentication +* Password based key derivation and password hashing + +Installation +============ + +Binary wheel install +-------------------- + +PyNaCl ships as a binary wheel on OS X, Windows and Linux ``manylinux1`` [#many]_ , +so all dependencies are included. Make sure you have an up-to-date pip +and run: + +.. code-block:: console + + $ pip install pynacl + +Linux source build +------------------ + +PyNaCl relies on `libsodium`_, a portable C library. A copy is bundled +with PyNaCl so to install you can run: + +.. code-block:: console + + $ pip install pynacl + +If you'd prefer to use the version of ``libsodium`` provided by your +distribution, you can disable the bundled copy during install by running: + +.. code-block:: console + + $ SODIUM_INSTALL=system pip install pynacl + +.. warning:: Usage of the legacy ``easy_install`` command provided by setuptools + is generally discouraged, and is completely unsupported in PyNaCl's case. + +.. _libsodium: https://github.com/jedisct1/libsodium + +.. [#many] `manylinux1 wheels `_ + are built on a baseline linux environment based on Centos 5.11 + and should work on most x86 and x86_64 glibc based linux environments. + +Changelog +========= + +1.3.0 2018-09-26 +---------------- + +* Added support for Python 3.7. +* Update ``libsodium`` to 1.0.16. +* Run and test all code examples in PyNaCl docs through sphinx's + doctest builder. +* Add low-level bindings for chacha20-poly1305 AEAD constructions. +* Add low-level bindings for the chacha20-poly1305 secretstream constructions. +* Add low-level bindings for ed25519ph pre-hashed signing construction. +* Add low-level bindings for constant-time increment and addition + on fixed-precision big integers represented as little-endian + byte sequences. +* Add low-level bindings for the ISO/IEC 7816-4 compatible padding API. +* Add low-level bindings for libsodium's crypto_kx... key exchange + construction. +* Set hypothesis deadline to None in tests/test_pwhash.py to avoid + incorrect test failures on slower processor architectures. GitHub + issue #370 + +1.2.1 - 2017-12-04 +------------------ + +* Update hypothesis minimum allowed version. +* Infrastructure: add proper configuration for readthedocs builder + runtime environment. + +1.2.0 - 2017-11-01 +------------------ + +* Update ``libsodium`` to 1.0.15. +* Infrastructure: add jenkins support for automatic build of + ``manylinux1`` binary wheels +* Added support for ``SealedBox`` construction. +* Added support for ``argon2i`` and ``argon2id`` password hashing constructs + and restructured high-level password hashing implementation to expose + the same interface for all hashers. +* Added support for 128 bit ``siphashx24`` variant of ``siphash24``. +* Added support for ``from_seed`` APIs for X25519 keypair generation. +* Dropped support for Python 3.3. + +1.1.2 - 2017-03-31 +------------------ + +* reorder link time library search path when using bundled + libsodium + +1.1.1 - 2017-03-15 +------------------ + +* Fixed a circular import bug in ``nacl.utils``. + +1.1.0 - 2017-03-14 +------------------ + +* Dropped support for Python 2.6. +* Added ``shared_key()`` method on ``Box``. +* You can now pass ``None`` to ``nonce`` when encrypting with ``Box`` or + ``SecretBox`` and it will automatically generate a random nonce. +* Added support for ``siphash24``. +* Added support for ``blake2b``. +* Added support for ``scrypt``. +* Update ``libsodium`` to 1.0.11. +* Default to the bundled ``libsodium`` when compiling. +* All raised exceptions are defined mixing-in + ``nacl.exceptions.CryptoError`` + +1.0.1 - 2016-01-24 +------------------ + +* Fix an issue with absolute paths that prevented the creation of wheels. + +1.0 - 2016-01-23 +---------------- + +* PyNaCl has been ported to use the new APIs available in cffi 1.0+. + Due to this change we no longer support PyPy releases older than 2.6. +* Python 3.2 support has been dropped. +* Functions to convert between Ed25519 and Curve25519 keys have been added. + +0.3.0 - 2015-03-04 +------------------ + +* The low-level API (`nacl.c.*`) has been changed to match the + upstream NaCl C/C++ conventions (as well as those of other NaCl bindings). + The order of arguments and return values has changed significantly. To + avoid silent failures, `nacl.c` has been removed, and replaced with + `nacl.bindings` (with the new argument ordering). If you have code which + calls these functions (e.g. `nacl.c.crypto_box_keypair()`), you must review + the new docstrings and update your code/imports to match the new + conventions. + + diff --git a/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/RECORD b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/RECORD new file mode 100644 index 0000000..8326241 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/RECORD @@ -0,0 +1,65 @@ +PyNaCl-1.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +PyNaCl-1.3.0.dist-info/LICENSE.txt,sha256=0xdK1j5yHUydzLitQyCEiZLTFDabxGMZcgtYAskVP-k,9694 +PyNaCl-1.3.0.dist-info/METADATA,sha256=pl3lEk7jyuFK7MNHloWA3m28tYU6xHI-S4le43id_x8,6632 +PyNaCl-1.3.0.dist-info/RECORD,, +PyNaCl-1.3.0.dist-info/WHEEL,sha256=F1TCjYjTFxks-nqiDpERoLzySPhR94sDPjBYFZlcSxk,109 +PyNaCl-1.3.0.dist-info/top_level.txt,sha256=wfdEOI_G2RIzmzsMyhpqP17HUh6Jcqi99to9aHLEslo,13 +nacl/__init__.py,sha256=PS9BuXZoCwSvrDpB8HXldTHnA6lb4y00IRi3uqdW5_E,1170 +nacl/__init__.pyc,, +nacl/_sodium.so,sha256=Rc6lNbEnFWTq2gjp4TmnvSXd1n97w59z2YmGShGcRkI,749348 +nacl/bindings/__init__.py,sha256=dNH1zFjW87qszsld5oy6xMf2S1w2v_qshQwYHp66pz4,14943 +nacl/bindings/__init__.pyc,, +nacl/bindings/crypto_aead.py,sha256=DE5zdi09GeHZxvmrhHtxVuTqF61y1cs8trTGh_6uP8Q,17335 +nacl/bindings/crypto_aead.pyc,, +nacl/bindings/crypto_box.py,sha256=hbHJetr9id5OvkbJwJoeqRQAhqSIGwWC2aXRAF5oPE4,9708 +nacl/bindings/crypto_box.pyc,, +nacl/bindings/crypto_generichash.py,sha256=-e4b4DaopLBQHhEjLSjEoumy5fOs4QdTb-hou1S34C4,8010 +nacl/bindings/crypto_generichash.pyc,, +nacl/bindings/crypto_hash.py,sha256=7Xp4mpXr4cpn-hAOU66KlYVUCVHP6deT0v_eW4UZZXo,2243 +nacl/bindings/crypto_hash.pyc,, +nacl/bindings/crypto_kx.py,sha256=2Gjxu5c7IKAwW2MOJa9zEn1EgpIVQ0tbZQs33REZb38,6937 +nacl/bindings/crypto_kx.pyc,, +nacl/bindings/crypto_pwhash.py,sha256=lWhEFKmXzFhKnzzxtWDwozs0CseZDkGgTJaI4YQ5rak,16898 +nacl/bindings/crypto_pwhash.pyc,, +nacl/bindings/crypto_scalarmult.py,sha256=VA2khmlUrnR24KK0CAdDw2dQ0jiYkku9-_NA-f1p21c,1803 +nacl/bindings/crypto_scalarmult.pyc,, +nacl/bindings/crypto_secretbox.py,sha256=luvzB3lwBwXxKm63e9nA2neGtOXeeG8R9SyWEckIqdI,2864 +nacl/bindings/crypto_secretbox.pyc,, +nacl/bindings/crypto_secretstream.py,sha256=gdKinW10jP3CZ51hanE40s6e39rz8iuajdXTSBSKVcM,10474 +nacl/bindings/crypto_secretstream.pyc,, +nacl/bindings/crypto_shorthash.py,sha256=eVUE8byB1RjI0AoHib5BdZSSLtSqtdIcHgPCPWf2OZM,2189 +nacl/bindings/crypto_shorthash.pyc,, +nacl/bindings/crypto_sign.py,sha256=uA0RdHM4vsBDNhph2f7fcuI_9K8vvW-4hNHjajTIVU0,9641 +nacl/bindings/crypto_sign.pyc,, +nacl/bindings/randombytes.py,sha256=eThts6s-9xBXOl3GNzT57fV1dZUhzPjjAmAVIUHfcrc,988 +nacl/bindings/randombytes.pyc,, +nacl/bindings/sodium_core.py,sha256=52z0K7y6Ge6IlXcysWDVN7UdYcTOij6v0Cb0OLo8_Qc,1079 +nacl/bindings/sodium_core.pyc,, +nacl/bindings/utils.py,sha256=jOKsDbsjxN9v_HI8DOib72chyU3byqbynXxbiV909-g,4420 +nacl/bindings/utils.pyc,, +nacl/encoding.py,sha256=tOiyIQVVpGU6A4Lzr0tMuqomhc_Aj0V_c1t56a-ZtPw,1928 +nacl/encoding.pyc,, +nacl/exceptions.py,sha256=SG0BNtXnzmppI9in6xMTSizh1ryfgUIvIVMQv_A0bs8,1858 +nacl/exceptions.pyc,, +nacl/hash.py,sha256=4DKlmqpWOZJLhzTPk7_JSGXQ32lJULsS3AzJCGsibus,5928 +nacl/hash.pyc,, +nacl/hashlib.py,sha256=gMxOu-lIlKYr3ywSCjsJRBksYgpU2dvXgaAEfQz7PEg,3909 +nacl/hashlib.pyc,, +nacl/public.py,sha256=-nwQof5ov-wSSdvvoXh-FavTtjfpRnYykZkatNKyLd0,13442 +nacl/public.pyc,, +nacl/pwhash/__init__.py,sha256=CN0mP6yteSYp3ui-DyWR1vjULNrXVN_gQ72CmTPoao0,2695 +nacl/pwhash/__init__.pyc,, +nacl/pwhash/_argon2.py,sha256=Eu3-juLws3_v1gNy5aeSVPEwuRVFdGOrfeF0wPH9VHA,1878 +nacl/pwhash/_argon2.pyc,, +nacl/pwhash/argon2i.py,sha256=EpheK0UHJvZYca_EMhhOcX5GXaOr0xCjFDTIgmSCSDo,4598 +nacl/pwhash/argon2i.pyc,, +nacl/pwhash/argon2id.py,sha256=IqNm5RQNEd1Z9F-bEWT-_Y9noU26QoTR5YdWONg1uuI,4610 +nacl/pwhash/argon2id.pyc,, +nacl/pwhash/scrypt.py,sha256=F9iUKbzZUMG2ZXuuk70p4KXI_nItue3VA39zmwOESE8,6025 +nacl/pwhash/scrypt.pyc,, +nacl/secret.py,sha256=jf4WuUjnnXTekZ2elGgQozZl6zGzxGY_0Nw0fwehUlg,5430 +nacl/secret.pyc,, +nacl/signing.py,sha256=ZwA1l31ZgOIw_sAjiUPkzEo07uYYi8SE7Ni0G_R8ksQ,7302 +nacl/signing.pyc,, +nacl/utils.py,sha256=hhmIriBM7Bwyh3beTrqVqDDucai5gXlSliAMVrxIHPI,1691 +nacl/utils.pyc,, diff --git a/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/WHEEL b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/WHEEL new file mode 100644 index 0000000..535e150 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.31.1) +Root-Is-Purelib: false +Tag: cp27-cp27m-macosx_10_6_intel + diff --git a/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/top_level.txt b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/top_level.txt new file mode 100644 index 0000000..f52507f --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyNaCl-1.3.0.dist-info/top_level.txt @@ -0,0 +1,2 @@ +_sodium +nacl diff --git a/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/INSTALLER b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/LICENSE b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/LICENSE new file mode 100644 index 0000000..e8f8805 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2017-2019 Ingy döt Net +Copyright (c) 2006-2016 Kirill Simonov + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/METADATA b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/METADATA new file mode 100644 index 0000000..e4ea8f1 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/METADATA @@ -0,0 +1,40 @@ +Metadata-Version: 2.1 +Name: PyYAML +Version: 5.1 +Summary: YAML parser and emitter for Python +Home-page: https://github.com/yaml/pyyaml +Author: Kirill Simonov +Author-email: xi@resolvent.net +License: MIT +Download-URL: https://pypi.org/project/PyYAML/ +Platform: Any +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.4 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing :: Markup +Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.* + +YAML is a data serialization format designed for human readability +and interaction with scripting languages. PyYAML is a YAML parser +and emitter for Python. + +PyYAML features a complete YAML 1.1 parser, Unicode support, pickle +support, capable extension API, and sensible error messages. PyYAML +supports standard YAML tags and provides Python-specific tags that +allow to represent an arbitrary Python object. + +PyYAML is applicable for a broad range of tasks from complex +configuration files to object serialization and persistence. + diff --git a/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/RECORD b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/RECORD new file mode 100644 index 0000000..a45f996 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/RECORD @@ -0,0 +1,40 @@ +PyYAML-5.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +PyYAML-5.1.dist-info/LICENSE,sha256=oq25yVm3l0lKDvgL32DiLbJ0nuPgwJCFVuPrVI-WfFY,1101 +PyYAML-5.1.dist-info/METADATA,sha256=33vAx8vSzjUMXGHO2jp0u8tvgkRqfAH3-OEDSpjfIx8,1704 +PyYAML-5.1.dist-info/RECORD,, +PyYAML-5.1.dist-info/WHEEL,sha256=X60NSjsla4d4ueip-xFdVMnfiCIypBW0CA59NCWilHY,110 +PyYAML-5.1.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11 +yaml/__init__.py,sha256=Ke2gASae4i0HLUxbz8l2CUR3__qpspvBBI1gltOxQbE,12182 +yaml/__init__.pyc,, +yaml/composer.py,sha256=TtvWJCaffdVHhHx_muLguloDUwg1NUbo-GlJ0me6xuA,4923 +yaml/composer.pyc,, +yaml/constructor.py,sha256=HrBLwPOrijfcmurB4Ww71xrTtMKehs0-xh3NNlQzveY,26834 +yaml/constructor.pyc,, +yaml/cyaml.py,sha256=6MZKSJHTWwoct5urK9qbGXAhM1xz_Boawlf5SVMC85o,3842 +yaml/cyaml.pyc,, +yaml/dumper.py,sha256=yMFwlojOY-M4EMUT8FiROY2QC2GAGQO7Iiky0xBlJFc,2833 +yaml/dumper.pyc,, +yaml/emitter.py,sha256=09BwSivdd4BbPgx2rbFcoMOa9H1yZxqY1YILjOXvFeo,43427 +yaml/emitter.pyc,, +yaml/error.py,sha256=7K-NdIv0qNKPKbnXxEg0L_b9K7nYDORr3rzm8_b-iBY,2559 +yaml/error.pyc,, +yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445 +yaml/events.pyc,, +yaml/loader.py,sha256=T61DzDkbfResZoQfVy1U3vN0_mKFyBALB9et-478-w4,2055 +yaml/loader.pyc,, +yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440 +yaml/nodes.pyc,, +yaml/parser.py,sha256=sgXahZA3DkySYnaC4D_zcl3l2y4Y5R40icWtdwkF_NE,25542 +yaml/parser.pyc,, +yaml/reader.py,sha256=y6cj-OcZjnFDO1u6Blmi-tKoi-3Pjvmo2PikMnO5FFc,6850 +yaml/reader.pyc,, +yaml/representer.py,sha256=BaJcXjs4a1yjYMnCKxJ39TZlWahVu2OE7K6dEEy0Bqo,17791 +yaml/representer.pyc,, +yaml/resolver.py,sha256=5Z3boiMikL6Qt6fS5Mt8fHym0GxbW7CMT2f2fnD1ZPQ,9122 +yaml/resolver.pyc,, +yaml/scanner.py,sha256=Umb0oXZGFIf814tr_CUPPfKfeWUZj9ucqz06q20v0Fg,52027 +yaml/scanner.pyc,, +yaml/serializer.py,sha256=tRsRwfu5E9fpLU7LY3vBQf2prt77hwnYlMt5dnBJLig,4171 +yaml/serializer.pyc,, +yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573 +yaml/tokens.pyc,, diff --git a/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/WHEEL b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/WHEEL new file mode 100644 index 0000000..bc0b983 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.33.1) +Root-Is-Purelib: false +Tag: cp27-cp27m-macosx_10_13_intel + diff --git a/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/top_level.txt b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/top_level.txt new file mode 100644 index 0000000..e6475e9 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/PyYAML-5.1.dist-info/top_level.txt @@ -0,0 +1,2 @@ +_yaml +yaml diff --git a/env_27/lib/python2.7/site-packages/_pyrsistent_version.py b/env_27/lib/python2.7/site-packages/_pyrsistent_version.py new file mode 100644 index 0000000..213e621 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/_pyrsistent_version.py @@ -0,0 +1 @@ +__version__ = '0.14.11' diff --git a/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/COPYING b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/COPYING new file mode 100644 index 0000000..10926e8 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/COPYING @@ -0,0 +1,675 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + diff --git a/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/INSTALLER b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/METADATA b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/METADATA new file mode 100644 index 0000000..035944d --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/METADATA @@ -0,0 +1,183 @@ +Metadata-Version: 2.1 +Name: ansible +Version: 2.7.10 +Summary: Radically simple IT automation +Home-page: https://ansible.com/ +Author: Ansible, Inc. +Author-email: info@ansible.com +License: GPLv3+ +Project-URL: Source Code, https://github.com/ansible/ansible +Project-URL: CI: Shippable, https://app.shippable.com/github/ansible/ansible +Project-URL: Code of Conduct, https://docs.ansible.com/ansible/latest/community/code_of_conduct.html +Project-URL: Documentation, https://docs.ansible.com/ansible/ +Project-URL: Bug Tracker, https://github.com/ansible/ansible/issues +Project-URL: Mailing lists, https://docs.ansible.com/ansible/latest/community/communication.html#mailing-list-information +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: System Administrators +Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+) +Classifier: Natural Language :: English +Classifier: Operating System :: POSIX +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Topic :: System :: Installation/Setup +Classifier: Topic :: System :: Systems Administration +Classifier: Topic :: Utilities +Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.* +Requires-Dist: jinja2 +Requires-Dist: PyYAML +Requires-Dist: paramiko +Requires-Dist: cryptography +Requires-Dist: setuptools +Provides-Extra: azure +Requires-Dist: packaging ; extra == 'azure' +Requires-Dist: requests[security] ; extra == 'azure' +Requires-Dist: azure-cli-core (==2.0.35) ; extra == 'azure' +Requires-Dist: azure-cli-nspkg (==3.0.2) ; extra == 'azure' +Requires-Dist: azure-common (==1.1.11) ; extra == 'azure' +Requires-Dist: azure-mgmt-batch (==4.1.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-compute (==2.1.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-containerinstance (==0.4.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-containerregistry (==2.0.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-containerservice (==3.0.1) ; extra == 'azure' +Requires-Dist: azure-mgmt-dns (==1.2.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-keyvault (==0.40.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-marketplaceordering (==0.1.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-monitor (==0.5.2) ; extra == 'azure' +Requires-Dist: azure-mgmt-network (==1.7.1) ; extra == 'azure' +Requires-Dist: azure-mgmt-nspkg (==2.0.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-rdbms (==1.2.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-resource (==1.2.2) ; extra == 'azure' +Requires-Dist: azure-mgmt-sql (==0.7.1) ; extra == 'azure' +Requires-Dist: azure-mgmt-storage (==1.5.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-trafficmanager (==0.50.0) ; extra == 'azure' +Requires-Dist: azure-mgmt-web (==0.32.0) ; extra == 'azure' +Requires-Dist: azure-nspkg (==2.0.0) ; extra == 'azure' +Requires-Dist: azure-storage (==0.35.1) ; extra == 'azure' +Requires-Dist: msrest (==0.4.29) ; extra == 'azure' +Requires-Dist: msrestazure (==0.4.31) ; extra == 'azure' +Requires-Dist: azure-keyvault (==1.0.0a1) ; extra == 'azure' +Requires-Dist: azure-graphrbac (==0.40.0) ; extra == 'azure' + +|PyPI version| |Docs badge| |Chat badge| |Build Status| + +******* +Ansible +******* + +Ansible is a radically simple IT automation system. It handles +configuration-management, application deployment, cloud provisioning, +ad-hoc task-execution, and multinode orchestration -- including +trivializing things like zero-downtime rolling updates with load +balancers. + +Read the documentation and more at https://ansible.com/ + +You can find installation instructions +`here `_ for a +variety of platforms. + +Most users should probably install a released version of Ansible from ``pip``, a package manager or +our `release repository `_. `Officially supported +`_ builds of Ansible are also available. Some power users +run directly from the development branch - while significant efforts are made to ensure that +``devel`` is reasonably stable, you're more likely to encounter breaking changes when running +Ansible this way. + +Design Principles +================= + +* Have a dead simple setup process and a minimal learning curve. +* Manage machines very quickly and in parallel. +* Avoid custom-agents and additional open ports, be agentless by + leveraging the existing SSH daemon. +* Describe infrastructure in a language that is both machine and human + friendly. +* Focus on security and easy auditability/review/rewriting of content. +* Manage new remote machines instantly, without bootstrapping any + software. +* Allow module development in any dynamic language, not just Python. +* Be usable as non-root. +* Be the easiest IT automation system to use, ever. + +Get Involved +============ + +* Read `Community + Information `_ for all + kinds of ways to contribute to and interact with the project, + including mailing list information and how to submit bug reports and + code to Ansible. +* All code submissions are done through pull requests to the ``devel`` branch. +* Feel free to talk to us before making larger changes + to avoid duplicate efforts. This not only helps everyone + know what's going on, it also helps save time and effort if we decide + some changes are needed. +* Users list: + `ansible-project `_ +* Development list: + `ansible-devel `_ +* Announcement list: + `ansible-announce `_ + -- read only +* irc.freenode.net: #ansible +* For the full list of Email Lists, IRC channels see the + `Communication page `_ + +Branch Info +=========== + +* Releases are named after Led Zeppelin songs. (Releases prior to 2.0 + were named after Van Halen songs.) +* The ``devel`` branch corresponds to the release actively under + development. +* The ``stable-2.x`` branches exist for current releases. +* Various release-X.Y branches exist for previous releases. +* For information about the active branches see the + `Ansible release and maintenance `_ page. +* We'd love to have your contributions, read the `Community + Guide `_ for notes on + how to get started. + +Roadmap +======= + +Based on team and community feedback, an initial roadmap will be published for a major or minor version (ex: 2.0, 2.1). +Subminor versions will generally not have roadmaps published. + +The `Ansible Roadmap page `_ details what is planned and how to influence the roadmap. + +Authors +======= + +Ansible was created by `Michael DeHaan `_ +(michael.dehaan/gmail/com) and has contributions from over 3700 users +(and growing). Thanks everyone! + +`Ansible `_ is sponsored by `Red Hat, Inc. +`_ + +License +======= + +GNU General Public License v3.0 + +See `COPYING `_ to see the full text. + +.. |PyPI version| image:: https://img.shields.io/pypi/v/ansible.svg + :target: https://pypi.org/project/ansible +.. |Docs badge| image:: https://img.shields.io/badge/docs-latest-brightgreen.svg + :target: https://docs.ansible.com/ansible/latest/ +.. |Build Status| image:: https://api.shippable.com/projects/573f79d02a8192902e20e34b/badge?branch=devel + :target: https://app.shippable.com/projects/573f79d02a8192902e20e34b +.. |Chat badge| image:: https://img.shields.io/badge/chat-IRC-brightgreen.svg + :target: https://docs.ansible.com/ansible/latest/community/communication.html + + diff --git a/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/RECORD b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/RECORD new file mode 100644 index 0000000..def613a --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/RECORD @@ -0,0 +1,6411 @@ +../../../bin/ansible,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-config,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-connection,sha256=hhTmvgWAtBbnUSjVz3RqShU_tAHTTMETUs8nXBk2LO4,11671 +../../../bin/ansible-console,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-doc,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-galaxy,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-inventory,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-playbook,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-pull,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +../../../bin/ansible-vault,sha256=irzWQ7n97moo6Na-EK61QvG3AOla5CaUpXU2CKGpVFY,5832 +ansible-2.7.10.dist-info/COPYING,sha256=CuBIWlvTemPmNgNZZBfk6w5lMzT6bH-TLKOg6F1K8ic,35148 +ansible-2.7.10.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ansible-2.7.10.dist-info/METADATA,sha256=-Vf8AndoyfmrP7f5mQoNlUYt7eJQBQjI71G9AaRuy60,8233 +ansible-2.7.10.dist-info/RECORD,, +ansible-2.7.10.dist-info/WHEEL,sha256=wy6I0RkXf1SHQI9WgMGMZtkrPqc-c49UWrTH1_nKFnQ,93 +ansible-2.7.10.dist-info/top_level.txt,sha256=bP1o-RYLYg8m00qC3A9r7ijpfW549hd0u6Y9uxQxRK4,8 +ansible/__init__.py,sha256=g3vWcT1PWPQ-mCdrcZRtO4epVN-1ikCdzjJ8mE764BA,1224 +ansible/__init__.pyc,, +ansible/cli/__init__.py,sha256=78f81_2VSZfb9zNeqgrAqaMo8FqikmYwHGxfhq1dSe8,38955 +ansible/cli/__init__.pyc,, +ansible/cli/adhoc.py,sha256=jje5Imqpb-SCTAWS7REVMxOK-Hjvhqetlef8HbsJh2k,7034 +ansible/cli/adhoc.pyc,, +ansible/cli/config.py,sha256=UsrkjDAhNH1zgjiF59zDgt2CwDQDa-Em6C_yNxQdXHo,6695 +ansible/cli/config.pyc,, +ansible/cli/console.py,sha256=UaOu58kzmHKuRwkFEEbu8nYA8YYyTaKUq2pzDeN79rI,15684 +ansible/cli/console.pyc,, +ansible/cli/doc.py,sha256=NnDh07Xmn6kAqN6Un91qHvVuXEoublRVOehWMvUyW0c,28907 +ansible/cli/doc.pyc,, +ansible/cli/galaxy.py,sha256=RYw8SSrXFCks3SrlW9wzGeS7kyIN6UJdfgB1PBStV8o,33089 +ansible/cli/galaxy.pyc,, +ansible/cli/inventory.py,sha256=VdjJAxgYtoL-hA3jKUVqQC8xKs-5Cz9vCb_D3YD3vsM,14516 +ansible/cli/inventory.pyc,, +ansible/cli/playbook.py,sha256=KL8a_xgUGzIQK-U2_fRQBew5obJPQIQG-P1srcLRYJQ,8553 +ansible/cli/playbook.pyc,, +ansible/cli/pull.py,sha256=WgL9S_UK74tc0Ssbw0-3vEU6p534E27q9Di9F3km5kk,15669 +ansible/cli/pull.pyc,, +ansible/cli/vault.py,sha256=Sh9csJCI0iz83wJIwXNkY4Rhtz6tlsC2BLWQ4MYUCTc,21273 +ansible/cli/vault.pyc,, +ansible/compat/__init__.py,sha256=kZSTiA4RIMSyu65Zc1o-VmVFegkNPnQtfsp4TpxIDTA,1087 +ansible/compat/__init__.pyc,, +ansible/compat/selectors/__init__.py,sha256=rKff6UtUa3ymRZ7tqWZFtdS1qn6p8u3fmyFSwVR6XU4,2181 +ansible/compat/selectors/__init__.pyc,, +ansible/compat/selectors/_selectors2.py,sha256=IY7awsIgEsfk6GysmPyCF_yX_jw9b_GQJgRVEz4ppK0,23458 +ansible/compat/selectors/_selectors2.pyc,, +ansible/compat/tests/__init__.py,sha256=kLXfOCebG9oXFoX61DDVdQZTIitljIf9ybpRwNpIoGI,1267 +ansible/compat/tests/__init__.pyc,, +ansible/compat/tests/mock.py,sha256=CvlYRQz23j-6_pSxER6ui6Wo2-HXhf-7nfgfJuSUbZk,4556 +ansible/compat/tests/mock.pyc,, +ansible/compat/tests/unittest.py,sha256=VAGgRuXOcfoZttkFq9D5vfgWwMY1973aZzCz7wbmcJY,1302 +ansible/compat/tests/unittest.pyc,, +ansible/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/config/__init__.pyc,, +ansible/config/base.yml,sha256=WeRWl66-CwSJG_PB_g-q8B2r-oyM4Wf88NxCCaqUujM,64526 +ansible/config/data.py,sha256=fJAQ9K44QxXLZiDXb3F5HM3yJJp-mmRLt9-ZRxQYL5k,1526 +ansible/config/data.pyc,, +ansible/config/manager.py,sha256=r99Qt9Me8jzmRGoIBf_uXWJC_zUZ_v4sEtF72os8oME,21454 +ansible/config/manager.pyc,, +ansible/config/module_defaults.yml,sha256=vEV8WLvScBABZnkUSwGZ-a43aYLPLrE5rEIqoWw0pu0,9536 +ansible/constants.py,sha256=T2ECi5GCe3bFiFn909-9hHz2ZxGeKzvdKk7DoRKzAco,7740 +ansible/constants.pyc,, +ansible/errors/__init__.py,sha256=dmsot3r-kDCMLHTxo64RUVVJ7zeo6R2_7ZZLCefLUHc,11573 +ansible/errors/__init__.pyc,, +ansible/errors/yaml_strings.py,sha256=d3IBVdC1FeqcUAWG1IpCZVaiQ4oQZlsiwfoLax6k5ZM,3820 +ansible/errors/yaml_strings.pyc,, +ansible/executor/__init__.py,sha256=1lMXN1i2fFqslda4BmeI5tpYMFP95D5Wpr1AjDJi-SQ,833 +ansible/executor/__init__.pyc,, +ansible/executor/action_write_locks.py,sha256=ClKVek_W4Z-qlV3SSiK-2esWgtFVtDWhqkfe_FZ94Og,1911 +ansible/executor/action_write_locks.pyc,, +ansible/executor/module_common.py,sha256=KOcdLjY_KirVkf73mGqGVcpHM9eY30xV0uX9UN59EC8,45950 +ansible/executor/module_common.pyc,, +ansible/executor/play_iterator.py,sha256=UZzbZkj5iwxi66hcx8Q62pVj9xM2M_J5_EOLFpGSsrg,27156 +ansible/executor/play_iterator.pyc,, +ansible/executor/playbook_executor.py,sha256=LvxOeUpVGaa4co8_gn4_bUfNa1tjtD7L-dPjew9QJyQ,12989 +ansible/executor/playbook_executor.pyc,, +ansible/executor/powershell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/executor/powershell/__init__.pyc,, +ansible/executor/powershell/bootstrap_wrapper.ps1,sha256=UMvRP1hhyG4Vl2U-1HbSXfiwJ3M6q5qkPocRHbJw8DQ,348 +ansible/executor/process/__init__.py,sha256=1lMXN1i2fFqslda4BmeI5tpYMFP95D5Wpr1AjDJi-SQ,833 +ansible/executor/process/__init__.pyc,, +ansible/executor/process/worker.py,sha256=H-Z0HcK_Vkb9d7xZt2p53KZCvQfjFmPOsob9pFGleMg,6239 +ansible/executor/process/worker.pyc,, +ansible/executor/stats.py,sha256=D3r-R7GDfWbsiHMpZJydMyoAeUlUCNzDsBA33SH2ykE,3113 +ansible/executor/stats.pyc,, +ansible/executor/task_executor.py,sha256=2-V31ITAYRg2ZbzJnn0bmzKUzcy_4jj5r0IhTj2cWzY,46622 +ansible/executor/task_executor.pyc,, +ansible/executor/task_queue_manager.py,sha256=A6uNHBAwZpsq4I-dB0fwWwIp7sQd3FCim4G_XStEjzc,15648 +ansible/executor/task_queue_manager.pyc,, +ansible/executor/task_result.py,sha256=npT0s_-nXrtNWxyu3hhLABHlPBGOqaVXf3kTX_WQdes,5315 +ansible/executor/task_result.pyc,, +ansible/galaxy/__init__.py,sha256=CRfALWhRhqO_0eSgVl6zhCYQhqFmBJCnQby9AkUP3Nc,2028 +ansible/galaxy/__init__.pyc,, +ansible/galaxy/api.py,sha256=hVONwYrSudcckbPlqDU90i_8Gy6eFHfdUVpTQnR1-TE,11063 +ansible/galaxy/api.pyc,, +ansible/galaxy/data/apb/Dockerfile.j2,sha256=AkBKmBXhfdcXivMcGorwYKWH7PsfUKvuGkGwhkcdIh8,190 +ansible/galaxy/data/apb/Makefile.j2,sha256=l_7uHTGBa1clbtENA5UIFAnxo3hFpFGi684OZzjvZAg,755 +ansible/galaxy/data/apb/README.md,sha256=QH6NCF6wlRLPc__Dna7jKn2ORFMaohrdz-Ksq9YQ-QI,1338 +ansible/galaxy/data/apb/apb.yml.j2,sha256=hKOkRFkxfTDB8aOIXC342Ev9zAvZ34A2ztuCBxtA7Es,278 +ansible/galaxy/data/apb/defaults/main.yml.j2,sha256=niRaHtSwlcuJYidnYADqRftPPIuRQrWlEZFbw_mKFac,40 +ansible/galaxy/data/apb/files/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/apb/handlers/main.yml.j2,sha256=u9I2gRnZiRt4mk1tJmndsqA00O08gsRt0oxwX4-Fmmc,40 +ansible/galaxy/data/apb/meta/main.yml.j2,sha256=gbteIINYsjWkKgmKWnuJZgCLlHeajWg_nTiWNMgFqVM,1537 +ansible/galaxy/data/apb/playbooks/deprovision.yml.j2,sha256=lkCuOin8YH_XQ_vstDUwdM8yQsm_ZtiOVSx_Dl5VvEA,196 +ansible/galaxy/data/apb/playbooks/provision.yml.j2,sha256=9fvqQZwh-arkr_Ub328Y9ePwyWhNN2xs4-6rCIbFJ-Q,192 +ansible/galaxy/data/apb/tasks/main.yml.j2,sha256=W7rHCp3QgYrD2A6uGLALCzmKgz0_Jc_CHP13qMOjXDQ,37 +ansible/galaxy/data/apb/templates/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/apb/tests/ansible.cfg,sha256=Ao6oXXa-SbMYpYMjOdE2pMBmrjavIpzXJpLJyxdZl10,33 +ansible/galaxy/data/apb/tests/inventory,sha256=scCC7fOQm1DEZOu6Damsdw2X13LV3YBaZ9OVfCdjo6M,12 +ansible/galaxy/data/apb/tests/test.yml.j2,sha256=gBJpxUFuqwJNckBKVOxs7mFVGSQWBrjCcSMQenxIsDA,132 +ansible/galaxy/data/apb/vars/main.yml.j2,sha256=Vz91wz4__mGmbD7g0prIzLoaWbkg3WE8Opz18GdLiio,37 +ansible/galaxy/data/container/README.md,sha256=PR3AwSjQxquevk_KEcW2H5Mzq_cxwZHpVYO1a3ywiZw,1489 +ansible/galaxy/data/container/defaults/main.yml.j2,sha256=fmqKmWeFMVlQmZEDZNDgYXHSU6MixpVtdOQEc41t1eY,41 +ansible/galaxy/data/container/files/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/container/handlers/main.yml.j2,sha256=u9I2gRnZiRt4mk1tJmndsqA00O08gsRt0oxwX4-Fmmc,40 +ansible/galaxy/data/container/meta/container.yml.j2,sha256=_hybIkM0GceiYlN909SVeg5a9sM110GmrrEa9wMviEo,287 +ansible/galaxy/data/container/meta/main.yml.j2,sha256=vQ806XZQZbdotfINQOc_XtRVTUz-NgB048n22LFR-W4,1893 +ansible/galaxy/data/container/tasks/main.yml.j2,sha256=kmDHiVK9QIS3ORWjj4Myx4fakHeixJZBcEfAQ-8WLn8,38 +ansible/galaxy/data/container/templates/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/container/tests/ansible.cfg,sha256=Ao6oXXa-SbMYpYMjOdE2pMBmrjavIpzXJpLJyxdZl10,33 +ansible/galaxy/data/container/tests/inventory,sha256=scCC7fOQm1DEZOu6Damsdw2X13LV3YBaZ9OVfCdjo6M,12 +ansible/galaxy/data/container/tests/test.yml.j2,sha256=gBJpxUFuqwJNckBKVOxs7mFVGSQWBrjCcSMQenxIsDA,132 +ansible/galaxy/data/container/vars/main.yml.j2,sha256=Vz91wz4__mGmbD7g0prIzLoaWbkg3WE8Opz18GdLiio,37 +ansible/galaxy/data/default/README.md,sha256=zHUddSZvdXo4GJ8V1U5Ujch3BvFKOXVplcJ7SerKigc,1328 +ansible/galaxy/data/default/defaults/main.yml.j2,sha256=niRaHtSwlcuJYidnYADqRftPPIuRQrWlEZFbw_mKFac,40 +ansible/galaxy/data/default/files/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/default/handlers/main.yml.j2,sha256=u9I2gRnZiRt4mk1tJmndsqA00O08gsRt0oxwX4-Fmmc,40 +ansible/galaxy/data/default/meta/main.yml.j2,sha256=OSplqzXx6EW9WDsli15WAAGmL_y7kS9P69NSrfFcg_A,2045 +ansible/galaxy/data/default/tasks/main.yml.j2,sha256=W7rHCp3QgYrD2A6uGLALCzmKgz0_Jc_CHP13qMOjXDQ,37 +ansible/galaxy/data/default/templates/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/default/tests/inventory,sha256=4CIzgZsaCYREEFSRkYE_fMe6Ng8hKYV49LoXJ6J9h_w,11 +ansible/galaxy/data/default/tests/test.yml.j2,sha256=btDKubBRtcBfOuO4-kLSMl2X6KRwFySuAigaDHNB5dw,73 +ansible/galaxy/data/default/vars/main.yml.j2,sha256=3qtsgmeZTZ37OdmQNpmI9R6XxOEzJcOhjjGQYGFb85w,36 +ansible/galaxy/data/network/README.md,sha256=h9svOT77DDQTf796THTyNmjcgG4txMS9XtJLMdQ1Zj4,1370 +ansible/galaxy/data/network/cliconf_plugins/example.py.j2,sha256=o7LTg4ZtFLktsznLs7W8addLEJhPcK7R1LMBWEyo-TA,1532 +ansible/galaxy/data/network/defaults/main.yml.j2,sha256=niRaHtSwlcuJYidnYADqRftPPIuRQrWlEZFbw_mKFac,40 +ansible/galaxy/data/network/files/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/network/library/example_command.py.j2,sha256=maT8V02p8DIvq50pNZzkthK3AZq-rksD2K1ryBJOfi8,2534 +ansible/galaxy/data/network/library/example_config.py.j2,sha256=LSVzMgKyBTLqf9gAGu-_8H1L7toYvrsj5P677V-27fY,2519 +ansible/galaxy/data/network/library/example_facts.py.j2,sha256=IX_mZkixsTZL7aTddWDhCKpbVKoGgIBkaNKXm-40cHo,2507 +ansible/galaxy/data/network/meta/main.yml.j2,sha256=jKCpbWdUmh6ca0akpt3uiLlwEMMOWCuO3ktPfAiNuZU,1847 +ansible/galaxy/data/network/module_utils/example.py.j2,sha256=t-hsLYV9wJS2RdDAayJRfnYSD_YWagUb06pUsbvPfmk,1559 +ansible/galaxy/data/network/netconf_plugins/example.py.j2,sha256=WxE_dgLo6zqO_mHqD69e9WBh_R_0OwBl6C9cqRxoqN8,1532 +ansible/galaxy/data/network/tasks/main.yml.j2,sha256=W7rHCp3QgYrD2A6uGLALCzmKgz0_Jc_CHP13qMOjXDQ,37 +ansible/galaxy/data/network/templates/.git_keep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/galaxy/data/network/terminal_plugins/example.py.j2,sha256=j78Dr2EHhDdh1-wvNJU_bLP2VbZV3CiFmvBKS2fP3J0,1547 +ansible/galaxy/data/network/tests/inventory,sha256=4CIzgZsaCYREEFSRkYE_fMe6Ng8hKYV49LoXJ6J9h_w,11 +ansible/galaxy/data/network/tests/test.yml.j2,sha256=rjvtKhlkGT_CI_dgBLHX14eI41S6jFPypqESN8Uztgg,199 +ansible/galaxy/data/network/vars/main.yml.j2,sha256=3qtsgmeZTZ37OdmQNpmI9R6XxOEzJcOhjjGQYGFb85w,36 +ansible/galaxy/login.py,sha256=Xfvf5l0NE-HlVdw7WIeAsPpcDJaedgzfNTfdNff2MkI,4619 +ansible/galaxy/login.pyc,, +ansible/galaxy/role.py,sha256=xL8sXdT45SIGAxadOhOWOwwOO2ikas0pPSAExAr0xUQ,15558 +ansible/galaxy/role.pyc,, +ansible/galaxy/token.py,sha256=l-6uQhkHCSrMbkC-GM21NgXPBLt7BxVcIIoq5V84EXM,2142 +ansible/galaxy/token.pyc,, +ansible/inventory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/inventory/__init__.pyc,, +ansible/inventory/data.py,sha256=ZiB0Hc0zUcFq4-3CoX7ITO9BtC-zTL2NbOVrkt6Bpk8,9978 +ansible/inventory/data.pyc,, +ansible/inventory/group.py,sha256=D1b8Zft8euDSWSdlsd82PyWSr4CIXTSNFxJbwFj1xIk,7324 +ansible/inventory/group.pyc,, +ansible/inventory/helpers.py,sha256=SUYCaW0AHEe5QL-FBEe-MA-n47EqCWFipvnXlOBjljY,1131 +ansible/inventory/helpers.pyc,, +ansible/inventory/host.py,sha256=MzhoIoIPPJLnwpqRKRFs0zCG1wzA_jSFGp9UoIg_15s,4372 +ansible/inventory/host.pyc,, +ansible/inventory/manager.py,sha256=1ucwEq3lLGz5rRiROc3Gfha9OcMVc_dd5RNZq_4f27Y,24153 +ansible/inventory/manager.pyc,, +ansible/module_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/__init__.pyc,, +ansible/module_utils/_text.py,sha256=YG9qB2-xrYB-FCXJIzoTSFSAT_lUeGp5gYCkIh8jxuo,12489 +ansible/module_utils/_text.pyc,, +ansible/module_utils/acme.py,sha256=BSxuiYVxp_ORtPt1TrIJrF33cP52HoQKSn6WGFoPjG8,34762 +ansible/module_utils/acme.pyc,, +ansible/module_utils/ansible_release.py,sha256=BvqgWy384Uqith-wKCG7ZAzlKIRdcyvMea2VUocOxTI,916 +ansible/module_utils/ansible_release.pyc,, +ansible/module_utils/ansible_tower.py,sha256=CmtAtsuWgGI0v-rDa0Ak_Z-94iLtqON4GVI_lA8dpLg,4663 +ansible/module_utils/ansible_tower.pyc,, +ansible/module_utils/api.py,sha256=pHXnWxb3ojzH_YyyGbdPnJPVA2NNQS5_AGo-_-lF6JY,4446 +ansible/module_utils/api.pyc,, +ansible/module_utils/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/aws/__init__.pyc,, +ansible/module_utils/aws/batch.py,sha256=JvFLLBM4KRGHmqwEhXIpOfSi6fac9yxWxZwbNKIlyWw,3908 +ansible/module_utils/aws/batch.pyc,, +ansible/module_utils/aws/cloudfront_facts.py,sha256=qTFD-DOUlWa0NQzeWuU3JWXvilqGdgnZxgky23clsEw,11396 +ansible/module_utils/aws/cloudfront_facts.pyc,, +ansible/module_utils/aws/core.py,sha256=SFABFQIWpbvyeNczlkpO5JrQiLBfhd1CdwPySB-K1rA,11342 +ansible/module_utils/aws/core.pyc,, +ansible/module_utils/aws/direct_connect.py,sha256=t9Wb9vzsfBxWsvNtWEC42hWhF-b1yOr6HQxyfdBPOOw,4009 +ansible/module_utils/aws/direct_connect.pyc,, +ansible/module_utils/aws/elb_utils.py,sha256=U06Gp_bOeWP8TuQ2YGIPv0ASNelQtKlIwB3t-J_HNuU,3399 +ansible/module_utils/aws/elb_utils.pyc,, +ansible/module_utils/aws/elbv2.py,sha256=4B-PPKdU7P4dt_M6xBm9G6EqJs2MOdq7c7ebP24fGuc,28253 +ansible/module_utils/aws/elbv2.pyc,, +ansible/module_utils/aws/iam.py,sha256=yUBicm85YN8Gxsadj6wLMU_DU-nIi-YavTliWH83J64,2029 +ansible/module_utils/aws/iam.pyc,, +ansible/module_utils/aws/rds.py,sha256=StoSbZlgwPqE5jctYH37LVAnUbRTRa0BefeSYqnKfmQ,11212 +ansible/module_utils/aws/rds.pyc,, +ansible/module_utils/aws/urls.py,sha256=w11wYbpnwjz9JPwFpDJEnTzpHn1uitrm9OgtByTHVlk,6049 +ansible/module_utils/aws/urls.pyc,, +ansible/module_utils/aws/waf.py,sha256=T_xqIYkx3O_WPsWA7Vq1iw-PtxkkEZjqZszao0g88hQ,7415 +ansible/module_utils/aws/waf.pyc,, +ansible/module_utils/aws/waiters.py,sha256=B90tDztftWaqr-hTU7p0Q-c8aMXtw7L9O9ylL3q2N_E,10179 +ansible/module_utils/aws/waiters.pyc,, +ansible/module_utils/azure_rm_common.py,sha256=YppQ0mTbB-qMB8eCKN2QxUGTZa2RKogNzKo5p87NoBs,54924 +ansible/module_utils/azure_rm_common.pyc,, +ansible/module_utils/azure_rm_common_rest.py,sha256=p2kyBq35COtxnKnqa6aCkVMhENCnL0hd8ehuoUcrgFU,2605 +ansible/module_utils/azure_rm_common_rest.pyc,, +ansible/module_utils/basic.py,sha256=AHtum1v4sfGQSo8rm9_--0_iPzvpKkmdG12lbK-hkx0,117194 +ansible/module_utils/basic.pyc,, +ansible/module_utils/cloud.py,sha256=XN2Bd0LcWikN-_ZsLM8YMGHM9nYg2cR8cNoeDvs-R1Q,8653 +ansible/module_utils/cloud.pyc,, +ansible/module_utils/cloudscale.py,sha256=pzrzKvO70eCVA6iODwuWHXB0CM62GS5TFP1jcUuigLs,3012 +ansible/module_utils/cloudscale.pyc,, +ansible/module_utils/cloudstack.py,sha256=l8QuDJqcg7YBo5d0fiQUjZkod_OAA_PQovQAfVv9v54,24040 +ansible/module_utils/cloudstack.pyc,, +ansible/module_utils/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/common/__init__.pyc,, +ansible/module_utils/common/_collections_compat.py,sha256=HeBEQyhz6aIvW2vavhnjqpMQGQh0ojvGqieIO_Z-tyo,895 +ansible/module_utils/common/_collections_compat.pyc,, +ansible/module_utils/common/collections.py,sha256=SknlbRQ630YufzmPnfCEGlWEPuyCt39lxcolpD9RFKE,1207 +ansible/module_utils/common/collections.pyc,, +ansible/module_utils/common/dict_transformations.py,sha256=TPfsAV2woCvoZ5tpMoFQ70AHC9ADOWSdYMnz81XKBGc,4373 +ansible/module_utils/common/dict_transformations.pyc,, +ansible/module_utils/common/file.py,sha256=Eabm5U3iWJsoldsVwk-cmyTsy_WU-ZqAG5VF-su1i_o,4101 +ansible/module_utils/common/file.pyc,, +ansible/module_utils/common/process.py,sha256=7tqKAYHOjSfV2q3r8MzYHN_wSs89kcGpTT8dqAAoDs4,1504 +ansible/module_utils/common/process.pyc,, +ansible/module_utils/common/removed.py,sha256=cT-4huVLgC_8bKU7jC3up2CR70AL64PFUNgb8DnsnI4,1676 +ansible/module_utils/common/removed.pyc,, +ansible/module_utils/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/compat/__init__.pyc,, +ansible/module_utils/compat/ipaddress.py,sha256=D26X14iep4b2W6yhIB7sAzhy0pg3rRW4RV_KA_EJD0E,82541 +ansible/module_utils/compat/ipaddress.pyc,, +ansible/module_utils/connection.py,sha256=37dQyMbIpuCkFtr_-vnNObChSDNV8Isidl4h8Yrp8W0,8435 +ansible/module_utils/connection.pyc,, +ansible/module_utils/crypto.py,sha256=DpR_-Xcpch6PZP4HgavfLdbtzyWmt2qOeU9-Df1Gb4s,6395 +ansible/module_utils/crypto.pyc,, +ansible/module_utils/database.py,sha256=KCxMQonWxyjRDg4tS_B6x7JYCTMRk5kpIGBENqY3rC8,5860 +ansible/module_utils/database.pyc,, +ansible/module_utils/digital_ocean.py,sha256=KH4SFQMdXKav3TUF-g86uTsi6IBBlSzZbS0SE8hJEPk,5769 +ansible/module_utils/digital_ocean.pyc,, +ansible/module_utils/dimensiondata.py,sha256=UoXoF8JyesPYZa-C4MCGbudwi19Tq1suWxsTm2WGaCg,10848 +ansible/module_utils/dimensiondata.pyc,, +ansible/module_utils/docker_common.py,sha256=TkVZWVz7sgKjbkwlg_h8Wv8bYOs01w407fMTT-zHwng,30748 +ansible/module_utils/docker_common.pyc,, +ansible/module_utils/ec2.py,sha256=oHtNqFOB8TVsszcglnuXcF2K8038HZvJgwEVkoZdm_Q,28070 +ansible/module_utils/ec2.pyc,, +ansible/module_utils/exoscale.py,sha256=zyxAGCQzpd7hc2ek7ibWnexqdCXRGZHIvkJ6M2Nfj_g,5159 +ansible/module_utils/exoscale.pyc,, +ansible/module_utils/f5_utils.py,sha256=yZrG6rqyz7E3h9Um8MR1S9Ac-f9BPuXvc5v8wqHUZlA,12361 +ansible/module_utils/f5_utils.pyc,, +ansible/module_utils/facts/__init__.py,sha256=_layfRosh3F19zRIdCqPw_jzIfPFZHNm4IrrLJav6bQ,1943 +ansible/module_utils/facts/__init__.pyc,, +ansible/module_utils/facts/ansible_collector.py,sha256=bG3zZZpRUpZ318_MtkDVBSwlpv2RstnnzJIj6bWjnKQ,6000 +ansible/module_utils/facts/ansible_collector.pyc,, +ansible/module_utils/facts/collector.py,sha256=eApnHW1SWEHKWcv3b_tl-KyyUN3D_IKuQCN2pXI64KM,14609 +ansible/module_utils/facts/collector.pyc,, +ansible/module_utils/facts/compat.py,sha256=78OWg-RdamAOBk9b6_WaD8hFH_dZFlrD2Z_qHu2_wz4,4115 +ansible/module_utils/facts/compat.pyc,, +ansible/module_utils/facts/default_collectors.py,sha256=D19nZlUoIbmp5-CEHA7Sm5lyGlbtgP13jWgCb2LAZ-E,7579 +ansible/module_utils/facts/default_collectors.pyc,, +ansible/module_utils/facts/hardware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/facts/hardware/__init__.pyc,, +ansible/module_utils/facts/hardware/aix.py,sha256=IlTqSYSg0QuJwPoBxGfpH4A1GHmn2FYYNDECs1rx2B8,9947 +ansible/module_utils/facts/hardware/aix.pyc,, +ansible/module_utils/facts/hardware/base.py,sha256=fopMuRi7ldNkRuJW_Eg_9leuRiJyJrlQLiPOV5iIMB4,2736 +ansible/module_utils/facts/hardware/base.pyc,, +ansible/module_utils/facts/hardware/darwin.py,sha256=iofEwkHpluzhIVNQ4ynxNRHPVBRl8A3NjsHVRJcBBOo,3527 +ansible/module_utils/facts/hardware/darwin.pyc,, +ansible/module_utils/facts/hardware/dragonfly.py,sha256=naOX1OpXr2DF7GahxMf0IJf98OlVyKBzvEvriNq31tc,1090 +ansible/module_utils/facts/hardware/dragonfly.pyc,, +ansible/module_utils/facts/hardware/freebsd.py,sha256=xZqQpPEOVqUayzbLO_8B7TjZaUwnBX7tePCJGcy0yiI,7355 +ansible/module_utils/facts/hardware/freebsd.pyc,, +ansible/module_utils/facts/hardware/hpux.py,sha256=-oLGqPG7y7lbZ1LxdTs4D7GiKFn8vHNWYP-mLzhz1Bg,8351 +ansible/module_utils/facts/hardware/hpux.pyc,, +ansible/module_utils/facts/hardware/hurd.py,sha256=8_YidJiOkJ1jvaCwmxGat_9x6N1gTLs1aR7xoGFpeIc,1753 +ansible/module_utils/facts/hardware/hurd.pyc,, +ansible/module_utils/facts/hardware/linux.py,sha256=EfGj1itN5yn2Tw4gFyLaQ5RJRloN_MaWYpDQ3eaBkl8,28748 +ansible/module_utils/facts/hardware/linux.pyc,, +ansible/module_utils/facts/hardware/netbsd.py,sha256=1ZWIZHjD0snCUdCZtwMNYJ3cuZ2wX67T-NZ2i-sgS2I,5597 +ansible/module_utils/facts/hardware/netbsd.pyc,, +ansible/module_utils/facts/hardware/openbsd.py,sha256=Urfdmc5CzwXtTsGtMLeTh-NAxBXnt_INXB4bPdSeYAI,6435 +ansible/module_utils/facts/hardware/openbsd.pyc,, +ansible/module_utils/facts/hardware/sunos.py,sha256=8G01q9WD6MMu2p3hTK-eENaEcoKvznFDZWeN9XJbuXw,9980 +ansible/module_utils/facts/hardware/sunos.pyc,, +ansible/module_utils/facts/namespace.py,sha256=5wN-aloUSJeTbLBCzpGDIB_5l4xAOiW8QlRUP1uSiZ8,2366 +ansible/module_utils/facts/namespace.pyc,, +ansible/module_utils/facts/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/facts/network/__init__.pyc,, +ansible/module_utils/facts/network/aix.py,sha256=7JYZoEJpav-qHBf_MfOL67uEot_4Ut0KhyKt8-WsIvk,5982 +ansible/module_utils/facts/network/aix.pyc,, +ansible/module_utils/facts/network/base.py,sha256=v-tpl6zbFiNKGLZWjRfEbw7MiNHQNHCS-umiloYutR8,2402 +ansible/module_utils/facts/network/base.pyc,, +ansible/module_utils/facts/network/darwin.py,sha256=e3MrX4mC_QxlAMO-vyulA-XMUCNVKbapF6l_mY-28HY,2011 +ansible/module_utils/facts/network/darwin.pyc,, +ansible/module_utils/facts/network/dragonfly.py,sha256=z7AOlp7-suWyuLd2eWHhLbJV194XisJmyIYyClTQ-WU,1202 +ansible/module_utils/facts/network/dragonfly.pyc,, +ansible/module_utils/facts/network/freebsd.py,sha256=IpuBIAkEWe5N--6toRH69oSYjXkGt56DU-oWHAvgUhc,1190 +ansible/module_utils/facts/network/freebsd.pyc,, +ansible/module_utils/facts/network/generic_bsd.py,sha256=GLBXcj3AQMCAkQkeAdudgyz9GpVdPPvQZlI2zv0K1Og,11825 +ansible/module_utils/facts/network/generic_bsd.pyc,, +ansible/module_utils/facts/network/hpux.py,sha256=lDpd5OGTXRPv47sNX5EZDN4_huF_QqAZSKfiuR74E5E,3015 +ansible/module_utils/facts/network/hpux.pyc,, +ansible/module_utils/facts/network/hurd.py,sha256=yPec2qpQXARu7a2_lBgA6HGKagCZ_N3fgBZCCtVcCH8,3142 +ansible/module_utils/facts/network/hurd.pyc,, +ansible/module_utils/facts/network/iscsi.py,sha256=8V3ovg8oC8GxRFi19N1CgGo-jgA4XT7TFreZHtlk26Y,3241 +ansible/module_utils/facts/network/iscsi.pyc,, +ansible/module_utils/facts/network/linux.py,sha256=pvPfyqLL0KjvkyxYl_VKz7_o9mfcDi0FtdST9uZqHGM,16259 +ansible/module_utils/facts/network/linux.pyc,, +ansible/module_utils/facts/network/netbsd.py,sha256=cOL9liuoNYjzdWDBuVD_gqroqAvPA-0AOC4ERqOPZmk,1801 +ansible/module_utils/facts/network/netbsd.pyc,, +ansible/module_utils/facts/network/openbsd.py,sha256=eGte14uKSNF15oVqFkbgbajG9MT1Cu8VB1Dn3LX1KU8,1600 +ansible/module_utils/facts/network/openbsd.pyc,, +ansible/module_utils/facts/network/sunos.py,sha256=vVESru65sg3FEpKx3CNDo9IS-j5OosyCpaP98goicBg,4805 +ansible/module_utils/facts/network/sunos.pyc,, +ansible/module_utils/facts/other/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/facts/other/__init__.pyc,, +ansible/module_utils/facts/other/facter.py,sha256=-h7zxw9pFxKRR4NXpqAEv45LJhbNNXyXIoDHXTqP_5o,2985 +ansible/module_utils/facts/other/facter.pyc,, +ansible/module_utils/facts/other/ohai.py,sha256=j7vsRyiISo6LXvsnl3dNdZDczTWcUTkjAAErzVwSZFY,2307 +ansible/module_utils/facts/other/ohai.pyc,, +ansible/module_utils/facts/sysctl.py,sha256=iJ9vKJmsNHFHmbhyHxbj2AJdYF5aV5vBnyi2wXXLdjc,1093 +ansible/module_utils/facts/sysctl.pyc,, +ansible/module_utils/facts/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/facts/system/__init__.pyc,, +ansible/module_utils/facts/system/apparmor.py,sha256=Je00hLlJ_Q7bhe2s5yDimcUnpr2t7sJHDQvf2phgtRA,1311 +ansible/module_utils/facts/system/apparmor.pyc,, +ansible/module_utils/facts/system/caps.py,sha256=0DYC1PU6uhbRKoG2L1Z40cPhesdvwMgzJsl_DpqTVBQ,2153 +ansible/module_utils/facts/system/caps.pyc,, +ansible/module_utils/facts/system/chroot.py,sha256=JCh61tsx7ZGuKo6hJo32atOvuAPysZHiGLlO3sMOjUQ,1039 +ansible/module_utils/facts/system/chroot.pyc,, +ansible/module_utils/facts/system/cmdline.py,sha256=r_bIErRlcgIrJyhG4cqmeIizFJI_9ydj5sXyLix9BCs,1751 +ansible/module_utils/facts/system/cmdline.pyc,, +ansible/module_utils/facts/system/date_time.py,sha256=4nJHMvZZ8yh7FnMHrwhRU2AalQIipiy-6lSztnl0pSE,2597 +ansible/module_utils/facts/system/date_time.pyc,, +ansible/module_utils/facts/system/distribution.py,sha256=6RCP0g7L3SAeoCZVOmRV8_lRRrLLmnyCrZpSogBx6ZE,27715 +ansible/module_utils/facts/system/distribution.pyc,, +ansible/module_utils/facts/system/dns.py,sha256=E-5muBwwCUMir-ZAW80Zez1mUzwamECz-HHvLxw9Dmc,2678 +ansible/module_utils/facts/system/dns.pyc,, +ansible/module_utils/facts/system/env.py,sha256=zdLC-zbF_oqTSXg0O1mfC59wJfuVUqpmD6ObozZDhJw,1170 +ansible/module_utils/facts/system/env.pyc,, +ansible/module_utils/facts/system/fips.py,sha256=YlFiI5UysGuXnrSe62HkFl_bGtatDA2TsoTVhLrD2bs,1338 +ansible/module_utils/facts/system/fips.pyc,, +ansible/module_utils/facts/system/local.py,sha256=exTL_0soAF9EGY-YHwDiE3KCKlh5JFozYyaa3OmbuMI,3138 +ansible/module_utils/facts/system/local.pyc,, +ansible/module_utils/facts/system/lsb.py,sha256=8i3aBS3nko8z1UENyQmCBBZ1VCPhBr-lOB3VXpeYd1g,3311 +ansible/module_utils/facts/system/lsb.pyc,, +ansible/module_utils/facts/system/pkg_mgr.py,sha256=jjJbGyXi3PVYIUzn02cL1GBS6rYwsUN3gKvOexidGBg,6489 +ansible/module_utils/facts/system/pkg_mgr.pyc,, +ansible/module_utils/facts/system/platform.py,sha256=dVv4B7YobEfdnH6nOo3VGjJEAN6EZKuDK_OkqhldOIE,3974 +ansible/module_utils/facts/system/platform.pyc,, +ansible/module_utils/facts/system/python.py,sha256=DKB3aCI4y1wRNqVMDEl7BbHXwi4bn2UOnnm324qwN1I,1999 +ansible/module_utils/facts/system/python.pyc,, +ansible/module_utils/facts/system/selinux.py,sha256=muCNB3mFrX8YoAG5VpUjnwDhauuEoQSN_w_Wq4J1cCI,3207 +ansible/module_utils/facts/system/selinux.pyc,, +ansible/module_utils/facts/system/service_mgr.py,sha256=qr94SJu-8ZCOa76XWQR29uVL6g1AOvBTYUu_OCC2epU,6057 +ansible/module_utils/facts/system/service_mgr.pyc,, +ansible/module_utils/facts/system/ssh_pub_keys.py,sha256=GkMX7PZ-WqLNQuSDtqSjPhubr_vBsyom5jrbwaVTpO0,2119 +ansible/module_utils/facts/system/ssh_pub_keys.pyc,, +ansible/module_utils/facts/system/user.py,sha256=aO4i9xSI7RTRr6k_9YDLaX2pJqtP_G7dNlvxKzPaMIA,1788 +ansible/module_utils/facts/system/user.pyc,, +ansible/module_utils/facts/timeout.py,sha256=AefP9KyJlEL02wxI_lb4wL_CJ9rEgeEgLWF2E2V8g7s,2452 +ansible/module_utils/facts/timeout.pyc,, +ansible/module_utils/facts/utils.py,sha256=9mPPCVTutNlKtZBZtBw35yFCFzBhG0MM7B83ZNJ45_g,2434 +ansible/module_utils/facts/utils.pyc,, +ansible/module_utils/facts/virtual/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/facts/virtual/__init__.pyc,, +ansible/module_utils/facts/virtual/base.py,sha256=e81aoA3sqa0ORPcYZs-QgRrtIkswaWwHbgG1Z9ZoZ5k,2298 +ansible/module_utils/facts/virtual/base.pyc,, +ansible/module_utils/facts/virtual/dragonfly.py,sha256=h8Xap4VGXOO3j8-fLUtVVe9-OwoqqLkaAV8VRHk-gL0,1012 +ansible/module_utils/facts/virtual/dragonfly.pyc,, +ansible/module_utils/facts/virtual/freebsd.py,sha256=D5slJEZpSX6SuUQGdtawYXqC0jJuZniXOfuYEs93EJk,1525 +ansible/module_utils/facts/virtual/freebsd.pyc,, +ansible/module_utils/facts/virtual/hpux.py,sha256=z-9c3FIx5DjkC-M9Rh6fjVw7gvjgbTtMd96YlRQNwVU,2486 +ansible/module_utils/facts/virtual/hpux.pyc,, +ansible/module_utils/facts/virtual/linux.py,sha256=Ccb-ULsukX6BEHSQkyrjTWTzhpf7aLjfffpHDo7gwkU,11391 +ansible/module_utils/facts/virtual/linux.pyc,, +ansible/module_utils/facts/virtual/netbsd.py,sha256=jyuLkxZ1T7tAO37GXAvxFaUnPrFvCpoM6TcCdcCzxNU,1833 +ansible/module_utils/facts/virtual/netbsd.pyc,, +ansible/module_utils/facts/virtual/openbsd.py,sha256=CpqfoGyxKGxR-lJqMjaBDLH7Yh7N6e-eMkhOm2noAXk,2319 +ansible/module_utils/facts/virtual/openbsd.pyc,, +ansible/module_utils/facts/virtual/sunos.py,sha256=nWG36V5FjzPpzZ-prtJRZOhlg_ilf-Ka5_yNMltHxZw,5481 +ansible/module_utils/facts/virtual/sunos.pyc,, +ansible/module_utils/facts/virtual/sysctl.py,sha256=nqaF1JONrG-wv-pZCKSBCe-aTD5nPQAynKHqyJoePWs,3192 +ansible/module_utils/facts/virtual/sysctl.pyc,, +ansible/module_utils/firewalld.py,sha256=8lEF0OXjFgkQjJaFQhQ2cLbx6Hh1hx_pYAEWbePr7Sc,11435 +ansible/module_utils/firewalld.pyc,, +ansible/module_utils/gcdns.py,sha256=D2ewrs_4UF2FdLj6zmM9Z7JLvfFNDRpUhmPK_G1s56U,2531 +ansible/module_utils/gcdns.pyc,, +ansible/module_utils/gce.py,sha256=017g8cRhTIwsdX3tk9icUavM6VkZfHWFYtxtffoEjnk,2535 +ansible/module_utils/gce.pyc,, +ansible/module_utils/gcp.py,sha256=0qiAJqwoeqJF1iF-rs_rT02ZvDkIpa6jzRDUPND3sTc,32636 +ansible/module_utils/gcp.pyc,, +ansible/module_utils/gcp_utils.py,sha256=AHK_2-5EsmK9x9LCUvveAXnJSzAWoGIQrudn1_kkPYg,9147 +ansible/module_utils/gcp_utils.pyc,, +ansible/module_utils/gitlab.py,sha256=S0X6cmA0DkXntJY6n_WhXAVNLN49IFuNbroRC5p-XwE,1179 +ansible/module_utils/gitlab.pyc,, +ansible/module_utils/heroku.py,sha256=DVE_9OVKMK4LkRzRYtSAKQ8-DoxPukBvlLIvrSb8WWc,1133 +ansible/module_utils/heroku.pyc,, +ansible/module_utils/ibm_sa_utils.py,sha256=7Dj2x1X4Q5-e8uymex_CHwh1fT2M6Rlll0ogrNJTa_E,2796 +ansible/module_utils/ibm_sa_utils.pyc,, +ansible/module_utils/infinibox.py,sha256=2YBaowHMnVPXkYwR8i3dXhvC9nczWod8Q_W2Z38gCJI,3673 +ansible/module_utils/infinibox.pyc,, +ansible/module_utils/influxdb.py,sha256=mP7ZyxjFUJrXkHwuIe5seR4OQfQFRO3zqddOl9Jt6BE,2703 +ansible/module_utils/influxdb.pyc,, +ansible/module_utils/ipa.py,sha256=BC68VnKR-78kWg-6KYeQCNtN6BAvfcARzKoL9mh8sV4,7949 +ansible/module_utils/ipa.pyc,, +ansible/module_utils/ismount.py,sha256=pGHJBA7Ik0NB5rpE5otD-l6Cbra4aHYq68SnyQLJipw,4030 +ansible/module_utils/ismount.pyc,, +ansible/module_utils/json_utils.py,sha256=vXFELOGuHyexpDtbojZFiJnORGYvUFVuD4sH_Hppi10,3293 +ansible/module_utils/json_utils.pyc,, +ansible/module_utils/k8s/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/k8s/__init__.pyc,, +ansible/module_utils/k8s/common.py,sha256=bIx518Ziws0lkbIsxT0W2rHPZrfrQ-khlLy_kZq7m48,8685 +ansible/module_utils/k8s/common.pyc,, +ansible/module_utils/k8s/inventory.py,sha256=bqZIatCQ9AekrYPS-HTn6_NC2ZeQK5gsDvS2HCxw_jk,15856 +ansible/module_utils/k8s/inventory.pyc,, +ansible/module_utils/k8s/raw.py,sha256=XtDfqb-qkSrrfeoVeAG2tB4rciUaAULHjzMgj0_dLo4,11659 +ansible/module_utils/k8s/raw.pyc,, +ansible/module_utils/k8s/scale.py,sha256=EPzgiCXZpcpiCXUg2-sPjdjsGFRBcBy_IuGHVf9eQK0,7586 +ansible/module_utils/k8s/scale.pyc,, +ansible/module_utils/keycloak.py,sha256=Fl6faKjoy8f5BurxOQlCqpFBwwyYyDA8GVPixMq6qGY,15912 +ansible/module_utils/keycloak.pyc,, +ansible/module_utils/known_hosts.py,sha256=M3jrwIaIoD7EBqa3XdMAMSY5HLWkeGrd1ZVbR1EBMGI,6919 +ansible/module_utils/known_hosts.pyc,, +ansible/module_utils/ldap.py,sha256=zcAZJG8tDCNwqHE9cERo0Uk_Ayhe-VQgxlBINfnnm4o,2327 +ansible/module_utils/ldap.pyc,, +ansible/module_utils/lxd.py,sha256=74EhcRoNRTDiWxDCOv12yYqp1oOjckcFHkgB8IDVSJ8,6224 +ansible/module_utils/lxd.pyc,, +ansible/module_utils/manageiq.py,sha256=kpVgh8Ogp__NqO8tZEQUnXGCwbVmLDNN6hHBUyBjYWE,6038 +ansible/module_utils/manageiq.pyc,, +ansible/module_utils/memset.py,sha256=33PtSofjZbxJOJeoxg8QDzS-B_ZW3rWFExkpm5rOhb4,5172 +ansible/module_utils/memset.pyc,, +ansible/module_utils/mysql.py,sha256=u-yLUUk8POJVL37qeqbmxecwhtU5ICBm0X3nN_QFduI,3607 +ansible/module_utils/mysql.pyc,, +ansible/module_utils/net_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/net_tools/__init__.pyc,, +ansible/module_utils/net_tools/nios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/net_tools/nios/__init__.pyc,, +ansible/module_utils/net_tools/nios/api.py,sha256=9lVPk9t2qIcilxN6YoBNhEOkc1Et9nBonaIeodGhS8g,16494 +ansible/module_utils/net_tools/nios/api.pyc,, +ansible/module_utils/netapp.py,sha256=bdcNPVGi9WztTm-CwgmDAg0Ak590vAnElx_Gg1F5UHU,9888 +ansible/module_utils/netapp.pyc,, +ansible/module_utils/netapp_elementsw_module.py,sha256=SecyoHwAPv8F8Bvus6E1q-MDjFyD_LBfwLhGeGB-VIM,5431 +ansible/module_utils/netapp_elementsw_module.pyc,, +ansible/module_utils/netapp_module.py,sha256=CDUnjZCUUA0_Tw9WSbafU_eM7bTLMmAtm5LY0b1J4cs,5878 +ansible/module_utils/netapp_module.pyc,, +ansible/module_utils/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/__init__.pyc,, +ansible/module_utils/network/a10/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/a10/__init__.pyc,, +ansible/module_utils/network/a10/a10.py,sha256=vVKNYtDJT113UbbebFJunFk7ZuDBBSIc7F_8399lZTQ,5900 +ansible/module_utils/network/a10/a10.pyc,, +ansible/module_utils/network/aci/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/aci/__init__.pyc,, +ansible/module_utils/network/aci/aci.py,sha256=lugbt8IRjJ3UNp4RGi7aa_yDdPPtZxCdvKpNNXsZupw,44250 +ansible/module_utils/network/aci/aci.pyc,, +ansible/module_utils/network/aireos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/aireos/__init__.pyc,, +ansible/module_utils/network/aireos/aireos.py,sha256=v7btyaCjG9B3-g7PyPgabo0xRFZ-hlEORqMs-H0geR8,5010 +ansible/module_utils/network/aireos/aireos.pyc,, +ansible/module_utils/network/aos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/aos/__init__.pyc,, +ansible/module_utils/network/aos/aos.py,sha256=3N9ReRi40E3edRaY-2qp4m9aDO0iNIUl9DAk1l5DJSE,5678 +ansible/module_utils/network/aos/aos.pyc,, +ansible/module_utils/network/aruba/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/aruba/__init__.pyc,, +ansible/module_utils/network/aruba/aruba.py,sha256=XWDJWjy6AnGxV-ykyRF3hZUKd33-gbzCowOuXXNGkdg,4862 +ansible/module_utils/network/aruba/aruba.pyc,, +ansible/module_utils/network/asa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/asa/__init__.pyc,, +ansible/module_utils/network/asa/asa.py,sha256=PGZbfIgWTPZhw_uu39-cjwveL651ZtZq0E70VY4wV6Q,5729 +ansible/module_utils/network/asa/asa.pyc,, +ansible/module_utils/network/avi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/avi/__init__.pyc,, +ansible/module_utils/network/avi/avi.py,sha256=yR9Npn76UJe3NEuI-X9gDOvEomc_rC_UTy2v00L2wAk,4188 +ansible/module_utils/network/avi/avi.pyc,, +ansible/module_utils/network/bigswitch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/bigswitch/__init__.pyc,, +ansible/module_utils/network/bigswitch/bigswitch.py,sha256=kyM9WTfxtM8cLh7x0eYkNDqfAG-avY1rhBz0jvjeb1w,3354 +ansible/module_utils/network/bigswitch/bigswitch.pyc,, +ansible/module_utils/network/cloudengine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/cloudengine/__init__.pyc,, +ansible/module_utils/network/cloudengine/ce.py,sha256=PofzZaUiF4sUWv-TlsGpn_3G-oXIHAwDVAHgM8uylxc,11924 +ansible/module_utils/network/cloudengine/ce.pyc,, +ansible/module_utils/network/cnos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/cnos/__init__.pyc,, +ansible/module_utils/network/cnos/cnos.py,sha256=1QdFae8qqzncmf0Hys2yZhftWjsrDKJHPm-6zhmDEsk,69701 +ansible/module_utils/network/cnos/cnos.pyc,, +ansible/module_utils/network/cnos/cnos_devicerules.py,sha256=6P6WFsFPJaZh7abFbgZMBOkHZnWOh5k69fRqHpOpwX8,91033 +ansible/module_utils/network/cnos/cnos_devicerules.pyc,, +ansible/module_utils/network/cnos/cnos_errorcodes.py,sha256=hSS4w4yFeTkQAPTQT5YBw16dv1TSE0eTtiNugzPFNgM,12205 +ansible/module_utils/network/cnos/cnos_errorcodes.pyc,, +ansible/module_utils/network/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/common/__init__.pyc,, +ansible/module_utils/network/common/config.py,sha256=xGRGJw8eNyTckUfbaWnUeXOPyrtZmlLD26Tkz-uaX8c,13804 +ansible/module_utils/network/common/config.pyc,, +ansible/module_utils/network/common/netconf.py,sha256=bYuVmXgZCoEoa_2hm9tc5js05ZVC0ZLKbTpPGXp1QZY,5732 +ansible/module_utils/network/common/netconf.pyc,, +ansible/module_utils/network/common/network.py,sha256=VG46EiC0d2m9mQ3u4bsEEjscmmWOXVFxeywhPavZkrI,7047 +ansible/module_utils/network/common/network.pyc,, +ansible/module_utils/network/common/parsing.py,sha256=k1zkZenGZpPWSWkrbuXpUZ1U9Za_WASCgcR7LxGWq-c,10030 +ansible/module_utils/network/common/parsing.pyc,, +ansible/module_utils/network/common/utils.py,sha256=kEF9DnqC7mCHMI1Xaa1ynLsHxu_4ZW6f1Jhs6N41PBc,17818 +ansible/module_utils/network/common/utils.pyc,, +ansible/module_utils/network/dellos10/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/dellos10/__init__.pyc,, +ansible/module_utils/network/dellos10/dellos10.py,sha256=nkdWSSF8NQNDuWqRUG22J0EbcBBrQR6v9F9z5FS0kMI,5827 +ansible/module_utils/network/dellos10/dellos10.pyc,, +ansible/module_utils/network/dellos6/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/dellos6/__init__.pyc,, +ansible/module_utils/network/dellos6/dellos6.py,sha256=YgXm4BOqlqg0Bm2AEZPk8R3lxJxwTqXqSKyiz9AXc1s,9815 +ansible/module_utils/network/dellos6/dellos6.pyc,, +ansible/module_utils/network/dellos9/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/dellos9/__init__.pyc,, +ansible/module_utils/network/dellos9/dellos9.py,sha256=EAxY1RtzYJSqeZwRbi17_PYK0tWfd2XntAQYENRjRK4,5791 +ansible/module_utils/network/dellos9/dellos9.pyc,, +ansible/module_utils/network/edgeos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/edgeos/__init__.pyc,, +ansible/module_utils/network/edgeos/edgeos.py,sha256=wr10g-JsymqVwpoYPKUs9KPp7r8IwuDaDGQbejkcGwg,4609 +ansible/module_utils/network/edgeos/edgeos.pyc,, +ansible/module_utils/network/enos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/enos/__init__.pyc,, +ansible/module_utils/network/enos/enos.py,sha256=WWMxWjYVUurl9bz38H-LnW2Z2G-yv8sZq-43y35trto,5474 +ansible/module_utils/network/enos/enos.pyc,, +ansible/module_utils/network/eos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/eos/__init__.pyc,, +ansible/module_utils/network/eos/eos.py,sha256=oQuaDSQgxCduXYkhNDIukindUTf5af2JeKOc6CWs9hk,15982 +ansible/module_utils/network/eos/eos.pyc,, +ansible/module_utils/network/exos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/exos/__init__.pyc,, +ansible/module_utils/network/exos/exos.py,sha256=JI8swdwBgUkNNqq78eUWdnXGiopFLDcViemj7nYDvAE,3764 +ansible/module_utils/network/exos/exos.pyc,, +ansible/module_utils/network/f5/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/f5/__init__.pyc,, +ansible/module_utils/network/f5/bigip.py,sha256=YzM9eQgJ8pXxOytzYdB8VY58kv7JkrxPBLAUNnQqE8A,3737 +ansible/module_utils/network/f5/bigip.pyc,, +ansible/module_utils/network/f5/bigiq.py,sha256=7s8Hhd7Mbbxc2XrpH9xgStkOk8xPaOWiywoISsxQ6QE,3847 +ansible/module_utils/network/f5/bigiq.pyc,, +ansible/module_utils/network/f5/common.py,sha256=Kb0npOBMjcoaJaoZuvpy08HaaHkDNr3rCeJkCk5Aa10,20493 +ansible/module_utils/network/f5/common.pyc,, +ansible/module_utils/network/f5/icontrol.py,sha256=k6Vo_E-tNwzFrQYG-1q1g5890L4fDHpta17wMzyitpY,17087 +ansible/module_utils/network/f5/icontrol.pyc,, +ansible/module_utils/network/f5/ipaddress.py,sha256=IYUg3b3vEAQDe5GpGMtOAMjmFPgUOutuq3faWYcT0hM,2504 +ansible/module_utils/network/f5/ipaddress.pyc,, +ansible/module_utils/network/f5/iworkflow.py,sha256=lGjpgM_k3WpYwSDev2jemJ3dZyq8DAlq_PGOCx4mok8,2060 +ansible/module_utils/network/f5/iworkflow.pyc,, +ansible/module_utils/network/f5/legacy.py,sha256=PZUEzZ7qtKMhjfIXQSAtesZFeNdlkXhqAHTQLdL58k0,3895 +ansible/module_utils/network/f5/legacy.pyc,, +ansible/module_utils/network/fortimanager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/fortimanager/__init__.pyc,, +ansible/module_utils/network/fortimanager/fortimanager.py,sha256=VhDonVrx4aOuvgNndTFzRPDlyqhyoA8lmR7hrp9e07Q,3514 +ansible/module_utils/network/fortimanager/fortimanager.pyc,, +ansible/module_utils/network/fortios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/fortios/__init__.pyc,, +ansible/module_utils/network/fortios/fortios.py,sha256=gS7rfO21J_fmtU4pLq-l0Qeii2b8qVzaZNP1vt6IUr4,8000 +ansible/module_utils/network/fortios/fortios.pyc,, +ansible/module_utils/network/ftd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/ftd/__init__.pyc,, +ansible/module_utils/network/ftd/common.py,sha256=xGBEvy6PeeIIP09wvE9uqiEyddamfcfiiJ5AWB8f8eQ,6027 +ansible/module_utils/network/ftd/common.pyc,, +ansible/module_utils/network/ftd/configuration.py,sha256=j4LSk6BA45yMXWMliPUWgkMu4bLplqc4Gmc8dekkN90,24087 +ansible/module_utils/network/ftd/configuration.pyc,, +ansible/module_utils/network/ftd/fdm_swagger_client.py,sha256=xH42Sb9SDewFXUxx-PJQVCNPOtoS7WWAV1BaEgfNxR8,26161 +ansible/module_utils/network/ftd/fdm_swagger_client.pyc,, +ansible/module_utils/network/ios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/ios/__init__.pyc,, +ansible/module_utils/network/ios/ios.py,sha256=1GqPelT3k9qXSB-xNZ3l6eFjvTcWp5BHU1Ay6FZzv1U,7105 +ansible/module_utils/network/ios/ios.pyc,, +ansible/module_utils/network/iosxr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/iosxr/__init__.pyc,, +ansible/module_utils/network/iosxr/iosxr.py,sha256=q6tURp2w426iWGPKnYI6eaw7GV6uUUTL8-RwJmKCz9c,21473 +ansible/module_utils/network/iosxr/iosxr.pyc,, +ansible/module_utils/network/ironware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/ironware/__init__.pyc,, +ansible/module_utils/network/ironware/ironware.py,sha256=lQNi2LFUUDT6_JFSPVHsRP-SefbbWf6U1lsSdd6M-8A,3517 +ansible/module_utils/network/ironware/ironware.pyc,, +ansible/module_utils/network/junos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/junos/__init__.pyc,, +ansible/module_utils/network/junos/junos.py,sha256=iKt5ctw5cOtnv2OTvVOAbuo01TwG76s_z0mFMGd2lek,15286 +ansible/module_utils/network/junos/junos.pyc,, +ansible/module_utils/network/meraki/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/meraki/__init__.pyc,, +ansible/module_utils/network/meraki/meraki.py,sha256=WFhlNdz2ag94BVeRn297nXj70iJR9ixMNa7qW2XlPXY,13485 +ansible/module_utils/network/meraki/meraki.pyc,, +ansible/module_utils/network/netconf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/netconf/__init__.pyc,, +ansible/module_utils/network/netconf/netconf.py,sha256=E94Wf2bKbsafwLiItNK3q9kijL9RG0Gs9OC8iIDIO0o,3910 +ansible/module_utils/network/netconf/netconf.pyc,, +ansible/module_utils/network/netscaler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/netscaler/__init__.pyc,, +ansible/module_utils/network/netscaler/netscaler.py,sha256=3ehbH1KCofLM1_zsfOkuJEC8EIyz8DdjcMSH_o0xPws,12064 +ansible/module_utils/network/netscaler/netscaler.pyc,, +ansible/module_utils/network/nos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/nos/__init__.pyc,, +ansible/module_utils/network/nos/nos.py,sha256=2KikPz6JVTd1i7QEIVK-Ti6MeadNMXcLiqgvfC3Mrn8,4786 +ansible/module_utils/network/nos/nos.pyc,, +ansible/module_utils/network/nso/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/nso/__init__.pyc,, +ansible/module_utils/network/nso/nso.py,sha256=tqtqNhrr2yDfH3mRi4lKMCDX3roA1fCP6AyUFUcv1uE,27045 +ansible/module_utils/network/nso/nso.pyc,, +ansible/module_utils/network/nxos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/nxos/__init__.pyc,, +ansible/module_utils/network/nxos/nxos.py,sha256=kVJHk21smUdDOdtS0lcmNvN3EP2hI8-5Uf0KUfTBoxI,20458 +ansible/module_utils/network/nxos/nxos.pyc,, +ansible/module_utils/network/onyx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/onyx/__init__.pyc,, +ansible/module_utils/network/onyx/onyx.py,sha256=W91wX4l3vCeM8I5fX9U15BZITL2NgQofXPYLaQN4-z8,6984 +ansible/module_utils/network/onyx/onyx.pyc,, +ansible/module_utils/network/ordnance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/ordnance/__init__.pyc,, +ansible/module_utils/network/ordnance/ordnance.py,sha256=76o8-4cPhvrLULUFFxHc2NjjEaPJbMV3NPhDnrgvwe8,487 +ansible/module_utils/network/ordnance/ordnance.pyc,, +ansible/module_utils/network/routeros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/routeros/__init__.pyc,, +ansible/module_utils/network/routeros/routeros.py,sha256=Ze2XIyu8jEXTwEnC-yDeuonydZgJxhCwj5wrrHkEf9E,5356 +ansible/module_utils/network/routeros/routeros.pyc,, +ansible/module_utils/network/slxos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/slxos/__init__.pyc,, +ansible/module_utils/network/slxos/slxos.py,sha256=rXnXoo_4owiQ_s636oBpu6_T-ih12JWvT6g41WLnIWk,4326 +ansible/module_utils/network/slxos/slxos.pyc,, +ansible/module_utils/network/sros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/sros/__init__.pyc,, +ansible/module_utils/network/sros/sros.py,sha256=gXni9XBROUUMFiPBy-haP30JZb7-7O4a0YJEqMwMsAw,4333 +ansible/module_utils/network/sros/sros.pyc,, +ansible/module_utils/network/voss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/voss/__init__.pyc,, +ansible/module_utils/network/voss/voss.py,sha256=Rn3WZaRZH4sQc9dGPynuP06GL2WcH8U_7A-CXQ9EakY,4305 +ansible/module_utils/network/voss/voss.pyc,, +ansible/module_utils/network/vyos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/network/vyos/__init__.pyc,, +ansible/module_utils/network/vyos/vyos.py,sha256=LElINGhRpXQ_1v3RL2DzqDUq5dTUrsKRncSm5JALuhc,4718 +ansible/module_utils/network/vyos/vyos.pyc,, +ansible/module_utils/oneandone.py,sha256=Y6g9m50oHRnFeY2P9fYf8RC6Pr9-FSQ4NZqZJPmJ9HE,10662 +ansible/module_utils/oneandone.pyc,, +ansible/module_utils/oneview.py,sha256=IUO_NN-TJ9XfXDK6NSlxbJWyuF5wDzVzjha5YcWYrFs,18856 +ansible/module_utils/oneview.pyc,, +ansible/module_utils/online.py,sha256=oCle_IWxbdUPNfeMVq39PURN2QzT4Lc_jLQgJRmWTSg,3831 +ansible/module_utils/online.pyc,, +ansible/module_utils/opennebula.py,sha256=dUUXEpG6eTdH0PVEXCSTviDvNBno_tt3pElgulqn76Q,10446 +ansible/module_utils/opennebula.pyc,, +ansible/module_utils/openstack.py,sha256=VsEOLR0363Qyr98tFkmew3rKg6U5kbP6uccXEsoak1w,6800 +ansible/module_utils/openstack.pyc,, +ansible/module_utils/ovirt.py,sha256=1XAeZ7fkCsemZirW91s106qP3ITo970W9PEkitMM-pg,27092 +ansible/module_utils/ovirt.pyc,, +ansible/module_utils/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/parsing/__init__.pyc,, +ansible/module_utils/parsing/convert_bool.py,sha256=mNdWQc_CvTtBLKx3Gy54JEc5A5yhFeBk3TzSPn1eUOQ,1008 +ansible/module_utils/parsing/convert_bool.pyc,, +ansible/module_utils/postgres.py,sha256=CEnhRW8_ebob9aPXDFc7wfHl678bMic9W24eI6h3dcM,2709 +ansible/module_utils/postgres.pyc,, +ansible/module_utils/powershell/Ansible.ModuleUtils.ArgvParser.psm1,sha256=svUfNYnIipHMWK6CIw3u4__uo7VmoUmwcUK_gaQtUpE,3294 +ansible/module_utils/powershell/Ansible.ModuleUtils.CamelConversion.psm1,sha256=I1MBgVAvoeI_e7MVB6HdT49UlfS_GC0fWduop-TT6zs,2444 +ansible/module_utils/powershell/Ansible.ModuleUtils.CommandUtil.psm1,sha256=5YG88nWWbccyEPTIhTGbTvdRJ1AbhdgC_4epw4nB4Rw,16546 +ansible/module_utils/powershell/Ansible.ModuleUtils.FileUtil.psm1,sha256=oNutMZG4MLGSyBvOhMkq6D38ccB2rH4J2r6-iiyH6gw,2173 +ansible/module_utils/powershell/Ansible.ModuleUtils.Legacy.psm1,sha256=nPOdijfDfYba2AJpJQ6T5Fc9jquoGPbRXN_za9-cjMo,12591 +ansible/module_utils/powershell/Ansible.ModuleUtils.LinkUtil.psm1,sha256=SLCH5fM2g6IBtAx4fyO6Sj27ERiIYTIB44joMeAcZRA,17544 +ansible/module_utils/powershell/Ansible.ModuleUtils.PrivilegeUtil.psm1,sha256=qajSFOE4kU5uohctaaL0gFE_ZOgllEcy0CYu4P4mr-A,20516 +ansible/module_utils/powershell/Ansible.ModuleUtils.SID.psm1,sha256=ihLxeDDGIik-YQVbX4dICKQRK6qK6hBXluPPSd1zMZw,3766 +ansible/module_utils/powershell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/powershell/__init__.pyc,, +ansible/module_utils/pure.py,sha256=bx3J9a_yklPF2gkFIJpS_ErhtjF12knvjl9DKPagvxY,4750 +ansible/module_utils/pure.pyc,, +ansible/module_utils/pycompat24.py,sha256=TQX7b5AX951jhS9rHmyDtfkPg_YM0YoEwDm5y8BSlVs,4055 +ansible/module_utils/pycompat24.pyc,, +ansible/module_utils/rax.py,sha256=kdvoPNNvtT2zk_xtTdaSuRnpUjqBgCMD7Nr-r9ycPlA,12063 +ansible/module_utils/rax.pyc,, +ansible/module_utils/redfish_utils.py,sha256=Debb5Tasoeenoe6ww31BueLpLgQWWs7tHT0Eg76txt4,37101 +ansible/module_utils/redfish_utils.pyc,, +ansible/module_utils/redhat.py,sha256=47p6IfPjgMnszpmFCz2Y2vwm06KVdtmrSmB5LrEjNA8,10351 +ansible/module_utils/redhat.pyc,, +ansible/module_utils/remote_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/remote_management/__init__.pyc,, +ansible/module_utils/remote_management/ucs.py,sha256=IJNo778GO1TUeWikSnQIBd6_s-VEzXP-5iCUjP5BE_I,3697 +ansible/module_utils/remote_management/ucs.pyc,, +ansible/module_utils/scaleway.py,sha256=LH0cR99OmKzocXY_6Ftr9iRkg5N35Wus_KZfIY5kQkc,4064 +ansible/module_utils/scaleway.pyc,, +ansible/module_utils/service.py,sha256=gdFLMkF7F0rk072ju2IkL-Bn9pLGlAjgxLa6CT2hamk,9242 +ansible/module_utils/service.pyc,, +ansible/module_utils/six/__init__.py,sha256=NqiO_jCj0Se0cyjTl5OS8dVV8NcxoZJYRGlsMpOarhI,31146 +ansible/module_utils/six/__init__.pyc,, +ansible/module_utils/splitter.py,sha256=fVYaM9O3iPyOhwcElhIQb6i5Zc1xiLz7SSkeYFlepmc,9433 +ansible/module_utils/splitter.pyc,, +ansible/module_utils/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/storage/__init__.pyc,, +ansible/module_utils/storage/emc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/module_utils/storage/emc/__init__.pyc,, +ansible/module_utils/storage/emc/emc_vnx.py,sha256=vz8xwdYaNS1e02b1xKExtnh_LNAzrlR9KUIgzfjv_FI,1915 +ansible/module_utils/storage/emc/emc_vnx.pyc,, +ansible/module_utils/univention_umc.py,sha256=s-uOT8wnkI9w5CbY-aioXkmdOvt9pX0N4LWQutXJAgY,8767 +ansible/module_utils/univention_umc.pyc,, +ansible/module_utils/urls.py,sha256=ik_zf0b4-jCDwpzdEZDE-mSsCSD2snKrG0p_i-2fNZg,54890 +ansible/module_utils/urls.pyc,, +ansible/module_utils/vca.py,sha256=3a9W5To8NfOljEGbc4kDdZL0NgQUl3goCbk1GLfMNkw,11177 +ansible/module_utils/vca.pyc,, +ansible/module_utils/vmware.py,sha256=gW9rGnTAQq3h6T48eV31etTlxqdOPjF6Zu8GgyqOn8k,41595 +ansible/module_utils/vmware.pyc,, +ansible/module_utils/vmware_rest_client.py,sha256=__mtAa5hR6F82vB9WKkUxug1bJJ8X-MkLqi1osVYnJ0,5700 +ansible/module_utils/vmware_rest_client.pyc,, +ansible/module_utils/vultr.py,sha256=pKyOXEckoDOnzn4dS290buAUAaanva2m9fx1P0dxx_I,11081 +ansible/module_utils/vultr.pyc,, +ansible/module_utils/yumdnf.py,sha256=9Uie45AC8pQkCSLPoaMY50Y13Xk3S3Wc8T0oIYxG1H0,6117 +ansible/module_utils/yumdnf.pyc,, +ansible/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/__init__.pyc,, +ansible/modules/cloud/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/__init__.pyc,, +ansible/modules/cloud/amazon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/amazon/__init__.pyc,, +ansible/modules/cloud/amazon/_ec2_ami_find.py,sha256=awK00rYZbvYh04kvayHeMUmMV3NVAsjfNRWy66p-0OI,13458 +ansible/modules/cloud/amazon/_ec2_ami_find.pyc,, +ansible/modules/cloud/amazon/_ec2_ami_search.py,sha256=zA1LmP_0IZ8XrifhTjnO8sX3dRijmLdWOfBmjON_Kho,500 +ansible/modules/cloud/amazon/_ec2_ami_search.pyc,, +ansible/modules/cloud/amazon/_ec2_facts.py,sha256=P5MvTEUZR-2zoe-WWZni39qqRxLtOlcKAt2wdNLNCZ8,533 +ansible/modules/cloud/amazon/_ec2_facts.pyc,, +ansible/modules/cloud/amazon/_ec2_remote_facts.py,sha256=X1ESnJIpJ0P2i6ADaOhlZ-FY56LJedg0UVI27Q1RHRg,14423 +ansible/modules/cloud/amazon/_ec2_remote_facts.pyc,, +ansible/modules/cloud/amazon/_ec2_vpc.py,sha256=BNYkxI1DnsPuYdmIG1E1HmcFhw2WoslildGJn9V4kpQ,499 +ansible/modules/cloud/amazon/_ec2_vpc.pyc,, +ansible/modules/cloud/amazon/_ec2_vpc_dhcp_options.py,sha256=W5lqDCdoAWM3bX_IgUW9xUPC4YvqwK3qF5Dh_QtXv-o,15811 +ansible/modules/cloud/amazon/_ec2_vpc_dhcp_options.pyc,, +ansible/modules/cloud/amazon/_ec2_vpc_dhcp_options_facts.py,sha256=y5hzAqaY4bYE5vHyOdcD8-gXpXtd9lSTczq3w4Z-KCs,4842 +ansible/modules/cloud/amazon/_ec2_vpc_dhcp_options_facts.pyc,, +ansible/modules/cloud/amazon/_iam_cert_facts.py,sha256=XdL2WO3y48O4pG_HLQA6iUKp7R8el_VxvSk1wNfZrEc,5371 +ansible/modules/cloud/amazon/_iam_cert_facts.pyc,, +ansible/modules/cloud/amazon/_s3.py,sha256=P5MvTEUZR-2zoe-WWZni39qqRxLtOlcKAt2wdNLNCZ8,533 +ansible/modules/cloud/amazon/_s3.pyc,, +ansible/modules/cloud/amazon/aws_acm_facts.py,sha256=0ENszOI5DWlyaWaWCIskRYpaUgJJol64Mu6mFhl3vig,11620 +ansible/modules/cloud/amazon/aws_acm_facts.pyc,, +ansible/modules/cloud/amazon/aws_api_gateway.py,sha256=H8q-X3vGuQ7FQK2SIUHOfvl5xiSqS4JZKz22pcJcPtA,9671 +ansible/modules/cloud/amazon/aws_api_gateway.pyc,, +ansible/modules/cloud/amazon/aws_application_scaling_policy.py,sha256=0SVTc2POoZmiDwSh7Wi7D-udv2ka-CAtJ8CxespR3iM,22103 +ansible/modules/cloud/amazon/aws_application_scaling_policy.pyc,, +ansible/modules/cloud/amazon/aws_az_facts.py,sha256=huqStiCtILUbtjhd4sbQT87yo-TCbU_K9b4ELTgOSHI,3999 +ansible/modules/cloud/amazon/aws_az_facts.pyc,, +ansible/modules/cloud/amazon/aws_batch_compute_environment.py,sha256=--Pjg8HXO3GFrENJY-cOmmHVzgGe8ZMnE6MPn1KNc-A,16653 +ansible/modules/cloud/amazon/aws_batch_compute_environment.pyc,, +ansible/modules/cloud/amazon/aws_batch_job_definition.py,sha256=b9OSDUba63SNEeisIomUQm-32lD6pBW1dC2m_QWJYVE,16337 +ansible/modules/cloud/amazon/aws_batch_job_definition.pyc,, +ansible/modules/cloud/amazon/aws_batch_job_queue.py,sha256=M9NhWmWiadz8Tz0l-BuKYGV5LoUe7xsj3dEeovGHkxc,10201 +ansible/modules/cloud/amazon/aws_batch_job_queue.pyc,, +ansible/modules/cloud/amazon/aws_caller_facts.py,sha256=AQ9bzAYhyusm1nyZfamlJPnHi-I_yNq6RnrPtn_zL5A,3551 +ansible/modules/cloud/amazon/aws_caller_facts.pyc,, +ansible/modules/cloud/amazon/aws_config_aggregation_authorization.py,sha256=uTKVZBQLEsGd8litJV-NxDi7-sZ-0xdap_AsMwBQlj0,5272 +ansible/modules/cloud/amazon/aws_config_aggregation_authorization.pyc,, +ansible/modules/cloud/amazon/aws_config_aggregator.py,sha256=jrZuGtzqv0HCHAzlYhKB61TjPGDal0q0lXx_Q3O-lLU,7632 +ansible/modules/cloud/amazon/aws_config_aggregator.pyc,, +ansible/modules/cloud/amazon/aws_config_delivery_channel.py,sha256=aHLr86g39wA8-_qSYzm0HyeyroIe1HINcOUkD3ENWlU,7752 +ansible/modules/cloud/amazon/aws_config_delivery_channel.pyc,, +ansible/modules/cloud/amazon/aws_config_recorder.py,sha256=-83Pb__IRYJPeb4t2ZVRM-gAYqFW3aMeOgwuS6R_b2U,7725 +ansible/modules/cloud/amazon/aws_config_recorder.pyc,, +ansible/modules/cloud/amazon/aws_config_rule.py,sha256=adWYz0wtpytwAONY0g6sQKL_yjHHJ1uaLQVX5-abTnA,9761 +ansible/modules/cloud/amazon/aws_config_rule.pyc,, +ansible/modules/cloud/amazon/aws_direct_connect_connection.py,sha256=WiEO-2EwTVmzL-Ms_0tTlsjSHW_PUnGXXS0rgctmBdY,12050 +ansible/modules/cloud/amazon/aws_direct_connect_connection.pyc,, +ansible/modules/cloud/amazon/aws_direct_connect_gateway.py,sha256=7L5UEsKOXZA5uJ1t3S-ZeuvenkzwJ39ghNSuOjbV2Ds,13580 +ansible/modules/cloud/amazon/aws_direct_connect_gateway.pyc,, +ansible/modules/cloud/amazon/aws_direct_connect_link_aggregation_group.py,sha256=oJ90DffWp15Ynx3A1M2P1X_YtMgERWyi5SCUlAT_5-4,18121 +ansible/modules/cloud/amazon/aws_direct_connect_link_aggregation_group.pyc,, +ansible/modules/cloud/amazon/aws_direct_connect_virtual_interface.py,sha256=k_IuWfa0uIe_7mGMLzhoTJ_grtuOf0nTWlUIkkn5TKo,17094 +ansible/modules/cloud/amazon/aws_direct_connect_virtual_interface.pyc,, +ansible/modules/cloud/amazon/aws_eks_cluster.py,sha256=_vrggmoVii2NeqetpIBuPWSaUueMFVJOMx7btg0WADQ,9275 +ansible/modules/cloud/amazon/aws_eks_cluster.pyc,, +ansible/modules/cloud/amazon/aws_elasticbeanstalk_app.py,sha256=q0Dzq2Dx55B8Y7pM0dKJ5XmGZmUPuy3kwub-VGRjpVY,7390 +ansible/modules/cloud/amazon/aws_elasticbeanstalk_app.pyc,, +ansible/modules/cloud/amazon/aws_glue_connection.py,sha256=oM--B40nXUAcH1qggnwDkaZx9BNCJylsFunJG7HBbHQ,12285 +ansible/modules/cloud/amazon/aws_glue_connection.pyc,, +ansible/modules/cloud/amazon/aws_glue_job.py,sha256=KfSwMjBHDzqPp-X7FLCH-sqawkBk4CNGibX35AKK6q8,12871 +ansible/modules/cloud/amazon/aws_glue_job.pyc,, +ansible/modules/cloud/amazon/aws_inspector_target.py,sha256=KOU_pQo2vzMbTODXjZJlVonkCESt8c4K4lT_F4QXETA,7849 +ansible/modules/cloud/amazon/aws_inspector_target.pyc,, +ansible/modules/cloud/amazon/aws_kms.py,sha256=LfevaabGBtjkYtR8wp-WNQkGxiXqdJmCHv3sbAXruXM,11606 +ansible/modules/cloud/amazon/aws_kms.pyc,, +ansible/modules/cloud/amazon/aws_kms_facts.py,sha256=fNLEbVvvEVY0Rdh6opV-QrhSsFzSmIkAUaScOx4osD8,14675 +ansible/modules/cloud/amazon/aws_kms_facts.pyc,, +ansible/modules/cloud/amazon/aws_region_facts.py,sha256=6PK1-i7KZmepw9PC_i1nGy2Aw3pRQybRZ5uGTgO0cLA,3496 +ansible/modules/cloud/amazon/aws_region_facts.pyc,, +ansible/modules/cloud/amazon/aws_s3.py,sha256=yjxLTpuBFfVAdmlAUycSLeZR3cPVYGJZXOdgG1ToGa0,42229 +ansible/modules/cloud/amazon/aws_s3.pyc,, +ansible/modules/cloud/amazon/aws_s3_bucket_facts.py,sha256=tw5AHBJmNQM6DA47V8DFk8MeXuep0RVw91hnN-QLqFs,2716 +ansible/modules/cloud/amazon/aws_s3_bucket_facts.pyc,, +ansible/modules/cloud/amazon/aws_s3_cors.py,sha256=CNcBddpdAoASFWlbdW58ss_fogeaKsH32AGK1nwAJBw,5132 +ansible/modules/cloud/amazon/aws_s3_cors.pyc,, +ansible/modules/cloud/amazon/aws_ses_identity.py,sha256=PxQQ-5-3ycEbvPyc8zdJwN8saGJsv7aVmH9khgjIDD0,23210 +ansible/modules/cloud/amazon/aws_ses_identity.pyc,, +ansible/modules/cloud/amazon/aws_ses_identity_policy.py,sha256=1fNK8L7lq2goPtUlTDTbncE8dOkoYcMWsZs4Yt6eD_E,7303 +ansible/modules/cloud/amazon/aws_ses_identity_policy.pyc,, +ansible/modules/cloud/amazon/aws_sgw_facts.py,sha256=12Fk-Jk2ZVvWNaqayy8tnWptvIcxLYOu5XBpiwKx2f0,11531 +ansible/modules/cloud/amazon/aws_sgw_facts.pyc,, +ansible/modules/cloud/amazon/aws_ssm_parameter_store.py,sha256=EpMK3LLszF2s5AFfFFasjKTiXPoro1SuGvff6c3a3XU,7669 +ansible/modules/cloud/amazon/aws_ssm_parameter_store.pyc,, +ansible/modules/cloud/amazon/aws_waf_condition.py,sha256=CX0bst0q2ovDOa2zvP-PK7L9iUOCn5HKrrV7jQJGZvk,27277 +ansible/modules/cloud/amazon/aws_waf_condition.pyc,, +ansible/modules/cloud/amazon/aws_waf_facts.py,sha256=gYBrwNd72j71VcrL9gjqaj7H3cIOKDwsWXmT3HbvJ1M,4164 +ansible/modules/cloud/amazon/aws_waf_facts.pyc,, +ansible/modules/cloud/amazon/aws_waf_rule.py,sha256=d5bj4paes_zAOnm9go97AEqoLUlq9rVn1AiKrCrtKpw,12179 +ansible/modules/cloud/amazon/aws_waf_rule.pyc,, +ansible/modules/cloud/amazon/aws_waf_web_acl.py,sha256=vDOK0u-WvYKcxi4JxPU95iwDfk-DC2uF2PxTuNS4_KU,11280 +ansible/modules/cloud/amazon/aws_waf_web_acl.pyc,, +ansible/modules/cloud/amazon/cloudformation.py,sha256=JOWWyq-7qqlhTX4K94IgUCVVxAtGgWnz4pOODHgJcYY,33358 +ansible/modules/cloud/amazon/cloudformation.pyc,, +ansible/modules/cloud/amazon/cloudformation_facts.py,sha256=ab-z-uvGM59ycYWsmMy1FeHmtCOgFSUKK4eq-YGnjx0,12240 +ansible/modules/cloud/amazon/cloudformation_facts.pyc,, +ansible/modules/cloud/amazon/cloudformation_stack_set.py,sha256=pNIOvCumf3re5o-P3wnCsVjMhs2CC0n9kIcvql0pS2Y,30057 +ansible/modules/cloud/amazon/cloudformation_stack_set.pyc,, +ansible/modules/cloud/amazon/cloudfront_distribution.py,sha256=-7ycCH2dqkpPkV0X2uGCW5Na43dMQBIiqMeLztPE6vo,86724 +ansible/modules/cloud/amazon/cloudfront_distribution.pyc,, +ansible/modules/cloud/amazon/cloudfront_facts.py,sha256=hQ_bIWUHcW6Rv4YLLnIlzEVaEDWOVncDZazwEK7seII,32140 +ansible/modules/cloud/amazon/cloudfront_facts.pyc,, +ansible/modules/cloud/amazon/cloudfront_invalidation.py,sha256=kDj2RA3jdCng4RGci0Z9ZpQrBb5JCiheqYgHWjFFMN4,10365 +ansible/modules/cloud/amazon/cloudfront_invalidation.pyc,, +ansible/modules/cloud/amazon/cloudfront_origin_access_identity.py,sha256=KH02Q0b3_Vfnx7_9JjLlt_JVdtdjOV4uDRV3tyo-fx8,10278 +ansible/modules/cloud/amazon/cloudfront_origin_access_identity.pyc,, +ansible/modules/cloud/amazon/cloudtrail.py,sha256=DtKI9HhjrzwBsZIikVrJ4QhOYbJnzZZp_evg91CDq9A,23723 +ansible/modules/cloud/amazon/cloudtrail.pyc,, +ansible/modules/cloud/amazon/cloudwatchevent_rule.py,sha256=W3PxFST-aydWrToit2NP2hh1sYp6fV9Up7WJZ8QLwAQ,16757 +ansible/modules/cloud/amazon/cloudwatchevent_rule.pyc,, +ansible/modules/cloud/amazon/cloudwatchlogs_log_group.py,sha256=TFWsuk-iIvysHd2iQC4Tx_evz7qBp8IPAB2pTibuDZY,11351 +ansible/modules/cloud/amazon/cloudwatchlogs_log_group.pyc,, +ansible/modules/cloud/amazon/cloudwatchlogs_log_group_facts.py,sha256=Q-ZdctdE5r-4xpbf6iYD_uiqZhCosBK3Zqm5lVu78FQ,4343 +ansible/modules/cloud/amazon/cloudwatchlogs_log_group_facts.pyc,, +ansible/modules/cloud/amazon/data_pipeline.py,sha256=muVv8KILX9_vzfS3WbQWVcNs38c5LDKx-fksh7sqNZk,20749 +ansible/modules/cloud/amazon/data_pipeline.pyc,, +ansible/modules/cloud/amazon/dynamodb_table.py,sha256=nPYDuiwj5_hefxiVBO1DH12s_uCel1ljbJ7s4V-NnB4,16898 +ansible/modules/cloud/amazon/dynamodb_table.pyc,, +ansible/modules/cloud/amazon/dynamodb_ttl.py,sha256=c3vDARtu-KJWVLDLy03DYsV7-K3n9SXOj2YmCGq_Gs4,5585 +ansible/modules/cloud/amazon/dynamodb_ttl.pyc,, +ansible/modules/cloud/amazon/ec2.py,sha256=FESWxHpffYfNhR-CMu-fn5PoLXpDnXjYoLbG8ZGku78,65057 +ansible/modules/cloud/amazon/ec2.pyc,, +ansible/modules/cloud/amazon/ec2_ami.py,sha256=H9bjo19AUDLv_GOhKvlZQ41MDek7ojRy93JZg7GTKgs,27339 +ansible/modules/cloud/amazon/ec2_ami.pyc,, +ansible/modules/cloud/amazon/ec2_ami_copy.py,sha256=vGYaXWMxSWKewCp0jFdjVEu5ZgDuNuSAX0sAPP-EDjk,7367 +ansible/modules/cloud/amazon/ec2_ami_copy.pyc,, +ansible/modules/cloud/amazon/ec2_ami_facts.py,sha256=fVmvGVQqP6FV22gTF-pfSSyGApjhtlWTq00GSLYWimA,8737 +ansible/modules/cloud/amazon/ec2_ami_facts.pyc,, +ansible/modules/cloud/amazon/ec2_asg.py,sha256=0MU01BzkaVjUxhgByMfts7aUetO5sZhLrVhSxBtveNY,64972 +ansible/modules/cloud/amazon/ec2_asg.pyc,, +ansible/modules/cloud/amazon/ec2_asg_facts.py,sha256=DO41jH48JUICpyov1o3QkIBq3fUu_m02N4humPem1Jc,14012 +ansible/modules/cloud/amazon/ec2_asg_facts.pyc,, +ansible/modules/cloud/amazon/ec2_asg_lifecycle_hook.py,sha256=0JeuZrkOLsHKG1irhLuknRYLbOapHGKhDwIiN92Tr0M,8604 +ansible/modules/cloud/amazon/ec2_asg_lifecycle_hook.pyc,, +ansible/modules/cloud/amazon/ec2_customer_gateway.py,sha256=KarMzg583vTay7LZVZqWXOXmKBFwv2GARhweKCZy7zQ,9318 +ansible/modules/cloud/amazon/ec2_customer_gateway.pyc,, +ansible/modules/cloud/amazon/ec2_customer_gateway_facts.py,sha256=wSXx-XMv3MZKBKQboeJYSU6xj2-CPEtb6SNG7hvogLw,4706 +ansible/modules/cloud/amazon/ec2_customer_gateway_facts.pyc,, +ansible/modules/cloud/amazon/ec2_eip.py,sha256=dFQux9lDQEGwPYmWFfdNXnNjpnX7rP1lbg57KJgV7JQ,16618 +ansible/modules/cloud/amazon/ec2_eip.pyc,, +ansible/modules/cloud/amazon/ec2_eip_facts.py,sha256=QpL3bnXISNed45v83MYlcjQFyo2tzzE5u81BAZhN6e4,3317 +ansible/modules/cloud/amazon/ec2_eip_facts.pyc,, +ansible/modules/cloud/amazon/ec2_elb.py,sha256=GP98Fzg-30zktoylYiQlTOWdsG4XwubSJH0d6t26OWg,13853 +ansible/modules/cloud/amazon/ec2_elb.pyc,, +ansible/modules/cloud/amazon/ec2_elb_facts.py,sha256=s0f8x4ow_7bLedB4wJWF-xuSuuzEhmI47bFveprs5mQ,8678 +ansible/modules/cloud/amazon/ec2_elb_facts.pyc,, +ansible/modules/cloud/amazon/ec2_elb_lb.py,sha256=RteMUcZAHckRQGHDT7pT0m2reGyrGwAXhIvnqR11R94,53494 +ansible/modules/cloud/amazon/ec2_elb_lb.pyc,, +ansible/modules/cloud/amazon/ec2_eni.py,sha256=GtfP-EPuiQECpBU0cULihNuw4WhWjQGpjUH4DppuajA,24092 +ansible/modules/cloud/amazon/ec2_eni.pyc,, +ansible/modules/cloud/amazon/ec2_eni_facts.py,sha256=NxNfh9wECpXpvgP8vxFGTHnO8xM5M7IEVruyn4Nez2U,9487 +ansible/modules/cloud/amazon/ec2_eni_facts.pyc,, +ansible/modules/cloud/amazon/ec2_group.py,sha256=012GT8EqfImPy2h0aF7OVBFKpgaHeoY-K3uwq4zHHZ8,49946 +ansible/modules/cloud/amazon/ec2_group.pyc,, +ansible/modules/cloud/amazon/ec2_group_facts.py,sha256=ZdyWHnkn5xdWkOMd6PtYvM1pdy8pE2LX0k83TOlgmUE,5032 +ansible/modules/cloud/amazon/ec2_group_facts.pyc,, +ansible/modules/cloud/amazon/ec2_instance.py,sha256=QiZbK10GClZG3pmYzyGfrGSb6W4LZdnIbjKtidQXTiU,68590 +ansible/modules/cloud/amazon/ec2_instance.pyc,, +ansible/modules/cloud/amazon/ec2_instance_facts.py,sha256=54GZ6tPMIOSSkG1iXLNDbXs9LRWsgWWfpPV7SeqElfA,22317 +ansible/modules/cloud/amazon/ec2_instance_facts.pyc,, +ansible/modules/cloud/amazon/ec2_key.py,sha256=6Mj0guuwExIkvZTHhmoNEKjJcwKbqciZuMo9LON4f2A,8274 +ansible/modules/cloud/amazon/ec2_key.pyc,, +ansible/modules/cloud/amazon/ec2_lc.py,sha256=hg4JrZqTVyfeEq2eekfoVvDliZmW5wur8bH3KEgnTM0,24341 +ansible/modules/cloud/amazon/ec2_lc.pyc,, +ansible/modules/cloud/amazon/ec2_lc_facts.py,sha256=EnwkpWFWhqiJJvQfqRr5wEaujFnyVpB1nTNpwTk6o14,7120 +ansible/modules/cloud/amazon/ec2_lc_facts.pyc,, +ansible/modules/cloud/amazon/ec2_lc_find.py,sha256=lRWD5P0YgfTuh7VwgoNekgXqKXzBHZRDcNE4NvuI7gI,6810 +ansible/modules/cloud/amazon/ec2_lc_find.pyc,, +ansible/modules/cloud/amazon/ec2_metadata_facts.py,sha256=OLqKLYNf8hXNG6s4dvVQiksKZUjl7Ey5OZsvhlXy3qw,26371 +ansible/modules/cloud/amazon/ec2_metadata_facts.pyc,, +ansible/modules/cloud/amazon/ec2_metric_alarm.py,sha256=spXF2lV-51vVOgTmQ4m-zLf2WAT0aP0uK4zHk0beq34,11516 +ansible/modules/cloud/amazon/ec2_metric_alarm.pyc,, +ansible/modules/cloud/amazon/ec2_placement_group.py,sha256=_sCw_lGWghEySVHbteuoa_TZYiXRUhlkps_q9mp3-4o,6407 +ansible/modules/cloud/amazon/ec2_placement_group.pyc,, +ansible/modules/cloud/amazon/ec2_placement_group_facts.py,sha256=9p6YnYbDktbKCTDJFS5oWXVU53o5n1JMVQNXzCOW3dI,3633 +ansible/modules/cloud/amazon/ec2_placement_group_facts.pyc,, +ansible/modules/cloud/amazon/ec2_scaling_policy.py,sha256=-2Vu2BupjEV-dHp51dTdexepVS6NO8V1a6uMUzZztIU,6822 +ansible/modules/cloud/amazon/ec2_scaling_policy.pyc,, +ansible/modules/cloud/amazon/ec2_snapshot.py,sha256=c5QROxadL_aLHSUiJFj43ZUxbCSsy9RjPhWdXmOumxQ,9675 +ansible/modules/cloud/amazon/ec2_snapshot.pyc,, +ansible/modules/cloud/amazon/ec2_snapshot_copy.py,sha256=xrpEPESY21CCXObQiJF7TapSvIYu2eRFFRCXhAeZBbo,5836 +ansible/modules/cloud/amazon/ec2_snapshot_copy.pyc,, +ansible/modules/cloud/amazon/ec2_snapshot_facts.py,sha256=gWMlkgfRFiNdxP8W49ovaykiqIymtO8qYlZa8E_E2_0,8184 +ansible/modules/cloud/amazon/ec2_snapshot_facts.pyc,, +ansible/modules/cloud/amazon/ec2_tag.py,sha256=KXGQ6xXQuc1NDb5SUrgYQxApuKeLtFuZZ-wRmsHW5IA,5508 +ansible/modules/cloud/amazon/ec2_tag.pyc,, +ansible/modules/cloud/amazon/ec2_vol.py,sha256=YLUpU4HkFn_OdPpWWu5bR-d3WgD5ibmPf3ez36JfV_g,20090 +ansible/modules/cloud/amazon/ec2_vol.pyc,, +ansible/modules/cloud/amazon/ec2_vol_facts.py,sha256=Lkhezbm8mjiunB38qqsH_exU_2O4hcaAt09WT5SroKU,4844 +ansible/modules/cloud/amazon/ec2_vol_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_dhcp_option.py,sha256=W5lqDCdoAWM3bX_IgUW9xUPC4YvqwK3qF5Dh_QtXv-o,15811 +ansible/modules/cloud/amazon/ec2_vpc_dhcp_option.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_dhcp_option_facts.py,sha256=y5hzAqaY4bYE5vHyOdcD8-gXpXtd9lSTczq3w4Z-KCs,4842 +ansible/modules/cloud/amazon/ec2_vpc_dhcp_option_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_egress_igw.py,sha256=IQPqEOTxisUK4V7NU8DG3JKC__FAQCOfj3WyEEruayE,6545 +ansible/modules/cloud/amazon/ec2_vpc_egress_igw.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_endpoint.py,sha256=gb2t7NDoGyg0g277bOAJVxTjV4eyNGonogRUaeyziE0,13892 +ansible/modules/cloud/amazon/ec2_vpc_endpoint.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_endpoint_facts.py,sha256=SLhe4Pf3vHi-IDI5V4xan4HynHIpP1rQuZgaO5e3tGU,6029 +ansible/modules/cloud/amazon/ec2_vpc_endpoint_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_igw.py,sha256=09HnR-lRqXxiDrJoxkm0UcsWEuCAa4KlIO74Z9lPE7U,7699 +ansible/modules/cloud/amazon/ec2_vpc_igw.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_igw_facts.py,sha256=dUG71i_vTknSxQijgTkzQv8VBJPsNn44Lnl6JcJfFK8,4661 +ansible/modules/cloud/amazon/ec2_vpc_igw_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_nacl.py,sha256=OMh_aDO1s5yeMI0SphiDRIQsFngj8DmSRBq9avoy404,20999 +ansible/modules/cloud/amazon/ec2_vpc_nacl.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_nacl_facts.py,sha256=0ksELXDNlUmn5j344rfBbdFP3od2geVc8ywoibuXC8g,7593 +ansible/modules/cloud/amazon/ec2_vpc_nacl_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_nat_gateway.py,sha256=O0c9slu7KrWftU-3gIpmG_J3QLwPcw9o9z_qJeMRcts,32413 +ansible/modules/cloud/amazon/ec2_vpc_nat_gateway.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_nat_gateway_facts.py,sha256=VSy8aQaQPdov-j-jmf8S2OCA4HmCN04dvfI15zJghPA,4572 +ansible/modules/cloud/amazon/ec2_vpc_nat_gateway_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_net.py,sha256=5A8CO4-Md7lTRGB2q5Zj7ZSwMKPmRvn-wbvFgdI88Aw,19080 +ansible/modules/cloud/amazon/ec2_vpc_net.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_net_facts.py,sha256=-3am2ubfKEfIb3fzx-scJTPxT9YmaLwGUdmCy88QZ8I,11434 +ansible/modules/cloud/amazon/ec2_vpc_net_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_peer.py,sha256=3WvKDsHXbM4TOoubuhXENcOE0KhbkbQ4EVTfRGePjHI,13634 +ansible/modules/cloud/amazon/ec2_vpc_peer.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_peering_facts.py,sha256=CaG1SDVoDDEJ9dmbp1xFz3kim03uPEgGJh0IhAs-3U0,4251 +ansible/modules/cloud/amazon/ec2_vpc_peering_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_route_table.py,sha256=xZLiq2OulY-xZ4zVyz8Lmx6gqsezR7wQ-n5Myp0ddJY,30385 +ansible/modules/cloud/amazon/ec2_vpc_route_table.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_route_table_facts.py,sha256=gyUP8FOSuc4JLkIw6bajygUDdoAqEfD3wT6jlvdPexk,3703 +ansible/modules/cloud/amazon/ec2_vpc_route_table_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_subnet.py,sha256=zFqLS28aSXjHKKgsh_8Mic4CepHoC_1DoccdNtGVqZY,23409 +ansible/modules/cloud/amazon/ec2_vpc_subnet.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_subnet_facts.py,sha256=LLxYt9INflMAwGPPLMPVJRFYHIjkPH0XQ7s9P1L9a1g,8217 +ansible/modules/cloud/amazon/ec2_vpc_subnet_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_vgw.py,sha256=aoaKLxyXgvKiv5TPn6nVLCujyB2rbCxcw9569mdCW3c,19909 +ansible/modules/cloud/amazon/ec2_vpc_vgw.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_vgw_facts.py,sha256=-HbAUYXScesl8Nb25y50ovfeSzpPTRrr7UrZzltL76g,4882 +ansible/modules/cloud/amazon/ec2_vpc_vgw_facts.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_vpn.py,sha256=wdjKvIvUlYFZrGVWUf198GbcJNmALO-W6eiDfnbN3R4,29311 +ansible/modules/cloud/amazon/ec2_vpc_vpn.pyc,, +ansible/modules/cloud/amazon/ec2_vpc_vpn_facts.py,sha256=wN6xmECGGpvw6Vh6uvQuIHiukVng6ApVEsH8LzlM45E,6885 +ansible/modules/cloud/amazon/ec2_vpc_vpn_facts.pyc,, +ansible/modules/cloud/amazon/ec2_win_password.py,sha256=c5TSNWXrOyIH3wOdRiBAHWCfRSjuzZWKFS7XtlBy3GY,5684 +ansible/modules/cloud/amazon/ec2_win_password.pyc,, +ansible/modules/cloud/amazon/ecs_attribute.py,sha256=e1pZA7j9_7P-5_ERCPtLxFzQVo5i2CHPv3Ww9tHHaWE,10418 +ansible/modules/cloud/amazon/ecs_attribute.pyc,, +ansible/modules/cloud/amazon/ecs_cluster.py,sha256=_YvX7W7t6RtFtWY7vTnJYGjvQTkhxf1l_ExLjItACIE,7340 +ansible/modules/cloud/amazon/ecs_cluster.pyc,, +ansible/modules/cloud/amazon/ecs_ecr.py,sha256=mquMxq6i5fJTsBDvXDUePviTZZijtlX7e2U55bnxs0M,11756 +ansible/modules/cloud/amazon/ecs_ecr.pyc,, +ansible/modules/cloud/amazon/ecs_service.py,sha256=NcvRvrtC08jwOX74jBFdF03cqDK_kB4Wt1JqkJibzkM,25229 +ansible/modules/cloud/amazon/ecs_service.pyc,, +ansible/modules/cloud/amazon/ecs_service_facts.py,sha256=pkUlGyRHc1HWrc9MLPuikQ6L1ucJECCo2Spr7ZZmIyo,8729 +ansible/modules/cloud/amazon/ecs_service_facts.pyc,, +ansible/modules/cloud/amazon/ecs_task.py,sha256=LbFLgFU_kqOGDiNLv3Hmbjz1HdIqyhM7OQw7nKSyCg4,13623 +ansible/modules/cloud/amazon/ecs_task.pyc,, +ansible/modules/cloud/amazon/ecs_taskdefinition.py,sha256=pcWGKMw2Fx8BsdYGuV230lVpAy5yen863wjA1oKFNYs,19844 +ansible/modules/cloud/amazon/ecs_taskdefinition.pyc,, +ansible/modules/cloud/amazon/ecs_taskdefinition_facts.py,sha256=6mnvfTNVuFbFg2OKVe5YPvbiwVGgdGOFlsLlWBr6mKM,12204 +ansible/modules/cloud/amazon/ecs_taskdefinition_facts.pyc,, +ansible/modules/cloud/amazon/efs.py,sha256=_y79E3YBKOyoOQKETr18__7Qrt-7lilCgNLyhLBdYi8,24520 +ansible/modules/cloud/amazon/efs.pyc,, +ansible/modules/cloud/amazon/efs_facts.py,sha256=k4uJIrCstTgpO2BJEJVXxPtisxzP1u9hPIQRNdFU9Hs,12802 +ansible/modules/cloud/amazon/efs_facts.pyc,, +ansible/modules/cloud/amazon/elasticache.py,sha256=invXj2qJUMsrTG4HI5kwyrT5z90_YSBaVhy8SeO-mAg,20437 +ansible/modules/cloud/amazon/elasticache.pyc,, +ansible/modules/cloud/amazon/elasticache_facts.py,sha256=5evXPw4NlRumiUCIDCSp26jeXEMk28hwg5a6HBBGzWw,9931 +ansible/modules/cloud/amazon/elasticache_facts.pyc,, +ansible/modules/cloud/amazon/elasticache_parameter_group.py,sha256=q_csf34jaWD4ZeFZoXMNoR0I03lozMu6z8ZvvBUI7xA,14534 +ansible/modules/cloud/amazon/elasticache_parameter_group.pyc,, +ansible/modules/cloud/amazon/elasticache_snapshot.py,sha256=ht2Yy44HtjnO4nFcA9qvNjvhVXD8-mrjCNjH4VXzqqw,7532 +ansible/modules/cloud/amazon/elasticache_snapshot.pyc,, +ansible/modules/cloud/amazon/elasticache_subnet_group.py,sha256=vYGoO2WBhLgQlMtMTc_H7DJJ6pXHvwztaEQSBzBULGo,4652 +ansible/modules/cloud/amazon/elasticache_subnet_group.pyc,, +ansible/modules/cloud/amazon/elb_application_lb.py,sha256=WhdZ-mU4iuy1DdNI-5CAHijbahSZvgzD-9MAUClHNMk,21516 +ansible/modules/cloud/amazon/elb_application_lb.pyc,, +ansible/modules/cloud/amazon/elb_application_lb_facts.py,sha256=dJFFUeYhPCwF_QRWCiqVwEkczCxsYfMkgQMCkJksdiE,10396 +ansible/modules/cloud/amazon/elb_application_lb_facts.pyc,, +ansible/modules/cloud/amazon/elb_classic_lb.py,sha256=6hk8SswgpcYiFyB-m01m7OnaABXZbg45BUPWeDSHZz8,53493 +ansible/modules/cloud/amazon/elb_classic_lb.pyc,, +ansible/modules/cloud/amazon/elb_classic_lb_facts.py,sha256=TY1sjzrB5b4XY2mZZsWjLhUnknKKzF0JSiZRgLf3ssA,7066 +ansible/modules/cloud/amazon/elb_classic_lb_facts.pyc,, +ansible/modules/cloud/amazon/elb_instance.py,sha256=6SRHyy1TcEuk7zIuKJjUxHYW0JMBbPAjNRN0dmH0-d8,13706 +ansible/modules/cloud/amazon/elb_instance.pyc,, +ansible/modules/cloud/amazon/elb_network_lb.py,sha256=kSf7mLUF85O1yo2N_hrGgN43EsbBHq6728MSgaNbcIc,15417 +ansible/modules/cloud/amazon/elb_network_lb.pyc,, +ansible/modules/cloud/amazon/elb_target.py,sha256=t6iwoCN-jrSRU9yEiSF7-wKMlJyORl8MVeRYcsb1VJc,12126 +ansible/modules/cloud/amazon/elb_target.pyc,, +ansible/modules/cloud/amazon/elb_target_facts.py,sha256=9VyQ7ZVpfLrTm95ATNN4vj-WbfnZNEYM607XwMRAAQY,16130 +ansible/modules/cloud/amazon/elb_target_facts.pyc,, +ansible/modules/cloud/amazon/elb_target_group.py,sha256=36BbjEQNgdLLmL9jzrVGTA6KckNN0ywyYQVP1EmOhC8,31741 +ansible/modules/cloud/amazon/elb_target_group.pyc,, +ansible/modules/cloud/amazon/elb_target_group_facts.py,sha256=i3Z-5wRiKTCJ0q-8zVJjZAPzdKfWpR_X8hPf6Pbcwpo,9790 +ansible/modules/cloud/amazon/elb_target_group_facts.pyc,, +ansible/modules/cloud/amazon/execute_lambda.py,sha256=9pNLZxWvjR--rLjWXpdVi5V6MX7ilC40uafuxRdhf0U,10356 +ansible/modules/cloud/amazon/execute_lambda.pyc,, +ansible/modules/cloud/amazon/iam.py,sha256=OHn0nrgUDr05A-VQu3yZXp3PzTv6aU2o2WZdzci9ZM0,35373 +ansible/modules/cloud/amazon/iam.pyc,, +ansible/modules/cloud/amazon/iam_cert.py,sha256=5lzm3Y8qA121ctOiCpz9y8RVhvamcNI_SHJ3F2KeLag,11817 +ansible/modules/cloud/amazon/iam_cert.pyc,, +ansible/modules/cloud/amazon/iam_group.py,sha256=44k18vhl0R91MbNQyvoKx94WM31A1iy4iL7YJPi_ptg,17098 +ansible/modules/cloud/amazon/iam_group.pyc,, +ansible/modules/cloud/amazon/iam_managed_policy.py,sha256=Fp16F4I9Gq0eW4lRh4FPrGowDUjv3iRGjZGcpa0ukLo,15814 +ansible/modules/cloud/amazon/iam_managed_policy.pyc,, +ansible/modules/cloud/amazon/iam_mfa_device_facts.py,sha256=Qmg2QdXVboTXAbDWH-Qjk5xEIIKcePn7JAci8lVY6ec,3357 +ansible/modules/cloud/amazon/iam_mfa_device_facts.pyc,, +ansible/modules/cloud/amazon/iam_policy.py,sha256=DHyqhRjMCsL2EI9JMkyh5xSkGSTy4zohbl_EFt3QU7w,13982 +ansible/modules/cloud/amazon/iam_policy.pyc,, +ansible/modules/cloud/amazon/iam_role.py,sha256=I-_ucvkaN4g9l8vWpzjt6tKoOZcxFZkZ_tyBc5lqLt0,24080 +ansible/modules/cloud/amazon/iam_role.pyc,, +ansible/modules/cloud/amazon/iam_role_facts.py,sha256=1JGh-pvMbt34Cr5XJaw8QaOACIUgyMSECHDr5vTEvv4,8111 +ansible/modules/cloud/amazon/iam_role_facts.pyc,, +ansible/modules/cloud/amazon/iam_server_certificate_facts.py,sha256=XdL2WO3y48O4pG_HLQA6iUKp7R8el_VxvSk1wNfZrEc,5371 +ansible/modules/cloud/amazon/iam_server_certificate_facts.pyc,, +ansible/modules/cloud/amazon/iam_user.py,sha256=VdNHtvv4zBxGAkKbi_SSyAe57YenVJ4MCtlMaZGUIlw,12346 +ansible/modules/cloud/amazon/iam_user.pyc,, +ansible/modules/cloud/amazon/kinesis_stream.py,sha256=Jx2YMIJTjgaaLCHKEJhnJRPn9d3DRljhanfTv0wLFh8,46520 +ansible/modules/cloud/amazon/kinesis_stream.pyc,, +ansible/modules/cloud/amazon/lambda.py,sha256=TrnkcKURGUek2T9xsIFsGjab92yvvEKbjf9bLOxw8TY,22584 +ansible/modules/cloud/amazon/lambda.pyc,, +ansible/modules/cloud/amazon/lambda_alias.py,sha256=oIMD17bLSzIUf6H7VtDrsqBMKl5DvEnaJXH77zKR-Gs,11991 +ansible/modules/cloud/amazon/lambda_alias.pyc,, +ansible/modules/cloud/amazon/lambda_event.py,sha256=WF_DkEcaFZ4S1iNhaLLJWwtc2PHAdsVeo7nh2HtnshA,15261 +ansible/modules/cloud/amazon/lambda_event.pyc,, +ansible/modules/cloud/amazon/lambda_facts.py,sha256=30nP6z8R5JJzni6rDPsdJdbHSAOFCD9kw9rkIKuspmE,13097 +ansible/modules/cloud/amazon/lambda_facts.pyc,, +ansible/modules/cloud/amazon/lambda_policy.py,sha256=GrxptHHIZTuoD4tzHkR3PyddvHhaJuV1spnhUMzwIEM,13979 +ansible/modules/cloud/amazon/lambda_policy.pyc,, +ansible/modules/cloud/amazon/lightsail.py,sha256=mboIPrtMOwPD8z8us0h7p-j4VO4qSPpMiXdcaSsUkC0,15620 +ansible/modules/cloud/amazon/lightsail.pyc,, +ansible/modules/cloud/amazon/rds.py,sha256=S71bpNWcRh0v5LwkZ9qsaog8QZDpea_j65M5HAJHtGQ,54381 +ansible/modules/cloud/amazon/rds.pyc,, +ansible/modules/cloud/amazon/rds_instance.py,sha256=O1gg5qJF4B4jM-aP1VANmy8qQoOIy-9IJmk0LfwnHcY,50632 +ansible/modules/cloud/amazon/rds_instance.pyc,, +ansible/modules/cloud/amazon/rds_instance_facts.py,sha256=km7qTr4nRc8bxTHMR_SiW7OpD3xwDdw2cLjKe0TzvPA,12113 +ansible/modules/cloud/amazon/rds_instance_facts.pyc,, +ansible/modules/cloud/amazon/rds_param_group.py,sha256=pOw8TbOqU9kw5zBh4ub7wdSiDJB-jExVPKBtZPhjbkc,15659 +ansible/modules/cloud/amazon/rds_param_group.pyc,, +ansible/modules/cloud/amazon/rds_snapshot_facts.py,sha256=4b4382Fa1aBDJsJ0S4k7y4ESCqzZy37uaQfyLnIe0EQ,12499 +ansible/modules/cloud/amazon/rds_snapshot_facts.pyc,, +ansible/modules/cloud/amazon/rds_subnet_group.py,sha256=7SSUMJ_tHIbfNJDH4m8pEgeb9Rb5EnSSZ4NWDVrZW0Q,6292 +ansible/modules/cloud/amazon/rds_subnet_group.pyc,, +ansible/modules/cloud/amazon/redshift.py,sha256=sryZHqY8r_M6ohwihim-QxBmwvIu1HokA2EunSrz9wg,17408 +ansible/modules/cloud/amazon/redshift.pyc,, +ansible/modules/cloud/amazon/redshift_facts.py,sha256=XKvUdT_F3Pz6E0JKIourZAk5tKtXr38_-ZSf-kcEQms,10951 +ansible/modules/cloud/amazon/redshift_facts.pyc,, +ansible/modules/cloud/amazon/redshift_subnet_group.py,sha256=K4iKFh2VwNH0xEv31FzIHzUQTuqSwmLR5eWjN1YP7mE,5877 +ansible/modules/cloud/amazon/redshift_subnet_group.pyc,, +ansible/modules/cloud/amazon/route53.py,sha256=MiZR-EdHtVQc0dr2tkXwSGWhCJafw4y0xfynp7BEBkc,24018 +ansible/modules/cloud/amazon/route53.pyc,, +ansible/modules/cloud/amazon/route53_facts.py,sha256=X7vYCNCnw3A__229iKA1JBQ4n4NcGWvaQ2_jwdMM6P8,12908 +ansible/modules/cloud/amazon/route53_facts.pyc,, +ansible/modules/cloud/amazon/route53_health_check.py,sha256=WnlG0leyZJbBCI6y-8mnumtYZGw8-r_q_tv6ZkH0vnE,13079 +ansible/modules/cloud/amazon/route53_health_check.pyc,, +ansible/modules/cloud/amazon/route53_zone.py,sha256=YSbbl42fH_9QX6hzXr1Fqx6lHPpCxDYZn8tVf7_wkb8,16446 +ansible/modules/cloud/amazon/route53_zone.pyc,, +ansible/modules/cloud/amazon/s3_bucket.py,sha256=yMSy5Gzz0xPjhHtATg8Q9zUw0pBVCQFOj6_VaF0SR6U,22896 +ansible/modules/cloud/amazon/s3_bucket.pyc,, +ansible/modules/cloud/amazon/s3_lifecycle.py,sha256=Mpa0_h5UYRUNEcOut-FCR-iZnwjTHmVjPCv33ubm9Ms,20288 +ansible/modules/cloud/amazon/s3_lifecycle.pyc,, +ansible/modules/cloud/amazon/s3_logging.py,sha256=7lvbH_X7VUgDl0wLJedRcraZEK2dt8lmRmGNwipPFAY,5320 +ansible/modules/cloud/amazon/s3_logging.pyc,, +ansible/modules/cloud/amazon/s3_sync.py,sha256=1alXau_tkCR5_yDADKRhxK5BDfqziIysxtTtJpei1Qg,19617 +ansible/modules/cloud/amazon/s3_sync.pyc,, +ansible/modules/cloud/amazon/s3_website.py,sha256=g5aNgzmmXMyrErZAAatmPlTFNrbeDjRn_DWlZrNlVc0,10652 +ansible/modules/cloud/amazon/s3_website.pyc,, +ansible/modules/cloud/amazon/sns.py,sha256=dJyrrACQCJmi2YPWJFH9a8sat4OhN4irvoXREnRoOo8,7273 +ansible/modules/cloud/amazon/sns.pyc,, +ansible/modules/cloud/amazon/sns_topic.py,sha256=9K55v8d09ZfQGElF2NN1CBgRsNO1yPgnabtL57vAj2w,19555 +ansible/modules/cloud/amazon/sns_topic.pyc,, +ansible/modules/cloud/amazon/sqs_queue.py,sha256=VLO-T_gVcfBerlUEvhM1Brp_TYwXC6VZjITFE8UzsYU,9867 +ansible/modules/cloud/amazon/sqs_queue.pyc,, +ansible/modules/cloud/amazon/sts_assume_role.py,sha256=gB6ELZIuy3vHf0-wFA3aov36V8js8YqjlnIfej3CIQQ,6320 +ansible/modules/cloud/amazon/sts_assume_role.pyc,, +ansible/modules/cloud/amazon/sts_session_token.py,sha256=ZtlNl_CsKsX5pVy2IL6LTIAjB04fLHoIXEzZ82MHdB8,4933 +ansible/modules/cloud/amazon/sts_session_token.pyc,, +ansible/modules/cloud/atomic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/atomic/__init__.pyc,, +ansible/modules/cloud/atomic/atomic_container.py,sha256=OE6EaUhwOQk3hOY0029Rto779fjBzKDpxSsnwXkuNZM,6561 +ansible/modules/cloud/atomic/atomic_container.pyc,, +ansible/modules/cloud/atomic/atomic_host.py,sha256=TukQJQ0xoDuVFrNoHkXhQSV78PDl_rXQ9Sg3jyHrKCk,2731 +ansible/modules/cloud/atomic/atomic_host.pyc,, +ansible/modules/cloud/atomic/atomic_image.py,sha256=nHJN0G1y2Xwp3wpky0C9qPFo1ADTKoMHvk5xC_7KB-U,5230 +ansible/modules/cloud/atomic/atomic_image.pyc,, +ansible/modules/cloud/azure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/azure/__init__.pyc,, +ansible/modules/cloud/azure/_azure.py,sha256=4AfO8UGzh-0J0BZkfVsN71nYDEGe-GRWsPJoPAiyBMY,23782 +ansible/modules/cloud/azure/_azure.pyc,, +ansible/modules/cloud/azure/azure_rm_acs.py,sha256=4bEJwS3DOyRi-4-agPbf-6kKr4vwWEueZyH7Ejr0EHM,29357 +ansible/modules/cloud/azure/azure_rm_acs.pyc,, +ansible/modules/cloud/azure/azure_rm_aks.py,sha256=AYFh7gIGxQb-dnnR1X7F7wET6ixJjJdR0Hh25xoD1eI,22127 +ansible/modules/cloud/azure/azure_rm_aks.pyc,, +ansible/modules/cloud/azure/azure_rm_aks_facts.py,sha256=Ji_ruxiHXUxJP2aAUGqY400uYV1gD345U0GwiTsLEI0,3911 +ansible/modules/cloud/azure/azure_rm_aks_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_appgateway.py,sha256=gHwilBzL1UGmVBxx55ZrL9DZZqvf2MhgQUSv_Siw7UU,35561 +ansible/modules/cloud/azure/azure_rm_appgateway.pyc,, +ansible/modules/cloud/azure/azure_rm_appserviceplan.py,sha256=hJFsHePGgh77BSuozR0dxhJDzLuAq3glbomh5WjiPqY,10547 +ansible/modules/cloud/azure/azure_rm_appserviceplan.pyc,, +ansible/modules/cloud/azure/azure_rm_appserviceplan_facts.py,sha256=OoQbi-X8yHbyzes82xUgJIjdn5FNrM-QowNhG157zHc,7323 +ansible/modules/cloud/azure/azure_rm_appserviceplan_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_autoscale.py,sha256=1lnzjByIePQ3BwcPLnES0Hb4yYHjZR1_FpxdHY3b98A,26908 +ansible/modules/cloud/azure/azure_rm_autoscale.pyc,, +ansible/modules/cloud/azure/azure_rm_autoscale_facts.py,sha256=eLmYcWQBnVsyuNJ_70qIBqWm2OMvEh4Ah05t0wPKp9Y,5480 +ansible/modules/cloud/azure/azure_rm_autoscale_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_availabilityset.py,sha256=lVB0WC_rcmdgjj-6PQ3Hjt99jyW1H8DFJ2an8FtToxk,9906 +ansible/modules/cloud/azure/azure_rm_availabilityset.pyc,, +ansible/modules/cloud/azure/azure_rm_availabilityset_facts.py,sha256=Ho5hcihchOQAGqWjTtPOfv6WkXtOa13O8swvLEq-BTk,4642 +ansible/modules/cloud/azure/azure_rm_availabilityset_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_containerinstance.py,sha256=jtVv85McT_7Oem5MPkXhGKM8n-15HAX388PG8Pq8rko,14939 +ansible/modules/cloud/azure/azure_rm_containerinstance.pyc,, +ansible/modules/cloud/azure/azure_rm_containerregistry.py,sha256=HW57kaxRSuQC-gr3XGQMrteNHk7xtAWj6v04uaaeciE,14269 +ansible/modules/cloud/azure/azure_rm_containerregistry.pyc,, +ansible/modules/cloud/azure/azure_rm_containerregistry_facts.py,sha256=adAGuBBq_c3AHMNTpS7pP2zBUTV6jw5Naiclpm0wfxc,8416 +ansible/modules/cloud/azure/azure_rm_containerregistry_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_deployment.py,sha256=c50_R70nZWB9pnYP3CCGmxiCy9nLcqZA3XfT6wvFg2Q,27347 +ansible/modules/cloud/azure/azure_rm_deployment.pyc,, +ansible/modules/cloud/azure/azure_rm_dnsrecordset.py,sha256=o8mL5vdoGSunnNarlpwPt6Vxhi6C2qUQDi9U_jzS0KI,13657 +ansible/modules/cloud/azure/azure_rm_dnsrecordset.pyc,, +ansible/modules/cloud/azure/azure_rm_dnsrecordset_facts.py,sha256=a-JYdC89kUiyF1Z_Mj9ixk9WRjLL6mzox-KHsjhOdHY,6509 +ansible/modules/cloud/azure/azure_rm_dnsrecordset_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_dnszone.py,sha256=uzSTvf116VywHfxD949AyJDncETLQPIgPQ387Giv9R0,6982 +ansible/modules/cloud/azure/azure_rm_dnszone.pyc,, +ansible/modules/cloud/azure/azure_rm_dnszone_facts.py,sha256=Wd3aJegQFN-oKJB10y1WfOUUTkmOkTE7OVhA2PHMGn8,5086 +ansible/modules/cloud/azure/azure_rm_dnszone_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_functionapp.py,sha256=Awhnfs3xAt7z9Rzz5VRqJ4cmDnmlcRIHnokt8Xyy98I,10270 +ansible/modules/cloud/azure/azure_rm_functionapp.pyc,, +ansible/modules/cloud/azure/azure_rm_functionapp_facts.py,sha256=zZmsgZgmMZyZM91eZG3GbXGK4g-zLk9bV2mQI6AKSzg,6001 +ansible/modules/cloud/azure/azure_rm_functionapp_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_image.py,sha256=le9JCA2fADl3v6-zWpQGKgAcrWpgvSZCW6IfreOjPBA,11696 +ansible/modules/cloud/azure/azure_rm_image.pyc,, +ansible/modules/cloud/azure/azure_rm_keyvault.py,sha256=24KR3IOtoMGnVGpPRXyf6RWsUoctjPpMLxE0J0i9nL8,20115 +ansible/modules/cloud/azure/azure_rm_keyvault.pyc,, +ansible/modules/cloud/azure/azure_rm_keyvaultkey.py,sha256=BCOiRwcRtUyo-R51SQeNOvXsLgAwJbt17JFZlwU90k4,10440 +ansible/modules/cloud/azure/azure_rm_keyvaultkey.pyc,, +ansible/modules/cloud/azure/azure_rm_keyvaultsecret.py,sha256=kFPVDGj56yjng_l9QFEPnfAd8pa10pYhwY6sZm_B2yA,6951 +ansible/modules/cloud/azure/azure_rm_keyvaultsecret.pyc,, +ansible/modules/cloud/azure/azure_rm_loadbalancer.py,sha256=OCsqMYbJCzQvfIADkyNS1VJydML19sQ0l4XV4yC5MLE,36277 +ansible/modules/cloud/azure/azure_rm_loadbalancer.pyc,, +ansible/modules/cloud/azure/azure_rm_loadbalancer_facts.py,sha256=7Agk0WVIKtHSag2XEl-gLvVe4MahTr0MgEWjODTtB5A,4891 +ansible/modules/cloud/azure/azure_rm_loadbalancer_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_managed_disk.py,sha256=IPl2gfbeZ7CcezIS539DzRl3CJ89y-NRz2xmdzY32QA,13265 +ansible/modules/cloud/azure/azure_rm_managed_disk.pyc,, +ansible/modules/cloud/azure/azure_rm_managed_disk_facts.py,sha256=6paJA9wJ_w1aK35LcZNjHWoGfz_pdfSJjLLVJ209cNk,5107 +ansible/modules/cloud/azure/azure_rm_managed_disk_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_mysqldatabase.py,sha256=pwPSlVbg5KZsgyXgYUOsCmwjvDci2DZAL0gRJ6Np4zg,10690 +ansible/modules/cloud/azure/azure_rm_mysqldatabase.pyc,, +ansible/modules/cloud/azure/azure_rm_mysqldatabase_facts.py,sha256=lPpmpPGVZxYP2dBUYFfMS8UhP9y9SlrU6vrdEyb86XQ,5925 +ansible/modules/cloud/azure/azure_rm_mysqldatabase_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_mysqlserver.py,sha256=dmydSABWGnAJTZPeDXQCRhHN-D1_BPVvbwAgIZs6ciw,13209 +ansible/modules/cloud/azure/azure_rm_mysqlserver.pyc,, +ansible/modules/cloud/azure/azure_rm_mysqlserver_facts.py,sha256=BDhK7geezkari-xeDX0J6lZxHVemkjCk4HCOrJXpqCA,6817 +ansible/modules/cloud/azure/azure_rm_mysqlserver_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_networkinterface.py,sha256=BER7ynoKYizMryqccixrsi9spFILrpIkBWLQJMnTne4,32840 +ansible/modules/cloud/azure/azure_rm_networkinterface.pyc,, +ansible/modules/cloud/azure/azure_rm_networkinterface_facts.py,sha256=JVBKefKD-xc64fERynYj6kYWLXrF-AQImnHn37iJ9Jk,6696 +ansible/modules/cloud/azure/azure_rm_networkinterface_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_postgresqldatabase.py,sha256=9FSk7eganl1ZQ3VMGVxGwSTPfv0FHixRkEWofi_zufI,10900 +ansible/modules/cloud/azure/azure_rm_postgresqldatabase.pyc,, +ansible/modules/cloud/azure/azure_rm_postgresqldatabase_facts.py,sha256=5TF1ImYZniHQMIl04lt4yAN-kOXf47LHvNz3s6PMbQ8,6074 +ansible/modules/cloud/azure/azure_rm_postgresqldatabase_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_postgresqlserver.py,sha256=M7LPIksL3jtATuKIO2VsgrnD-EL5bZxMcppdaxeTnaM,13420 +ansible/modules/cloud/azure/azure_rm_postgresqlserver.pyc,, +ansible/modules/cloud/azure/azure_rm_postgresqlserver_facts.py,sha256=9nZ-64cmMQQaocXGqTF7ytNs7Nt57nJNMMBBAgnIED4,6876 +ansible/modules/cloud/azure/azure_rm_postgresqlserver_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_publicipaddress.py,sha256=eNmlaDZNnH-DTlK9szJNP5U_9mfUwaLvekfpOs3sHtk,10029 +ansible/modules/cloud/azure/azure_rm_publicipaddress.pyc,, +ansible/modules/cloud/azure/azure_rm_publicipaddress_facts.py,sha256=vozHe37czPoFWnCz5dCBABZ4HgFc-qAbkGqlZLw_Gvo,5576 +ansible/modules/cloud/azure/azure_rm_publicipaddress_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_resource.py,sha256=vVUr60ZxfXPKqQJ1WLWSDe1lD8cvz7pA6eCYnMueHUk,8787 +ansible/modules/cloud/azure/azure_rm_resource.pyc,, +ansible/modules/cloud/azure/azure_rm_resource_facts.py,sha256=UIFLDJFOwbnCe7TM7ZlpWWMy-cliDrbuC_nuj_o0YeU,6311 +ansible/modules/cloud/azure/azure_rm_resource_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_resourcegroup.py,sha256=MMqsqaAenFpmFzBXbu-Kkd2Dtdpedqo-9QfiM5oAAVg,8679 +ansible/modules/cloud/azure/azure_rm_resourcegroup.pyc,, +ansible/modules/cloud/azure/azure_rm_resourcegroup_facts.py,sha256=pO-oCzLoyoFsl_TVdA_Y0Gz7ebkdw5CWa7shGzXG_lM,3939 +ansible/modules/cloud/azure/azure_rm_resourcegroup_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_route.py,sha256=bCVTSEAbShBTZPkE4V9DsHKRJvAOuvV_0JZgz0cJOvc,7346 +ansible/modules/cloud/azure/azure_rm_route.pyc,, +ansible/modules/cloud/azure/azure_rm_routetable.py,sha256=DwOpuiGNYK-VyX6sfhzOpFHv8syEHfiGMCVQmmMBD7M,6221 +ansible/modules/cloud/azure/azure_rm_routetable.pyc,, +ansible/modules/cloud/azure/azure_rm_routetable_facts.py,sha256=YWiCY8rZM6suY-fSc1DRVeskEwbO4MHH1DI3aXTasQg,5564 +ansible/modules/cloud/azure/azure_rm_routetable_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_securitygroup.py,sha256=gUaPml2SWblLZ5ZETIHHLcT3Ln2UGAa8K4VHefvHKJU,28341 +ansible/modules/cloud/azure/azure_rm_securitygroup.pyc,, +ansible/modules/cloud/azure/azure_rm_securitygroup_facts.py,sha256=r-kwhexyVBJ3DDo5JeglfHx3NUseBnXZKowYdI0pRNc,10606 +ansible/modules/cloud/azure/azure_rm_securitygroup_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_sqldatabase.py,sha256=kJ0BlHwum25BSc-7jFkeX5fMWXiqxvCpzC-PcFzCysY,19681 +ansible/modules/cloud/azure/azure_rm_sqldatabase.pyc,, +ansible/modules/cloud/azure/azure_rm_sqlfirewallrule.py,sha256=tgpyCJp2IN3eguRLDFoZo2NzNVvPHYAV1wQhRztotC8,9645 +ansible/modules/cloud/azure/azure_rm_sqlfirewallrule.pyc,, +ansible/modules/cloud/azure/azure_rm_sqlserver.py,sha256=OF9LxzCaOlqYg9Mdl3I2HoXaB0kjC3o-fWzxVCKTvS8,10759 +ansible/modules/cloud/azure/azure_rm_sqlserver.pyc,, +ansible/modules/cloud/azure/azure_rm_sqlserver_facts.py,sha256=N1iIPKQ5XCnAjWgGZuzfm89GJcDgrZL9MAImSdwRdQk,6290 +ansible/modules/cloud/azure/azure_rm_sqlserver_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_storageaccount.py,sha256=i31yy22IPDOFnnf8nPSaIJzgn2Xvup2RmUrt8Rikunc,19171 +ansible/modules/cloud/azure/azure_rm_storageaccount.pyc,, +ansible/modules/cloud/azure/azure_rm_storageaccount_facts.py,sha256=3sXX0FZceZfYI6XratWUpUqQMGKQfQzGD1POORSNmV4,5827 +ansible/modules/cloud/azure/azure_rm_storageaccount_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_storageblob.py,sha256=qNR4i6ylyIIPDy2VbB8Uyc70ZYUsx2IMAElOy5c0_ss,21406 +ansible/modules/cloud/azure/azure_rm_storageblob.pyc,, +ansible/modules/cloud/azure/azure_rm_subnet.py,sha256=PXuwk1PsBbqHo5wBnq_pe8FLvJZfubaRWXw8vUfZwiA,13483 +ansible/modules/cloud/azure/azure_rm_subnet.pyc,, +ansible/modules/cloud/azure/azure_rm_trafficmanagerendpoint.py,sha256=bo5IMSNwDiRONKwYAhiGPWvsszfp1IOPCFYKt18AgZk,13798 +ansible/modules/cloud/azure/azure_rm_trafficmanagerendpoint.pyc,, +ansible/modules/cloud/azure/azure_rm_trafficmanagerendpoint_facts.py,sha256=58Tk9Mbzoj81oJiFdWeTHE2BFZycXINKJetpzsRIDqc,8907 +ansible/modules/cloud/azure/azure_rm_trafficmanagerendpoint_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_trafficmanagerprofile.py,sha256=NJ8eXsHsoqo3W_o3SWIVd0Z7h4Kblz0QR4kLCaOHn3E,16489 +ansible/modules/cloud/azure/azure_rm_trafficmanagerprofile.pyc,, +ansible/modules/cloud/azure/azure_rm_trafficmanagerprofile_facts.py,sha256=GtBty4BHMn96mMSC0TBoWyPSEwwp79uKZHOVEd9nJXo,12773 +ansible/modules/cloud/azure/azure_rm_trafficmanagerprofile_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualmachine.py,sha256=awS7hxupYTyWTqIGmhSe_0-2Gui-axBx-fIcH73Rm8A,84497 +ansible/modules/cloud/azure/azure_rm_virtualmachine.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualmachine_extension.py,sha256=MzFrj2y-GqV6ejLqbTI0ZTPet4fNZrxltRZSXV0O2aI,9896 +ansible/modules/cloud/azure/azure_rm_virtualmachine_extension.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualmachine_facts.py,sha256=kpJFzR380IUo0_Ov6mSIW_SOuaopQ0RIdrWnwGY4DW8,10796 +ansible/modules/cloud/azure/azure_rm_virtualmachine_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualmachine_scaleset.py,sha256=MQ9RBitDOZGcU7kBO69ZgqHDd0Ag2GVtVWizP_31Els,39117 +ansible/modules/cloud/azure/azure_rm_virtualmachine_scaleset.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualmachine_scaleset_facts.py,sha256=-hU9dEpzDH_kcKsCd7cCnZYz8YcgY8BXnNv5R6GDXAU,13643 +ansible/modules/cloud/azure/azure_rm_virtualmachine_scaleset_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualmachineimage_facts.py,sha256=YK2MhN6ouHw4_mK-tt7bZRyl67CuuIYe7iUsieKe9Ls,6797 +ansible/modules/cloud/azure/azure_rm_virtualmachineimage_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualnetwork.py,sha256=8uZrT6Ai1QL232xRtJ1XBzbafaedF5XwoTu1pVN8zF8,13253 +ansible/modules/cloud/azure/azure_rm_virtualnetwork.pyc,, +ansible/modules/cloud/azure/azure_rm_virtualnetwork_facts.py,sha256=4kM_GJJBT7VhGMqir9X3uY9y4dsCBTUY1R79R0sLPYA,5144 +ansible/modules/cloud/azure/azure_rm_virtualnetwork_facts.pyc,, +ansible/modules/cloud/azure/azure_rm_webapp.py,sha256=zrOEwQcL9F7J6aJ2G08ViF6n6VqygWA0FrJLbQ4MjjM,36963 +ansible/modules/cloud/azure/azure_rm_webapp.pyc,, +ansible/modules/cloud/azure/azure_rm_webapp_facts.py,sha256=ZeKFDBfhikKhLXII4IyB_eIxPD7JGKR7T4KX2Em42Ak,13314 +ansible/modules/cloud/azure/azure_rm_webapp_facts.pyc,, +ansible/modules/cloud/centurylink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/centurylink/__init__.pyc,, +ansible/modules/cloud/centurylink/clc_aa_policy.py,sha256=5n4JNYiMSecAnPJ0Gh2Nmc8kFXlKyHkPETcJvfwhs7k,10521 +ansible/modules/cloud/centurylink/clc_aa_policy.pyc,, +ansible/modules/cloud/centurylink/clc_alert_policy.py,sha256=QGOy6AIUOF4QmOtAEMBReQv1y1_sfSMvfLHauzPo1fc,17447 +ansible/modules/cloud/centurylink/clc_alert_policy.pyc,, +ansible/modules/cloud/centurylink/clc_blueprint_package.py,sha256=dwuvFUCto__Hu62CLI_Y-NmY6EExPlMeVOX3WqRIhWo,10113 +ansible/modules/cloud/centurylink/clc_blueprint_package.pyc,, +ansible/modules/cloud/centurylink/clc_firewall_policy.py,sha256=UOPxjpn7IXpgQP4lcZCYZuZ7bjwSP5cVJKMrnfHxoSQ,21245 +ansible/modules/cloud/centurylink/clc_firewall_policy.pyc,, +ansible/modules/cloud/centurylink/clc_group.py,sha256=5PctkRvX7BwORn1n5k-I3Nu16uGw4FMrTXxagxNqO6I,16765 +ansible/modules/cloud/centurylink/clc_group.pyc,, +ansible/modules/cloud/centurylink/clc_loadbalancer.py,sha256=guLjsmlIECkM6xgYyrvIRk-eFAAmCEvrRxnbtDBzHmc,34753 +ansible/modules/cloud/centurylink/clc_loadbalancer.pyc,, +ansible/modules/cloud/centurylink/clc_modify_server.py,sha256=eqnBNbahPKIdIRIChIV5WYtCmoR-N57p1CbRvvprsJA,34575 +ansible/modules/cloud/centurylink/clc_modify_server.pyc,, +ansible/modules/cloud/centurylink/clc_publicip.py,sha256=xxN_R-hC8gIZJ64xHXRvia_uDieuVoQgP8pxxjukPEo,11990 +ansible/modules/cloud/centurylink/clc_publicip.pyc,, +ansible/modules/cloud/centurylink/clc_server.py,sha256=LRWdmWxxz9dgfxgQ3bUkBkfc_fW4Uwv_4iARLb8z534,55954 +ansible/modules/cloud/centurylink/clc_server.pyc,, +ansible/modules/cloud/centurylink/clc_server_snapshot.py,sha256=pei-UQa44f6VO0DbOnKFLOMihupQTr9Vn82LA0wDJBE,14108 +ansible/modules/cloud/centurylink/clc_server_snapshot.pyc,, +ansible/modules/cloud/cloudscale/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/cloudscale/__init__.pyc,, +ansible/modules/cloud/cloudscale/cloudscale_floating_ip.py,sha256=f6HXR3SUiu8LqJFwaIF7fkJD6iGYAmquGIcJTCxL0rw,9740 +ansible/modules/cloud/cloudscale/cloudscale_floating_ip.pyc,, +ansible/modules/cloud/cloudscale/cloudscale_server.py,sha256=9gGqLJFwG5ixIu0T6fc8JOVEcuZwdDrImNUArlE2P3E,13293 +ansible/modules/cloud/cloudscale/cloudscale_server.pyc,, +ansible/modules/cloud/cloudstack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/cloudstack/__init__.pyc,, +ansible/modules/cloud/cloudstack/_cs_nic.py,sha256=8C5tBjdqYFmTGBQElcDW2jFrz8ktT7bkxWxmIYU1uZA,8156 +ansible/modules/cloud/cloudstack/_cs_nic.pyc,, +ansible/modules/cloud/cloudstack/cs_account.py,sha256=NDPk9xB7yt7Gx2EoUklWq4Lp1XjIe6yLsh8bzmajQD4,10559 +ansible/modules/cloud/cloudstack/cs_account.pyc,, +ansible/modules/cloud/cloudstack/cs_affinitygroup.py,sha256=n1_hqt68AFFLktonkMrgmeMVvUgxVnKDmFwL5oEk7-U,7275 +ansible/modules/cloud/cloudstack/cs_affinitygroup.pyc,, +ansible/modules/cloud/cloudstack/cs_cluster.py,sha256=FECcyDhTw59V22QTcKOVAtmEn9pVh3HtQPOXRN3fCm4,11787 +ansible/modules/cloud/cloudstack/cs_cluster.pyc,, +ansible/modules/cloud/cloudstack/cs_configuration.py,sha256=XtbIDo9hm2DOYGSkQH-1JS-eVavBIxATDFuaRZC9bWQ,8340 +ansible/modules/cloud/cloudstack/cs_configuration.pyc,, +ansible/modules/cloud/cloudstack/cs_disk_offering.py,sha256=yD-Mh6Jd05RAxefr6z5Fte5CFX-VTGOO8g5engrqAtE,11291 +ansible/modules/cloud/cloudstack/cs_disk_offering.pyc,, +ansible/modules/cloud/cloudstack/cs_domain.py,sha256=M4lRqhZvWyPDpRLGscVl2jDq_7iPuJPlliKBipIOxiQ,7150 +ansible/modules/cloud/cloudstack/cs_domain.pyc,, +ansible/modules/cloud/cloudstack/cs_facts.py,sha256=GU_fBR3roQ-4ROVdYF4Zpb4xLAMKOBcjlZhbbSCzONU,8119 +ansible/modules/cloud/cloudstack/cs_facts.pyc,, +ansible/modules/cloud/cloudstack/cs_firewall.py,sha256=mNBY-I6BlgvE6GRUPHyI28jMrpkEsCKDFHUGgOMNYnA,13491 +ansible/modules/cloud/cloudstack/cs_firewall.pyc,, +ansible/modules/cloud/cloudstack/cs_host.py,sha256=tszBybNxO_mhC1cDeT3AD8TWYQJS_ODmKeWwiDDQQrQ,18456 +ansible/modules/cloud/cloudstack/cs_host.pyc,, +ansible/modules/cloud/cloudstack/cs_instance.py,sha256=2m6Nz7yXlKIDF2Uiy49ZEDgQaOgfN0gKJSMLytVHZIY,38918 +ansible/modules/cloud/cloudstack/cs_instance.pyc,, +ansible/modules/cloud/cloudstack/cs_instance_facts.py,sha256=yjbRNgB7LY8wcssJz7xiR9zw_AUJDIm-3UBHbY2Uz9w,8632 +ansible/modules/cloud/cloudstack/cs_instance_facts.pyc,, +ansible/modules/cloud/cloudstack/cs_instance_nic.py,sha256=DFT3zPldy3-OewFv3U9sm1yph9OrWJEdE_QW4TS77Fw,8002 +ansible/modules/cloud/cloudstack/cs_instance_nic.pyc,, +ansible/modules/cloud/cloudstack/cs_instance_nic_secondaryip.py,sha256=bxP-e_vtFpez1C2QVx2ensVLBKFTS0Jin5SAPs18nCo,8006 +ansible/modules/cloud/cloudstack/cs_instance_nic_secondaryip.pyc,, +ansible/modules/cloud/cloudstack/cs_instancegroup.py,sha256=YCp5EORGaZ4HlGiV1UL2vlypBld8AufNXOMPwTImX8Y,5335 +ansible/modules/cloud/cloudstack/cs_instancegroup.pyc,, +ansible/modules/cloud/cloudstack/cs_ip_address.py,sha256=3LHCYRO7mIwXutL0gld6z4e8aAr0pr6AzuZFECmUyq0,8009 +ansible/modules/cloud/cloudstack/cs_ip_address.pyc,, +ansible/modules/cloud/cloudstack/cs_iso.py,sha256=gVTUEfnLcb9l3p05BZhzT6bALm0SsSMqTJm3J3O2ecY,13505 +ansible/modules/cloud/cloudstack/cs_iso.pyc,, +ansible/modules/cloud/cloudstack/cs_loadbalancer_rule.py,sha256=ceRtLrj3osif11r3T_MA4Qn0wscv60m3VzkStrYDm2w,10342 +ansible/modules/cloud/cloudstack/cs_loadbalancer_rule.pyc,, +ansible/modules/cloud/cloudstack/cs_loadbalancer_rule_member.py,sha256=4SaxJ9R7wPrebhomEx4tLFxQNvtv745RoJX_2ZazNSo,9656 +ansible/modules/cloud/cloudstack/cs_loadbalancer_rule_member.pyc,, +ansible/modules/cloud/cloudstack/cs_network.py,sha256=a8DX2uE2gihXGpMo4jIUsWUpyI9WizUqyluzjwI1fNA,18141 +ansible/modules/cloud/cloudstack/cs_network.pyc,, +ansible/modules/cloud/cloudstack/cs_network_acl.py,sha256=UFfl6TlUxHiaJ99t9GRn6fClZA7HeAL1818pNh7HUDQ,5618 +ansible/modules/cloud/cloudstack/cs_network_acl.pyc,, +ansible/modules/cloud/cloudstack/cs_network_acl_rule.py,sha256=X8opSjl2CgW_WDjroWJAp9mQRXdg0N6IY_pSxizfxPA,14421 +ansible/modules/cloud/cloudstack/cs_network_acl_rule.pyc,, +ansible/modules/cloud/cloudstack/cs_network_offering.py,sha256=J_-IBzNIckDTvBImZnfsQVdR-_zfiVoqoqXgsxxsLLY,12782 +ansible/modules/cloud/cloudstack/cs_network_offering.pyc,, +ansible/modules/cloud/cloudstack/cs_pod.py,sha256=oY8FgHHgW-0lbs6On8ZG552M664xNnWGv0ug0wQYdOQ,7239 +ansible/modules/cloud/cloudstack/cs_pod.pyc,, +ansible/modules/cloud/cloudstack/cs_portforward.py,sha256=E3kf9PSQ-5UEcrzufJW4rmrj0xZdcmAW8KFaxNMSxLc,12316 +ansible/modules/cloud/cloudstack/cs_portforward.pyc,, +ansible/modules/cloud/cloudstack/cs_project.py,sha256=Ph53K9DuOK5ltPe6__Wn0hhxybeDav0UqE1IVsZylKA,7998 +ansible/modules/cloud/cloudstack/cs_project.pyc,, +ansible/modules/cloud/cloudstack/cs_region.py,sha256=onpCz1Iwfm6tG2kBuZ054Tx5p9zV6MMYdmjYsICxphE,5319 +ansible/modules/cloud/cloudstack/cs_region.pyc,, +ansible/modules/cloud/cloudstack/cs_resourcelimit.py,sha256=5ga58oP458Z0-sIo9Jb1JiP5XhwumgdsvuqdjvqiLsU,5951 +ansible/modules/cloud/cloudstack/cs_resourcelimit.pyc,, +ansible/modules/cloud/cloudstack/cs_role.py,sha256=P-p16IIXh1rHg7tUjVaH3LCad4n20s6X8gCBQs3AiLo,5796 +ansible/modules/cloud/cloudstack/cs_role.pyc,, +ansible/modules/cloud/cloudstack/cs_role_permission.py,sha256=hV1uuZgCJfGuJtVvvPD29W1mw9kfFuYDr4DkTrWRljw,9375 +ansible/modules/cloud/cloudstack/cs_role_permission.pyc,, +ansible/modules/cloud/cloudstack/cs_router.py,sha256=Zpugafyw3HJRf17PRr5RoPoM7yFaVWOucnh7Fe_16zg,10470 +ansible/modules/cloud/cloudstack/cs_router.pyc,, +ansible/modules/cloud/cloudstack/cs_securitygroup.py,sha256=zbg6XYuHa3qWjGbtBKsTTyFm6tc-Rv3P9Vg8ou4i3fs,5313 +ansible/modules/cloud/cloudstack/cs_securitygroup.pyc,, +ansible/modules/cloud/cloudstack/cs_securitygroup_rule.py,sha256=kKyXCIbphhZNz0dZ63fBkrui911Q26T3Ikxzz1PXX2A,12777 +ansible/modules/cloud/cloudstack/cs_securitygroup_rule.pyc,, +ansible/modules/cloud/cloudstack/cs_service_offering.py,sha256=Dm7aU7Rc7BbQfvxWw-ofaXrCPJBymk1HJRPvlkdxUM4,17032 +ansible/modules/cloud/cloudstack/cs_service_offering.pyc,, +ansible/modules/cloud/cloudstack/cs_snapshot_policy.py,sha256=zinuSCgYUVLVJRmTWjqtGjuFo-GQOdusEsLye0NQX-g,10636 +ansible/modules/cloud/cloudstack/cs_snapshot_policy.pyc,, +ansible/modules/cloud/cloudstack/cs_sshkeypair.py,sha256=sP9QVHhDz682oZNa1GnuKNH5bFuzbvWNp_DLildkyjc,8797 +ansible/modules/cloud/cloudstack/cs_sshkeypair.pyc,, +ansible/modules/cloud/cloudstack/cs_staticnat.py,sha256=2kGSuJurku038KRphbR_oBQ_cRUXgii-eHawBl6voJE,7371 +ansible/modules/cloud/cloudstack/cs_staticnat.pyc,, +ansible/modules/cloud/cloudstack/cs_storage_pool.py,sha256=Mr6OhCvpOYdXfjmCiKgl4qc_ObqBB8G-8CNsgNiIdGI,15975 +ansible/modules/cloud/cloudstack/cs_storage_pool.pyc,, +ansible/modules/cloud/cloudstack/cs_template.py,sha256=SKrdKIy_VgSRwGtpXA_QY1FyosRQmmU_A1BFe8TETzg,23954 +ansible/modules/cloud/cloudstack/cs_template.pyc,, +ansible/modules/cloud/cloudstack/cs_user.py,sha256=c_SrfMFBNSDimJe2ct1_xjC-JhrFbwH_aRb4DaZScnM,11702 +ansible/modules/cloud/cloudstack/cs_user.pyc,, +ansible/modules/cloud/cloudstack/cs_vmsnapshot.py,sha256=bg0Emst6aTeCGzxDNcg0XPWUeME3I2neghm5mtEA310,8249 +ansible/modules/cloud/cloudstack/cs_vmsnapshot.pyc,, +ansible/modules/cloud/cloudstack/cs_volume.py,sha256=OMTKFZ_F4Qx1mArXpc7Ha1GksYsI1yD-RU-4716n8ao,13709 +ansible/modules/cloud/cloudstack/cs_volume.pyc,, +ansible/modules/cloud/cloudstack/cs_vpc.py,sha256=hC559yAjDs8GhQRIe8PmMSlcREgyG7_NlD0VfsoUUqY,11320 +ansible/modules/cloud/cloudstack/cs_vpc.pyc,, +ansible/modules/cloud/cloudstack/cs_vpc_offering.py,sha256=qQSaxDvdbdYZEBm6u71QHcG25cgb-swa8ZB8ti4TkBI,8616 +ansible/modules/cloud/cloudstack/cs_vpc_offering.pyc,, +ansible/modules/cloud/cloudstack/cs_vpn_connection.py,sha256=XYxkLoe0n2zgrbKaZ8msZeRYtipWiOEjtdXejMpt-Ho,10273 +ansible/modules/cloud/cloudstack/cs_vpn_connection.pyc,, +ansible/modules/cloud/cloudstack/cs_vpn_customer_gateway.py,sha256=rIhD4CI1yEHx6plDs9_vwR44bXZB1nJNE4QIBNqM_ZU,10806 +ansible/modules/cloud/cloudstack/cs_vpn_customer_gateway.pyc,, +ansible/modules/cloud/cloudstack/cs_vpn_gateway.py,sha256=kQulMqNfUVqJ2Jy7hisvGuUyc7YQnVryZ7aoIUO4nN0,5961 +ansible/modules/cloud/cloudstack/cs_vpn_gateway.pyc,, +ansible/modules/cloud/cloudstack/cs_zone.py,sha256=5WVMsRviuIqTIqGu47bolBdim7E7ta_lWj86bkso738,10132 +ansible/modules/cloud/cloudstack/cs_zone.pyc,, +ansible/modules/cloud/cloudstack/cs_zone_facts.py,sha256=6QXEktuPAwMrI29ziBE5kwE0zapZbsLEtlmFESjAB1k,4805 +ansible/modules/cloud/cloudstack/cs_zone_facts.pyc,, +ansible/modules/cloud/digital_ocean/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/digital_ocean/__init__.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean.py,sha256=watfk96KAPdXZdp3XqJQ_xfyLfmPBUVW45GZylz_qAA,15456 +ansible/modules/cloud/digital_ocean/digital_ocean.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_account_facts.py,sha256=No8DBSN_7YmfEJWA4z6B0adpljjN2gsKgFrBjv-JFHY,2100 +ansible/modules/cloud/digital_ocean/digital_ocean_account_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_block_storage.py,sha256=95hmL8sDfrQ07aKf5v-_yj2Mt1BMsYU-6bA07VhU1BM,9906 +ansible/modules/cloud/digital_ocean/digital_ocean_block_storage.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_certificate.py,sha256=3OwbprayGwaKWr8Qpzkbw0eMl74lK5q7CaSgRM71fTo,5460 +ansible/modules/cloud/digital_ocean/digital_ocean_certificate.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_certificate_facts.py,sha256=UzG5RWtPJ6hCkQlFyG0o5Wvk_-qbl4P73UkoQMr_Kjc,3234 +ansible/modules/cloud/digital_ocean/digital_ocean_certificate_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_domain.py,sha256=-qjzlmDWrmuR5KgBueZQECJkvvrsYgGoCjMyFNBd4dQ,6228 +ansible/modules/cloud/digital_ocean/digital_ocean_domain.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_domain_facts.py,sha256=pzqI7OKAnejs8YquyyIsWF6j91Q-tV07mX8yXpV-HCs,3918 +ansible/modules/cloud/digital_ocean/digital_ocean_domain_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_floating_ip.py,sha256=pjo-xoU0Ndo8P5wH44IDLvcyC-FOY31bfJ-bTR2Z8u0,9249 +ansible/modules/cloud/digital_ocean/digital_ocean_floating_ip.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_floating_ip_facts.py,sha256=aL0v6PlNc0fwVBjuHGci2C_WyWqtCHUocsoJ7v-1ebw,3030 +ansible/modules/cloud/digital_ocean/digital_ocean_floating_ip_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_image_facts.py,sha256=NPBgL4Lctej05sJ7rqd8xpTQOhtueV3rXgaxhdTSDCw,4218 +ansible/modules/cloud/digital_ocean/digital_ocean_image_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_load_balancer_facts.py,sha256=-os79EpFRlhJNCluROH4un0zf7Q7rLdrK-QhLjZjzGg,3299 +ansible/modules/cloud/digital_ocean/digital_ocean_load_balancer_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_region_facts.py,sha256=wVzW_YZTd5brAs7r8cgvUs1fyib1zh-c9IcWrdvwRzI,2897 +ansible/modules/cloud/digital_ocean/digital_ocean_region_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_size_facts.py,sha256=tSkMLtSt1p0_1QlTnDxTGzMkQ21GuGIFNfKxm8jKHSY,2779 +ansible/modules/cloud/digital_ocean/digital_ocean_size_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_snapshot_facts.py,sha256=0PN0WNhtWvZlj3xUx4pA3YC6EmPrFKlCkdPT-JLcJ14,4971 +ansible/modules/cloud/digital_ocean/digital_ocean_snapshot_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_sshkey.py,sha256=cZG6Iua04ZgA59XSiMFKngYlIvpdqPswA1etHvpb3-s,8087 +ansible/modules/cloud/digital_ocean/digital_ocean_sshkey.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_sshkey_facts.py,sha256=y5LVj_pxJcNClc5xIgB0Dolfio_Nk2Z6t4zh_fXbqIE,2422 +ansible/modules/cloud/digital_ocean/digital_ocean_sshkey_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_tag.py,sha256=fz9ueUvnKv7PdTEv3c_ZQjMqPOWf0R9ntG3k3W6aR9A,6492 +ansible/modules/cloud/digital_ocean/digital_ocean_tag.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_tag_facts.py,sha256=qb1lyCQw4qywnB_FmheWJzZNZ8qblAATl1FGYtF5f5k,2932 +ansible/modules/cloud/digital_ocean/digital_ocean_tag_facts.pyc,, +ansible/modules/cloud/digital_ocean/digital_ocean_volume_facts.py,sha256=tGavwkDp-diRPf0ki3vSdg5Nki2WFNwv-Xus_RZ9N9Q,3673 +ansible/modules/cloud/digital_ocean/digital_ocean_volume_facts.pyc,, +ansible/modules/cloud/dimensiondata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/dimensiondata/__init__.pyc,, +ansible/modules/cloud/dimensiondata/dimensiondata_network.py,sha256=V3p_5QwDWlcmWri6PUmEo-lDGrr-uYtN2HM298vQfok,9051 +ansible/modules/cloud/dimensiondata/dimensiondata_network.pyc,, +ansible/modules/cloud/dimensiondata/dimensiondata_vlan.py,sha256=50igNPGHY9cRWy60b78Ar8lrQOh_409S9PYXN5QLzIQ,19248 +ansible/modules/cloud/dimensiondata/dimensiondata_vlan.pyc,, +ansible/modules/cloud/docker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/docker/__init__.pyc,, +ansible/modules/cloud/docker/_docker.py,sha256=VlndjDVECB6knmYsTUPyR-x5DyKd0Sy7pVkRNC3GD1o,650 +ansible/modules/cloud/docker/_docker.pyc,, +ansible/modules/cloud/docker/docker_container.py,sha256=Z7-To3aj0lGWlGx4Dc7bsbTsS67nMMKfTcMuIChTaY8,96060 +ansible/modules/cloud/docker/docker_container.pyc,, +ansible/modules/cloud/docker/docker_image.py,sha256=5lvjKZfyhl0bmLxeUO2ApjMj1Jasl_aw1xEjkjv-cm0,23083 +ansible/modules/cloud/docker/docker_image.pyc,, +ansible/modules/cloud/docker/docker_image_facts.py,sha256=HdPmU15g0K_oTRlkmL8h4dG90lszGuwd5kNJuveeX0Y,7157 +ansible/modules/cloud/docker/docker_image_facts.pyc,, +ansible/modules/cloud/docker/docker_login.py,sha256=veDY2eKJGgMx3RA4A7yBy9s3oy7VBEnppW8WJO95CSc,10953 +ansible/modules/cloud/docker/docker_login.pyc,, +ansible/modules/cloud/docker/docker_network.py,sha256=Wf-2hFb0nm_kPfFP3nsbb6q0XsfmmrDfzqyg4MFFocA,14593 +ansible/modules/cloud/docker/docker_network.pyc,, +ansible/modules/cloud/docker/docker_secret.py,sha256=3ad6a3Iir3WOgMNV7l-co_XLnEN-TkAGNSh6LMIukHc,8116 +ansible/modules/cloud/docker/docker_secret.pyc,, +ansible/modules/cloud/docker/docker_service.py,sha256=1ammJre5NkWtRdr3lr7sfTnFpw1zb97Zf47RrV7kLsA,38778 +ansible/modules/cloud/docker/docker_service.pyc,, +ansible/modules/cloud/docker/docker_swarm.py,sha256=7G6xQpGD97YNvj98_KEM9NkN_clqAXir3Eqa8o6Jp1o,21825 +ansible/modules/cloud/docker/docker_swarm.pyc,, +ansible/modules/cloud/docker/docker_swarm_service.py,sha256=B5IM_dNmlfRxSzmwD_knJ7iBdZnDr9mLAEq8CdXtG4c,45846 +ansible/modules/cloud/docker/docker_swarm_service.pyc,, +ansible/modules/cloud/docker/docker_volume.py,sha256=pnjiK8_YLE8F9PG-D4LK9z0TjNzroA7GOzo0NfgSh8M,8502 +ansible/modules/cloud/docker/docker_volume.pyc,, +ansible/modules/cloud/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/google/__init__.pyc,, +ansible/modules/cloud/google/gc_storage.py,sha256=ZJ7xqstg_860oVsIjVGINucT4tpmuXNkt65dW5RnT3w,16892 +ansible/modules/cloud/google/gc_storage.pyc,, +ansible/modules/cloud/google/gcdns_record.py,sha256=GsCiPQnfJIsZ2ZPm7KEYI2wW6ykrn0ulg_84NGCoV8g,27090 +ansible/modules/cloud/google/gcdns_record.pyc,, +ansible/modules/cloud/google/gcdns_zone.py,sha256=zEKi6TIw9kNjDNTsS2b27Qwzos2D1imEXND0cTYm-pc,12063 +ansible/modules/cloud/google/gcdns_zone.pyc,, +ansible/modules/cloud/google/gce.py,sha256=-cmUzueRp_cb5UB2n7Mb5ZulXbNbNzhOTiGhV5NMLTs,27529 +ansible/modules/cloud/google/gce.pyc,, +ansible/modules/cloud/google/gce_eip.py,sha256=vgNspayI9XxW8ALjmtKr_H2UVA0eMAcD3Efl0yFfn90,6405 +ansible/modules/cloud/google/gce_eip.pyc,, +ansible/modules/cloud/google/gce_img.py,sha256=5LP75pKGlXz-MbcwiDSIs5VKYtGkTIPlugnLA00sHyg,5969 +ansible/modules/cloud/google/gce_img.pyc,, +ansible/modules/cloud/google/gce_instance_template.py,sha256=WdBUW7qZk4CQUkf9ifEWAFjkrHcrhRkXMC1mo2RaOMc,18982 +ansible/modules/cloud/google/gce_instance_template.pyc,, +ansible/modules/cloud/google/gce_labels.py,sha256=JpCFXEAy9mUz9_1icZkMS4pZSNlNhZAHbhrE4j2hyzs,12673 +ansible/modules/cloud/google/gce_labels.pyc,, +ansible/modules/cloud/google/gce_lb.py,sha256=lcSAwcnu4hTpiC7I94b9XNcSJxeKcXspsVwnX0MyGDw,11807 +ansible/modules/cloud/google/gce_lb.pyc,, +ansible/modules/cloud/google/gce_mig.py,sha256=NSfhpk2-baPKp1b5fyvD0F9uOBufoor1G4DJSzddbRY,29857 +ansible/modules/cloud/google/gce_mig.pyc,, +ansible/modules/cloud/google/gce_net.py,sha256=yFpZJ9KRNI6NzPob9bveMiMEpgnp--x7s07Df8bh5k4,18212 +ansible/modules/cloud/google/gce_net.pyc,, +ansible/modules/cloud/google/gce_pd.py,sha256=fW3l5OvIkNaBLFac6fVXPbrQHJAdsVvnvV7Yv4KOOks,9927 +ansible/modules/cloud/google/gce_pd.pyc,, +ansible/modules/cloud/google/gce_snapshot.py,sha256=1sxd4XD9DpFWtldqRKECOs8mhg_tqtXMSr2Nsvq9nT4,6781 +ansible/modules/cloud/google/gce_snapshot.pyc,, +ansible/modules/cloud/google/gce_tag.py,sha256=bUNjF0bIfGSbptenrBgrnCF-pQgsi2qvdz-f7zVkOqU,7227 +ansible/modules/cloud/google/gce_tag.pyc,, +ansible/modules/cloud/google/gcp_backend_service.py,sha256=jvvwt0tnmOt16RBWMX2aYZHOf-YMXEmjwy6FNYUEimQ,12605 +ansible/modules/cloud/google/gcp_backend_service.pyc,, +ansible/modules/cloud/google/gcp_compute_address.py,sha256=C7b9_SlGQgC25jBHPgOt8zWgmh7YDzSyQZD1RO84b3w,13248 +ansible/modules/cloud/google/gcp_compute_address.pyc,, +ansible/modules/cloud/google/gcp_compute_address_facts.py,sha256=GQVYWBBESXOZ2-hIlUPbiYYb2RSAYiz_rZVGI6CICgQ,7157 +ansible/modules/cloud/google/gcp_compute_address_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_backend_bucket.py,sha256=eYa4R0AiE40Fi91j2RMh1Vyeo2tBEyBrT8HfF5XdxJc,11275 +ansible/modules/cloud/google/gcp_compute_backend_bucket.pyc,, +ansible/modules/cloud/google/gcp_compute_backend_bucket_facts.py,sha256=JIkBZiNetQAahTwn1HF_zYA6WtPPhf9YEiyPUp_iDlg,6012 +ansible/modules/cloud/google/gcp_compute_backend_bucket_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_backend_service.py,sha256=uglpVNdisuoIQTsw7Oo7YbuvpfIO8D-vXaLVkQq3P5c,41716 +ansible/modules/cloud/google/gcp_compute_backend_service.pyc,, +ansible/modules/cloud/google/gcp_compute_backend_service_facts.py,sha256=Eb3bZwKuPg2VLKA6qVUbChhSf6mUAnBQq0grkceoFcU,16564 +ansible/modules/cloud/google/gcp_compute_backend_service_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_disk.py,sha256=ydwI4CJeW9KwXgu7m_Uo1Mdgj97jSAhictsGT7seLAU,27124 +ansible/modules/cloud/google/gcp_compute_disk.pyc,, +ansible/modules/cloud/google/gcp_compute_disk_facts.py,sha256=Q-WwggtHZApYJvkkdFMvaJHcRvh6Xgcr-bS0UOkICAY,13619 +ansible/modules/cloud/google/gcp_compute_disk_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_firewall.py,sha256=Xn2zgXd_SnF870VeQ9gwgdFBHraFRTU0fl_fEX0OkEA,19307 +ansible/modules/cloud/google/gcp_compute_firewall.pyc,, +ansible/modules/cloud/google/gcp_compute_firewall_facts.py,sha256=ofq-hO2CRrtlJOiYQ88gZv1jtnrdWvfh3o_AyeYCFfM,9579 +ansible/modules/cloud/google/gcp_compute_firewall_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_forwarding_rule.py,sha256=h1-jXaPGJmd2-iMULlKqgDs2C1LIlcFmKwpQiI3X2Bw,24684 +ansible/modules/cloud/google/gcp_compute_forwarding_rule.pyc,, +ansible/modules/cloud/google/gcp_compute_forwarding_rule_facts.py,sha256=ajkxnmLsn-F7rHlzfY8pM50YuxTjZNmhRFCM9_CO370,12571 +ansible/modules/cloud/google/gcp_compute_forwarding_rule_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_global_address.py,sha256=iFz-G26kTti_rXRsJbbTPcx7_c1Wmp_EFNmqe9-k4Gk,11150 +ansible/modules/cloud/google/gcp_compute_global_address.pyc,, +ansible/modules/cloud/google/gcp_compute_global_address_facts.py,sha256=yglzP2kejI8j_U8I8TwU2Yd3o6XmwbvqkzL0qfoJyDo,6324 +ansible/modules/cloud/google/gcp_compute_global_address_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_global_forwarding_rule.py,sha256=4UcxSleM6nnL_5uh5FtGOWOO3-35Nt03UysJmq-Pj-w,25327 +ansible/modules/cloud/google/gcp_compute_global_forwarding_rule.pyc,, +ansible/modules/cloud/google/gcp_compute_global_forwarding_rule_facts.py,sha256=QBK1_gXyZAzJMm9RNQpqFkwrny-F9xVtNQsgbjADVp8,12089 +ansible/modules/cloud/google/gcp_compute_global_forwarding_rule_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_health_check.py,sha256=CIfRTyKA-3_vdk2GHn_bKE1Wj0bcSNbe3jMGYjxPGZo,31640 +ansible/modules/cloud/google/gcp_compute_health_check.pyc,, +ansible/modules/cloud/google/gcp_compute_health_check_facts.py,sha256=X5aHhwfgEAfJpar6eYRk_AJNzIzqDjRR4Uqjz8GbEGk,14145 +ansible/modules/cloud/google/gcp_compute_health_check_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_http_health_check.py,sha256=9yh7JrbmQQmomgMgzmXOQaY8SEKcHZQkJejN8Pg7xKM,14281 +ansible/modules/cloud/google/gcp_compute_http_health_check.pyc,, +ansible/modules/cloud/google/gcp_compute_http_health_check_facts.py,sha256=F1hrboOWYxaeDN5kas5hy731WLSU6qR7JTqHX-qOVcI,7515 +ansible/modules/cloud/google/gcp_compute_http_health_check_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_https_health_check.py,sha256=6hoRsNEOr5snRXgA6zytYDt6ztDYkc3V5CkHR2XB0oo,14191 +ansible/modules/cloud/google/gcp_compute_https_health_check.pyc,, +ansible/modules/cloud/google/gcp_compute_https_health_check_facts.py,sha256=uupv9utMj5jh5zJMdmjKFzcT-0usvqNt8lq3awBM3mE,7524 +ansible/modules/cloud/google/gcp_compute_https_health_check_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_image.py,sha256=8e7aPbuGIlSRQfTMj-XT_E-J1nMF6EOnLnhochk3WNA,30275 +ansible/modules/cloud/google/gcp_compute_image.pyc,, +ansible/modules/cloud/google/gcp_compute_image_facts.py,sha256=aKm3fPOPVPxXZMfOp00w_XJ89XILa4TOlHu5JeKJeeM,14424 +ansible/modules/cloud/google/gcp_compute_image_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_instance.py,sha256=pHBmJpmHnVk0A-k7C9IzVIlMbR7L-w_eagKz-IO8WE4,64597 +ansible/modules/cloud/google/gcp_compute_instance.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_facts.py,sha256=mhq2WCEwD95-NChd1LMUlIgg-55rCb6Mp-p-R5VxZek,25902 +ansible/modules/cloud/google/gcp_compute_instance_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_group.py,sha256=QgwsYmI1aofL90ToJmT7YPck3s8XMbgAPHaL-9jQtAg,14461 +ansible/modules/cloud/google/gcp_compute_instance_group.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_group_facts.py,sha256=ekOppmZgYcgN-W0dcw8d0mcQZewalJ-E7VUH9jVMfho,7256 +ansible/modules/cloud/google/gcp_compute_instance_group_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_group_manager.py,sha256=RI8ax6UOGsyNn27GE4u-1iXqTuMJsPCF0SvSAYXl5-E,22222 +ansible/modules/cloud/google/gcp_compute_instance_group_manager.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_group_manager_facts.py,sha256=fcYMbB9geTRuGvqppDWH8EpbgxX2Gfkt7dpKk7gp4LY,11721 +ansible/modules/cloud/google/gcp_compute_instance_group_manager_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_template.py,sha256=AnQYDa6nB4S4xxYfyKm2qp-lxG_b_6pz6wLjCOjFw_8,69257 +ansible/modules/cloud/google/gcp_compute_instance_template.pyc,, +ansible/modules/cloud/google/gcp_compute_instance_template_facts.py,sha256=hUx6GAlUyFgxI4m0tlyLISC0HWgJBp_8z_I_pmTD55I,27478 +ansible/modules/cloud/google/gcp_compute_instance_template_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_network.py,sha256=L1lvPuyE9EW7HtXgB--ymM90EdoPmcLpdjoZu3kHXBo,13126 +ansible/modules/cloud/google/gcp_compute_network.pyc,, +ansible/modules/cloud/google/gcp_compute_network_facts.py,sha256=omk3dFpepSFLZXJmSfPd1GGDiK-GWeNSQTWTYMpkZ_k,6973 +ansible/modules/cloud/google/gcp_compute_network_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_route.py,sha256=IounBQQi_HGZZaqdKXTi4Xis7slOp1peYnn2-yMb9VM,16681 +ansible/modules/cloud/google/gcp_compute_route.pyc,, +ansible/modules/cloud/google/gcp_compute_route_facts.py,sha256=kLd68MNeGesGi-T8sEPCZXZCeeznGwsW8lXVtQXIeZM,7916 +ansible/modules/cloud/google/gcp_compute_route_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_router.py,sha256=JIWiZZW458ecxN5F70f4gX2u-WA0d3Lckf58WBJGyDo,17972 +ansible/modules/cloud/google/gcp_compute_router.pyc,, +ansible/modules/cloud/google/gcp_compute_router_facts.py,sha256=Gm9jA_lnIQN-YfVxQfbLZM7cU7gpqHLYCaiNpYzo-Uo,8629 +ansible/modules/cloud/google/gcp_compute_router_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_ssl_certificate.py,sha256=Uxa4DxEilLimPoXbBrr1aV06EFV3pArjoTnDnFyxd2s,12069 +ansible/modules/cloud/google/gcp_compute_ssl_certificate.pyc,, +ansible/modules/cloud/google/gcp_compute_ssl_certificate_facts.py,sha256=7LqDhkHHZ9ALv83PldBTuGVothhNe4-bU2xq5SchpYk,6079 +ansible/modules/cloud/google/gcp_compute_ssl_certificate_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_ssl_policy.py,sha256=d9-8VMG6w4Pkjlsv0cWNzLB3kkLcls8KH78PzNpn8es,14604 +ansible/modules/cloud/google/gcp_compute_ssl_policy.pyc,, +ansible/modules/cloud/google/gcp_compute_ssl_policy_facts.py,sha256=ujvHUwpYfg5sfXJKS94oIAb_JoUFFnk00NI6jBWuUPg,7795 +ansible/modules/cloud/google/gcp_compute_ssl_policy_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_subnetwork.py,sha256=NkaJhpwUG2TYicYwEr52tbD6weIMMRW7nleqEukgjZ0,14450 +ansible/modules/cloud/google/gcp_compute_subnetwork.pyc,, +ansible/modules/cloud/google/gcp_compute_subnetwork_facts.py,sha256=YDNUw_Qm3sD2oPPVGrqsoL1qWSBogD0tZwdnLnREr4I,7229 +ansible/modules/cloud/google/gcp_compute_subnetwork_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_target_http_proxy.py,sha256=G2VrhogjPvXjKwtWVnV_6xLBARuW02MXl1IY36n2XYc,11662 +ansible/modules/cloud/google/gcp_compute_target_http_proxy.pyc,, +ansible/modules/cloud/google/gcp_compute_target_http_proxy_facts.py,sha256=ry6vtyVlKCn8q9sbzqfX9RMxg5MDBm4TnCj1nNZ_J9g,5849 +ansible/modules/cloud/google/gcp_compute_target_http_proxy_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_target_https_proxy.py,sha256=hWPUZoexM2TUIQa0l0Cl7u2s2aEdBORM2Mj_NtLh9Vc,15589 +ansible/modules/cloud/google/gcp_compute_target_https_proxy.pyc,, +ansible/modules/cloud/google/gcp_compute_target_https_proxy_facts.py,sha256=sHIp6F354TBc38e3HEtLoStraMhA9OkVhlwbScb2UGE,6709 +ansible/modules/cloud/google/gcp_compute_target_https_proxy_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_target_pool.py,sha256=A0gTvC9SEZqrAx20gcYdbitTz3dI3B4gLUPUem-rIIo,18374 +ansible/modules/cloud/google/gcp_compute_target_pool.pyc,, +ansible/modules/cloud/google/gcp_compute_target_pool_facts.py,sha256=dGsx5yDMweg6p5wAC4MX7XG1zNa-gUSeU42Fg-5wtkY,9385 +ansible/modules/cloud/google/gcp_compute_target_pool_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_target_ssl_proxy.py,sha256=G60eMq6Oo3VMBqbbSEjh6m_yza9_XunYKjwcztjZGTA,14701 +ansible/modules/cloud/google/gcp_compute_target_ssl_proxy.pyc,, +ansible/modules/cloud/google/gcp_compute_target_ssl_proxy_facts.py,sha256=hD4-1mXoqWbMqzdKfP102XGgy4Yv9ZiCm1kIWlYeCV4,6369 +ansible/modules/cloud/google/gcp_compute_target_ssl_proxy_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_target_tcp_proxy.py,sha256=YwR3CIxI-QeT9xhkoDFnKRPtRLUzcIz8Y5nt1vdDju0,12104 +ansible/modules/cloud/google/gcp_compute_target_tcp_proxy.pyc,, +ansible/modules/cloud/google/gcp_compute_target_tcp_proxy_facts.py,sha256=isIFAc1vJM47RGfkyohxxYctIEOUD_hJrM4FY4bXaM8,6057 +ansible/modules/cloud/google/gcp_compute_target_tcp_proxy_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_target_vpn_gateway.py,sha256=nQezHzJC8Tn11sRPxEDqY6Xv9thrOHtBpcAt5uAZwP8,11444 +ansible/modules/cloud/google/gcp_compute_target_vpn_gateway.pyc,, +ansible/modules/cloud/google/gcp_compute_target_vpn_gateway_facts.py,sha256=4C8ox1JWcbHyQzqmjx7txqvdI4kJy5fH7W4cxT2fgDI,6557 +ansible/modules/cloud/google/gcp_compute_target_vpn_gateway_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_url_map.py,sha256=VLRah1WZm6FhVx5ktciZ7e59X-5jmwJ3H4pJiAyLqPg,24108 +ansible/modules/cloud/google/gcp_compute_url_map.pyc,, +ansible/modules/cloud/google/gcp_compute_url_map_facts.py,sha256=l3gcKo1IQZzqcBTXs69s1_Ff7ZE_NZeEWHTiQnZkPU4,9996 +ansible/modules/cloud/google/gcp_compute_url_map_facts.pyc,, +ansible/modules/cloud/google/gcp_compute_vpn_tunnel.py,sha256=3GbFJucH16yjoQgtEBLTHEENTcS8KCWasytFe8ozDRU,15943 +ansible/modules/cloud/google/gcp_compute_vpn_tunnel.pyc,, +ansible/modules/cloud/google/gcp_compute_vpn_tunnel_facts.py,sha256=ORGhVmYzgzdo5SEHBRxVBeQ_b2WYazGGXAM7cQcTBMA,7873 +ansible/modules/cloud/google/gcp_compute_vpn_tunnel_facts.pyc,, +ansible/modules/cloud/google/gcp_container_cluster.py,sha256=0jWgY500S92J0WSAH51TXNJreGCo9VtvzC4YAf6tL58,42004 +ansible/modules/cloud/google/gcp_container_cluster.pyc,, +ansible/modules/cloud/google/gcp_container_node_pool.py,sha256=MP729Vvj7bcY50CmTpZN4pqLQfqhOWMafZCRoOSaPjI,31885 +ansible/modules/cloud/google/gcp_container_node_pool.pyc,, +ansible/modules/cloud/google/gcp_dns_managed_zone.py,sha256=Sc2-h9-Rp1tYHhvSslo5654yT7ADTmUWTYIbw6dx40o,9010 +ansible/modules/cloud/google/gcp_dns_managed_zone.pyc,, +ansible/modules/cloud/google/gcp_dns_resource_record_set.py,sha256=Ce_6Qmmc67envICKPTRCYrIcGBO3ND_n9B1-i5LjbT0,14965 +ansible/modules/cloud/google/gcp_dns_resource_record_set.pyc,, +ansible/modules/cloud/google/gcp_forwarding_rule.py,sha256=AOf-D0cia7VKAepJgg4AQincqWJ23Nt756AA33Sct6M,12871 +ansible/modules/cloud/google/gcp_forwarding_rule.pyc,, +ansible/modules/cloud/google/gcp_healthcheck.py,sha256=F3KB2bQjZlWTslHyTRfCKVCjI8hHZSkaqCpAPC3tEuY,15302 +ansible/modules/cloud/google/gcp_healthcheck.pyc,, +ansible/modules/cloud/google/gcp_pubsub_subscription.py,sha256=ht5bBKn_YOJzJbUgJYjA3Obtz1V8pNnjTdpmg0kzBy8,12147 +ansible/modules/cloud/google/gcp_pubsub_subscription.pyc,, +ansible/modules/cloud/google/gcp_pubsub_topic.py,sha256=dl8jONlQHWI2gPNo1i5iqxzyKI4PeDJOw9foyZ7KVM4,6369 +ansible/modules/cloud/google/gcp_pubsub_topic.pyc,, +ansible/modules/cloud/google/gcp_spanner_database.py,sha256=UYw5Joj50SM0MUvxawvmY8v5QX6mwVeMOq5KnPclzRw,9062 +ansible/modules/cloud/google/gcp_spanner_database.pyc,, +ansible/modules/cloud/google/gcp_spanner_instance.py,sha256=otjoQwQqUzpo7dtW5AWH8sQaMsxOyugF-a4svMluDEE,12886 +ansible/modules/cloud/google/gcp_spanner_instance.pyc,, +ansible/modules/cloud/google/gcp_sql_database.py,sha256=YAbVQTlptZDl6nrqPnXU8UxkbgZzOLevaPLQSTxohtM,9709 +ansible/modules/cloud/google/gcp_sql_database.pyc,, +ansible/modules/cloud/google/gcp_sql_instance.py,sha256=yGn90gLGWGNp_RV-S3dl4ygV86qYV_JlDcAGHFpfIec,41295 +ansible/modules/cloud/google/gcp_sql_instance.pyc,, +ansible/modules/cloud/google/gcp_sql_user.py,sha256=WBW5Tk-tqAswSwtlY38EmaO6dZcviiXmS0OOomota5Q,11081 +ansible/modules/cloud/google/gcp_sql_user.pyc,, +ansible/modules/cloud/google/gcp_storage_bucket.py,sha256=BuTH-5DIBjtW61nd4RcwfZgVaMzGg1GKFAhpF3_hqfo,53695 +ansible/modules/cloud/google/gcp_storage_bucket.pyc,, +ansible/modules/cloud/google/gcp_storage_bucket_access_control.py,sha256=OMUNwXM8C5mIEihzinq12mp9vh63RPDoPhcm8HpdqNw,12033 +ansible/modules/cloud/google/gcp_storage_bucket_access_control.pyc,, +ansible/modules/cloud/google/gcp_target_proxy.py,sha256=MnHgPoPXwJ-H2v2GTHAkg-jiiieUxvkgLYuwjYSIYC0,10199 +ansible/modules/cloud/google/gcp_target_proxy.pyc,, +ansible/modules/cloud/google/gcp_url_map.py,sha256=9N5qVQfV0mnoZXMei6mUDQTt2U0nUmYewmtRym4KnE4,17159 +ansible/modules/cloud/google/gcp_url_map.pyc,, +ansible/modules/cloud/google/gcpubsub.py,sha256=Brt0XRLR_K7mFOblNTMm3RSqM0Pe4UcDj2RSmJaJ3g0,11794 +ansible/modules/cloud/google/gcpubsub.pyc,, +ansible/modules/cloud/google/gcpubsub_facts.py,sha256=G75lwc57XzATLgQrW_QjHnkM07DbpCnU-SNPjQhjjn0,4359 +ansible/modules/cloud/google/gcpubsub_facts.pyc,, +ansible/modules/cloud/google/gcspanner.py,sha256=wMI8BREEFDzOxOAm44xVAuYOEZpsQDRzyEOnIjLHifc,9807 +ansible/modules/cloud/google/gcspanner.pyc,, +ansible/modules/cloud/heroku/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/heroku/__init__.pyc,, +ansible/modules/cloud/heroku/heroku_collaborator.py,sha256=1lAzQ-B_Y9YpR482LBiXlsiJhBwtHpfRX43aZV3msJI,4017 +ansible/modules/cloud/heroku/heroku_collaborator.pyc,, +ansible/modules/cloud/linode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/linode/__init__.pyc,, +ansible/modules/cloud/linode/linode.py,sha256=Db6Dlva9pRRp_uBxn_6OALec2UV5PZrX_sRq4V4AdaM,24399 +ansible/modules/cloud/linode/linode.pyc,, +ansible/modules/cloud/lxc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/lxc/__init__.pyc,, +ansible/modules/cloud/lxc/lxc_container.py,sha256=3jAp464m58zeG2VFb1S24Zu1SN31xtnsVmJ8zutjQeU,56247 +ansible/modules/cloud/lxc/lxc_container.pyc,, +ansible/modules/cloud/lxd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/lxd/__init__.pyc,, +ansible/modules/cloud/lxd/lxd_container.py,sha256=er30yLm-FsUDZ0rYxwq9mEqJjPuoHGA4MZKl5WPzP0w,20928 +ansible/modules/cloud/lxd/lxd_container.pyc,, +ansible/modules/cloud/lxd/lxd_profile.py,sha256=LZX3rcJmsRX4Y3eGQnRLtbJC3SfcRIOLIy3Lns67qMI,11857 +ansible/modules/cloud/lxd/lxd_profile.pyc,, +ansible/modules/cloud/memset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/memset/__init__.pyc,, +ansible/modules/cloud/memset/memset_dns_reload.py,sha256=g3Gm0AP_OFIkl-cun4SEskU7RlCByAa7X-s-BPp_YTQ,5876 +ansible/modules/cloud/memset/memset_dns_reload.pyc,, +ansible/modules/cloud/memset/memset_zone.py,sha256=thZjOhgkpyhbEZ13hlw4VshS2NOyd-I7i44kUq5aqfw,10804 +ansible/modules/cloud/memset/memset_zone.pyc,, +ansible/modules/cloud/memset/memset_zone_domain.py,sha256=hz8DYV56vioZb0_UNHKs32XHqOPJSsK59iJCeAbxmQc,9082 +ansible/modules/cloud/memset/memset_zone_domain.pyc,, +ansible/modules/cloud/memset/memset_zone_record.py,sha256=r-34897Py8FuwJI2g3XOEg5k6ZymhH-aS4t-1Ckawks,13706 +ansible/modules/cloud/memset/memset_zone_record.pyc,, +ansible/modules/cloud/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/misc/__init__.pyc,, +ansible/modules/cloud/misc/cloud_init_data_facts.py,sha256=DBpaqWKFGS2NVJ8LJHYm1mJ4G2k8JGT15S_j16gg5b8,3393 +ansible/modules/cloud/misc/cloud_init_data_facts.pyc,, +ansible/modules/cloud/misc/helm.py,sha256=nlELp3tqEq5M-qho3OUEzRN_ESl0ok0mpyfywXWe8BE,4873 +ansible/modules/cloud/misc/helm.pyc,, +ansible/modules/cloud/misc/ovirt.py,sha256=MssknQndNQNmmFRHwd8c7EquVq0JCGzftnSZ3rSTVlU,17024 +ansible/modules/cloud/misc/ovirt.pyc,, +ansible/modules/cloud/misc/proxmox.py,sha256=GEbg9m_IR9HNnOHAVq9tKpnOKtAChE0Wcy575GoVx2s,22697 +ansible/modules/cloud/misc/proxmox.pyc,, +ansible/modules/cloud/misc/proxmox_kvm.py,sha256=oLIdiS_qMkCeYdCcFGEh0pREKgtcSV4DOy2OhpXHvMc,44799 +ansible/modules/cloud/misc/proxmox_kvm.pyc,, +ansible/modules/cloud/misc/proxmox_template.py,sha256=Is4KejbDvIWia8-bmAq6fF2moODQ4O-hruCj9Ti69w0,8250 +ansible/modules/cloud/misc/proxmox_template.pyc,, +ansible/modules/cloud/misc/rhevm.py,sha256=0PxQgiQAW--tLuF1qyo6_G2yfeGJU4QMXjWpRkITS4M,51119 +ansible/modules/cloud/misc/rhevm.pyc,, +ansible/modules/cloud/misc/serverless.py,sha256=ejB9idslI9tSGaVMMSEcqybi6MmuIekqa2DppcD9-iM,7557 +ansible/modules/cloud/misc/serverless.pyc,, +ansible/modules/cloud/misc/terraform.py,sha256=7c51wkbwpRc3XZnqrJG77nm5GNd-so_r5TZ5FLy096Q,14740 +ansible/modules/cloud/misc/terraform.pyc,, +ansible/modules/cloud/misc/virt.py,sha256=HEk5k9PNAkSgSadvCc30OJXI6yqQ3sEUfL9m-NbFoP8,15050 +ansible/modules/cloud/misc/virt.pyc,, +ansible/modules/cloud/misc/virt_net.py,sha256=l9_LcHgbbzI2zVkytKf3IRAYA40wWZTuNqkdeITpSUs,18971 +ansible/modules/cloud/misc/virt_net.pyc,, +ansible/modules/cloud/misc/virt_pool.py,sha256=iRwjipPuo1ZZgHeihTqutyctt5UyR1fsxZLx7eMjdec,21722 +ansible/modules/cloud/misc/virt_pool.pyc,, +ansible/modules/cloud/misc/xenserver_facts.py,sha256=uCWXH4aT1j57Lk5ucdkefE3kZ-MKIzqZfodu9CIhtmk,5151 +ansible/modules/cloud/misc/xenserver_facts.pyc,, +ansible/modules/cloud/oneandone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/oneandone/__init__.pyc,, +ansible/modules/cloud/oneandone/oneandone_firewall_policy.py,sha256=PQklXkcIWFIziZgulAXUVHL2lWGjczRVlr1hzylG3zA,18691 +ansible/modules/cloud/oneandone/oneandone_firewall_policy.pyc,, +ansible/modules/cloud/oneandone/oneandone_load_balancer.py,sha256=PVdqlp5cotgwOU9KMjO0-AX7iAks4tntWYU47L8WmiE,22901 +ansible/modules/cloud/oneandone/oneandone_load_balancer.pyc,, +ansible/modules/cloud/oneandone/oneandone_monitoring_policy.py,sha256=_smd1v4koW7FtRf2u632WUN3hhBofB5V-YcAHu8AZtA,33731 +ansible/modules/cloud/oneandone/oneandone_monitoring_policy.pyc,, +ansible/modules/cloud/oneandone/oneandone_private_network.py,sha256=aSU85eYHJSOrTk-EM2kNsWlerJGKntEQ7apTAuUuFWk,14745 +ansible/modules/cloud/oneandone/oneandone_private_network.pyc,, +ansible/modules/cloud/oneandone/oneandone_public_ip.py,sha256=w8aVIz9wy0SW1Sxisb2mys55-AILpZlcCzJce97vBSM,10210 +ansible/modules/cloud/oneandone/oneandone_public_ip.pyc,, +ansible/modules/cloud/oneandone/oneandone_server.py,sha256=-v2qzRPhX2dSeTCASJbjo4sZzcH66MRsHdJjjHfvqWU,22851 +ansible/modules/cloud/oneandone/oneandone_server.pyc,, +ansible/modules/cloud/online/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/online/__init__.pyc,, +ansible/modules/cloud/online/online_user_facts.py,sha256=ID81HbRo3X1sdTVQtZQ2SVaTQaYJt-hKInpRnxNHQFM,1700 +ansible/modules/cloud/online/online_user_facts.pyc,, +ansible/modules/cloud/opennebula/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/opennebula/__init__.pyc,, +ansible/modules/cloud/opennebula/one_host.py,sha256=4BSt_oULPp6aoOMIF_thVSNbbxVYZ4G__WDqPm5f0uc,9821 +ansible/modules/cloud/opennebula/one_host.pyc,, +ansible/modules/cloud/opennebula/one_image.py,sha256=tAXRaeuIUPzDWbUGjz8i4uImj23aCgwoJVPmeX1O5DQ,11669 +ansible/modules/cloud/opennebula/one_image.pyc,, +ansible/modules/cloud/opennebula/one_image_facts.py,sha256=0yBsUirSWEQGMAoDyIfb17vxGlhzLHmK2zvC3UFQFek,8102 +ansible/modules/cloud/opennebula/one_image_facts.pyc,, +ansible/modules/cloud/opennebula/one_service.py,sha256=e60kelEZQJcoKl44U9zHcO5nHvv6niSEjXdPKZTEj-g,25622 +ansible/modules/cloud/opennebula/one_service.pyc,, +ansible/modules/cloud/opennebula/one_vm.py,sha256=9cXzMndaSf6Lpvsk3RmL7JiBZgL7FkjfsxTD1eTiIKY,50014 +ansible/modules/cloud/opennebula/one_vm.pyc,, +ansible/modules/cloud/openstack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/openstack/__init__.pyc,, +ansible/modules/cloud/openstack/_os_server_actions.py,sha256=4Ke4EOGx-RoKYKXwWYH79gw-Y33sNfQ1KqIbLMI69o4,8182 +ansible/modules/cloud/openstack/_os_server_actions.pyc,, +ansible/modules/cloud/openstack/os_auth.py,sha256=rOnJo2whcngzspfZrcg6hZEHuVziRDtheaKERNx4bXI,1767 +ansible/modules/cloud/openstack/os_auth.pyc,, +ansible/modules/cloud/openstack/os_client_config.py,sha256=KAAOdWZpn98iz2OAMDIU1-PxMJ-a5KmQpUrmz8dnXG8,2245 +ansible/modules/cloud/openstack/os_client_config.pyc,, +ansible/modules/cloud/openstack/os_coe_cluster_template.py,sha256=K0jAVzTLInz_-tQ8S3T8-SsZ9tYAlsXHmtsCs4UNPP0,12590 +ansible/modules/cloud/openstack/os_coe_cluster_template.pyc,, +ansible/modules/cloud/openstack/os_flavor_facts.py,sha256=MyvzdCM6QqkgHFk4CQbHlXn1RzdxgrG4p99VO3sEQwA,6809 +ansible/modules/cloud/openstack/os_flavor_facts.pyc,, +ansible/modules/cloud/openstack/os_floating_ip.py,sha256=3pG1c0gaS6v_wPZKmiEny4xuuW297CRXyScMU0RSOrc,9820 +ansible/modules/cloud/openstack/os_floating_ip.pyc,, +ansible/modules/cloud/openstack/os_group.py,sha256=WLjn8084eaHY51saK30FRgVsiOLMc2qHisrx0Ag5KWY,4758 +ansible/modules/cloud/openstack/os_group.pyc,, +ansible/modules/cloud/openstack/os_image.py,sha256=MtrCACAua9gU6fNzK6U9QmdoYc0U94pwxZkzNeGt7gY,6182 +ansible/modules/cloud/openstack/os_image.pyc,, +ansible/modules/cloud/openstack/os_image_facts.py,sha256=ULdtvuv09VBWw5TLWLeXsyJSpZ_nbQ-Tv-V3k8tSNBo,4735 +ansible/modules/cloud/openstack/os_image_facts.pyc,, +ansible/modules/cloud/openstack/os_ironic.py,sha256=R8KWDozKY7WK11cij8Y_uupyoFa84fIxKF3T1m41WPo,12365 +ansible/modules/cloud/openstack/os_ironic.pyc,, +ansible/modules/cloud/openstack/os_ironic_inspect.py,sha256=-gSEQSGjsMLX9BHwP4v514yUXIjxPNGKzIWBLo3UieY,4981 +ansible/modules/cloud/openstack/os_ironic_inspect.pyc,, +ansible/modules/cloud/openstack/os_ironic_node.py,sha256=Md2kofMX3SiDchLjWims1riGCZG6vN7ub2wsBGQGmwA,12663 +ansible/modules/cloud/openstack/os_ironic_node.pyc,, +ansible/modules/cloud/openstack/os_keypair.py,sha256=z7KkvphHfGvvn18OApMRoXZWxMyPKr9QcKkhQw_rk00,4598 +ansible/modules/cloud/openstack/os_keypair.pyc,, +ansible/modules/cloud/openstack/os_keystone_domain.py,sha256=Ba4qPAaPkBGng22Vx9cdCwUWE1dRN9DWZtRGTxneD74,5153 +ansible/modules/cloud/openstack/os_keystone_domain.pyc,, +ansible/modules/cloud/openstack/os_keystone_domain_facts.py,sha256=jILNfe9D3WHgYZm8jZzMxvKgrq8khKzgDLC9uLXQ6hA,3510 +ansible/modules/cloud/openstack/os_keystone_domain_facts.pyc,, +ansible/modules/cloud/openstack/os_keystone_endpoint.py,sha256=KWf3Bj6zjKyKdRypK2sfXzH-P_YPitk_HIlEwFI0DrE,6356 +ansible/modules/cloud/openstack/os_keystone_endpoint.pyc,, +ansible/modules/cloud/openstack/os_keystone_role.py,sha256=ZRKC1AXlCN4HXtxRwToWf9n7lTtaNZz-F5RS9wxhbnw,3246 +ansible/modules/cloud/openstack/os_keystone_role.pyc,, +ansible/modules/cloud/openstack/os_keystone_service.py,sha256=gYef1WLFo34zE9bbODzdVImYQkqBvMmMXMnymDWSgDU,5676 +ansible/modules/cloud/openstack/os_keystone_service.pyc,, +ansible/modules/cloud/openstack/os_listener.py,sha256=9w55z4yySKr0QH_84Hsrwe6c-WTh9hZmd1cOORUCTVA,8358 +ansible/modules/cloud/openstack/os_listener.pyc,, +ansible/modules/cloud/openstack/os_loadbalancer.py,sha256=t1uV1xasA2x4MzSszmc3BEribliOgajwRyIhSDnFq2Y,8260 +ansible/modules/cloud/openstack/os_loadbalancer.pyc,, +ansible/modules/cloud/openstack/os_member.py,sha256=aITAbb-JoLkSzKfg3uxJ3RI18nHwrTaxnZK9o0x4Qsk,6989 +ansible/modules/cloud/openstack/os_member.pyc,, +ansible/modules/cloud/openstack/os_network.py,sha256=PWlcdmQmDEpFXCMXXXRtebwbcm7u9DvS0gaVXwZvO2M,7411 +ansible/modules/cloud/openstack/os_network.pyc,, +ansible/modules/cloud/openstack/os_networks_facts.py,sha256=Bi2ciFzek7XXjYMYYUD92Q3JWGF1QkVZhvHTRGg_suA,4010 +ansible/modules/cloud/openstack/os_networks_facts.pyc,, +ansible/modules/cloud/openstack/os_nova_flavor.py,sha256=hMyFTLOD3s0eyWs_5WuuzpZUKd00iF5KPtOcJKSpgkk,7526 +ansible/modules/cloud/openstack/os_nova_flavor.pyc,, +ansible/modules/cloud/openstack/os_nova_host_aggregate.py,sha256=Wxq_sph00H12a1q66M9crwvss75bxS4_sy4eHcQWdE0,5989 +ansible/modules/cloud/openstack/os_nova_host_aggregate.pyc,, +ansible/modules/cloud/openstack/os_object.py,sha256=JR_YCaLjez-l9SeDvGWvEgsI6VtcWvpqlgpDOqUSIWo,3841 +ansible/modules/cloud/openstack/os_object.pyc,, +ansible/modules/cloud/openstack/os_pool.py,sha256=ybHtLMtjfzqjz8DzTE9XnJGqrDH0krHgQKtyx6xkmNg,8811 +ansible/modules/cloud/openstack/os_pool.pyc,, +ansible/modules/cloud/openstack/os_port.py,sha256=BaQf0AFpwZHyxCEFNHpEEK2N4Hl38wmswThYDTUFqEA,11492 +ansible/modules/cloud/openstack/os_port.pyc,, +ansible/modules/cloud/openstack/os_port_facts.py,sha256=JFi86RWK-tP4YLC1q4f1g5xCUS_Jo5INELxncGI0Myw,7195 +ansible/modules/cloud/openstack/os_port_facts.pyc,, +ansible/modules/cloud/openstack/os_project.py,sha256=PCJfjbgom8qURF5rRSXzJPPaPhmjmoDoQkBlYCsP2fc,6086 +ansible/modules/cloud/openstack/os_project.pyc,, +ansible/modules/cloud/openstack/os_project_access.py,sha256=lSuPrKFtJCOK756CcJgoFZWfKkjBzYn22R1Go8A62l8,6817 +ansible/modules/cloud/openstack/os_project_access.pyc,, +ansible/modules/cloud/openstack/os_project_facts.py,sha256=LAeHE1OYstvz3CtelhI0In1eH-K1d6M7k2Tr5KeTgY0,4395 +ansible/modules/cloud/openstack/os_project_facts.pyc,, +ansible/modules/cloud/openstack/os_quota.py,sha256=dboGPsoz1JDupAVUgube5Wu6gc06j2G2bXO1v23Ziqk,15737 +ansible/modules/cloud/openstack/os_quota.pyc,, +ansible/modules/cloud/openstack/os_recordset.py,sha256=17dFxINHHb96dYwCGUpE0S-X6QmyVwqKsP5tCW9w6JM,7460 +ansible/modules/cloud/openstack/os_recordset.pyc,, +ansible/modules/cloud/openstack/os_router.py,sha256=mmzPJlOtv4FZbP_N_w1qXAEtCgl0vcwjB5-5Orl8q1A,17760 +ansible/modules/cloud/openstack/os_router.pyc,, +ansible/modules/cloud/openstack/os_security_group.py,sha256=1NC0PveRtusI0Jv8XC7-1M_g37u_YSkJBsZBtQS1HGY,4846 +ansible/modules/cloud/openstack/os_security_group.pyc,, +ansible/modules/cloud/openstack/os_security_group_rule.py,sha256=gq5lLzlU1dUwlpE9sAFjjiNOG6V_NRhnRBx15Em6uZ4,12009 +ansible/modules/cloud/openstack/os_security_group_rule.pyc,, +ansible/modules/cloud/openstack/os_server.py,sha256=mwMZSh4I3Sd6WjcChXUnJKgRaC8r3P5fty8ht6uibzU,24764 +ansible/modules/cloud/openstack/os_server.pyc,, +ansible/modules/cloud/openstack/os_server_action.py,sha256=4Ke4EOGx-RoKYKXwWYH79gw-Y33sNfQ1KqIbLMI69o4,8182 +ansible/modules/cloud/openstack/os_server_action.pyc,, +ansible/modules/cloud/openstack/os_server_facts.py,sha256=eO4BSu5ZCMnJX4VPMfUbXRdz3uWyAeyNoll3avCm3NI,2658 +ansible/modules/cloud/openstack/os_server_facts.pyc,, +ansible/modules/cloud/openstack/os_server_group.py,sha256=jv9HFVANNB3UFIQX1sro7tkLq6B6khbPKNkHWsX-H90,4713 +ansible/modules/cloud/openstack/os_server_group.pyc,, +ansible/modules/cloud/openstack/os_server_metadata.py,sha256=LTQ2i6-5pwIZ9oQRV1cdf1NhJkOj7UMRB3hdEU5-hHI,5416 +ansible/modules/cloud/openstack/os_server_metadata.pyc,, +ansible/modules/cloud/openstack/os_server_volume.py,sha256=F-I5TBgfisbkyICWmwEAjYYxrVjImZlZs6MufJ-p68Q,4342 +ansible/modules/cloud/openstack/os_server_volume.pyc,, +ansible/modules/cloud/openstack/os_stack.py,sha256=ARZYwfaGwdLspKdyRoPoLE6ISk6mPf_WN8aW8dW6e30,9206 +ansible/modules/cloud/openstack/os_stack.pyc,, +ansible/modules/cloud/openstack/os_subnet.py,sha256=bFQhVxEpdPf6etrOFv3YCIBAJ57uOZpOtGdxezXopNM,12816 +ansible/modules/cloud/openstack/os_subnet.pyc,, +ansible/modules/cloud/openstack/os_subnets_facts.py,sha256=d_UQNOvEa0A30UCYPyOiR_QGC7ylJBKFUiZL_-1V1wA,4467 +ansible/modules/cloud/openstack/os_subnets_facts.pyc,, +ansible/modules/cloud/openstack/os_user.py,sha256=oMX6lD3HmIaupntnlTQN_0cmI6mSB6nKVpedzfxCfmE,9823 +ansible/modules/cloud/openstack/os_user.pyc,, +ansible/modules/cloud/openstack/os_user_facts.py,sha256=XKVC2w5nfFY-fkChUgtZEqD-C2LDdKVENqNzWnf1kwA,4552 +ansible/modules/cloud/openstack/os_user_facts.pyc,, +ansible/modules/cloud/openstack/os_user_group.py,sha256=s0tsJMlrjgyW6N7iuMzWDtYmECo38ev0a4h83vPJkxE,2880 +ansible/modules/cloud/openstack/os_user_group.pyc,, +ansible/modules/cloud/openstack/os_user_role.py,sha256=14B-B2BQ8wgH9hGBUGIA2gW682QslBK-L4vYNPNN4-M,5581 +ansible/modules/cloud/openstack/os_user_role.pyc,, +ansible/modules/cloud/openstack/os_volume.py,sha256=TBTWzF7yV0uBERjiTSPXbR1m0q4cWjuOti2Gen69vsk,5265 +ansible/modules/cloud/openstack/os_volume.pyc,, +ansible/modules/cloud/openstack/os_volume_snapshot.py,sha256=B8bHVGQR5njM-4WUT0KEMXty06NOHahTdlkB61d_TSo,6631 +ansible/modules/cloud/openstack/os_volume_snapshot.pyc,, +ansible/modules/cloud/openstack/os_zone.py,sha256=NyhhZm8BOmnfx7BfxO2vbWf103Dra63JmFdhLvPb868,6569 +ansible/modules/cloud/openstack/os_zone.pyc,, +ansible/modules/cloud/ovh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/ovh/__init__.pyc,, +ansible/modules/cloud/ovh/ovh_ip_loadbalancing_backend.py,sha256=XpyBBV3t3BJ87DFAv8umaSmaFHPI4Z46DSs7tfXksts,11297 +ansible/modules/cloud/ovh/ovh_ip_loadbalancing_backend.pyc,, +ansible/modules/cloud/ovirt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/ovirt/__init__.pyc,, +ansible/modules/cloud/ovirt/_ovirt_affinity_groups.py,sha256=bNHQ6PM5rojDmXtmNc74ol8pgEgpS4sHF3mX9Z3X3tY,11924 +ansible/modules/cloud/ovirt/_ovirt_affinity_groups.pyc,, +ansible/modules/cloud/ovirt/_ovirt_affinity_labels.py,sha256=Tg_O_icccSBjWUbd-6MfDcHn0gg20uFi_HFxbTmr0ak,7067 +ansible/modules/cloud/ovirt/_ovirt_affinity_labels.pyc,, +ansible/modules/cloud/ovirt/_ovirt_affinity_labels_facts.py,sha256=J2wz_8HOa65CBRYcEtSYBhuBRf49wkUeSGuJqnkBgic,5876 +ansible/modules/cloud/ovirt/_ovirt_affinity_labels_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_clusters.py,sha256=VRQQuRdJBD1ShWPdH5j0Fy2ECVTWlI3WHsWG_pOxJS4,31272 +ansible/modules/cloud/ovirt/_ovirt_clusters.pyc,, +ansible/modules/cloud/ovirt/_ovirt_clusters_facts.py,sha256=n5UW6S2S80ycz36srumj-BpT02-gqseCidadNcOi--0,3660 +ansible/modules/cloud/ovirt/_ovirt_clusters_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_datacenters.py,sha256=QZPfWppmDIbPGzP_OHAKds1REfC-yMcw2sL3OsRGNGM,7418 +ansible/modules/cloud/ovirt/_ovirt_datacenters.pyc,, +ansible/modules/cloud/ovirt/_ovirt_datacenters_facts.py,sha256=27GxTijWJqy4nEkCSxOL3bIMqbeDmAPMXj-c_2T9x6g,3120 +ansible/modules/cloud/ovirt/_ovirt_datacenters_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_disks.py,sha256=VRd6wnvHKpdBP1PdmPOcVDG7zxJP3vLmzKsTcAntkKA,27277 +ansible/modules/cloud/ovirt/_ovirt_disks.pyc,, +ansible/modules/cloud/ovirt/_ovirt_external_providers.py,sha256=zRTccqmSq-zIL475zT5xiNdcYUi9Y07RuRBR7eC_dYI,14901 +ansible/modules/cloud/ovirt/_ovirt_external_providers.pyc,, +ansible/modules/cloud/ovirt/_ovirt_external_providers_facts.py,sha256=Aru-fklIL28Tu1F6VSdg2d1IsD0Dn7BSLt6YOwgQcHw,6127 +ansible/modules/cloud/ovirt/_ovirt_external_providers_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_groups.py,sha256=BbG3JKQr2WlGSFBA71Mc1efsuH-k4-8dSlN8q8NHpYY,5494 +ansible/modules/cloud/ovirt/_ovirt_groups.pyc,, +ansible/modules/cloud/ovirt/_ovirt_groups_facts.py,sha256=NlwmA6v_h32jua97ScXmefSSxS26ULrGJT2e0M63Sgw,3549 +ansible/modules/cloud/ovirt/_ovirt_groups_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_host_networks.py,sha256=hwyrxmBL8ALMwEu-7dzxliXD8DWEjPoHXrNf43-6yg4,18238 +ansible/modules/cloud/ovirt/_ovirt_host_networks.pyc,, +ansible/modules/cloud/ovirt/_ovirt_hosts.py,sha256=4WiUjPE4vEpmjtDCIk-28nndpEJFNzXPvXyLbgChQUY,22997 +ansible/modules/cloud/ovirt/_ovirt_hosts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_hosts_facts.py,sha256=_JGY_J0vPvCeTB0hcGUYheQXsORrj7eM_OvYZekAQOY,3397 +ansible/modules/cloud/ovirt/_ovirt_hosts_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_mac_pools.py,sha256=7HPZR3eQPX1-R1XoCa8j94wLorooVxONewajhYLt8NU,5018 +ansible/modules/cloud/ovirt/_ovirt_mac_pools.pyc,, +ansible/modules/cloud/ovirt/_ovirt_networks.py,sha256=JOGdU2_yfFPM5E-XHNfcd-ml-Yd246M9hYPdn4XOdUE,10597 +ansible/modules/cloud/ovirt/_ovirt_networks.pyc,, +ansible/modules/cloud/ovirt/_ovirt_networks_facts.py,sha256=jlpO1UB4Qiv7d_1r-IEGRUHEoideOBjY5Vc6Q74eSJc,3609 +ansible/modules/cloud/ovirt/_ovirt_networks_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_nics.py,sha256=agu4qd6E6xNe8_OnozU0vIlzWdu4Zx75Q2dBv0ccASw,9235 +ansible/modules/cloud/ovirt/_ovirt_nics.pyc,, +ansible/modules/cloud/ovirt/_ovirt_nics_facts.py,sha256=OscSFEtAEAn-_6qwaz4OUFPxUaqSGxqnnDY_fAW2tYE,4093 +ansible/modules/cloud/ovirt/_ovirt_nics_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_permissions.py,sha256=o3gxaHI6GUJ18i1Pvwf5u6HKXugJVlWChkBquVIOBB0,10372 +ansible/modules/cloud/ovirt/_ovirt_permissions.pyc,, +ansible/modules/cloud/ovirt/_ovirt_permissions_facts.py,sha256=hkYNpzBSk991EMKYtLIZSuDFyInwZiE4gM9YDQbAiLo,4987 +ansible/modules/cloud/ovirt/_ovirt_permissions_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_quotas.py,sha256=SLeJ8CD-F8IWPtSQeOUiJKTg-C1TmO5fDFD2wC8gcus,10427 +ansible/modules/cloud/ovirt/_ovirt_quotas.pyc,, +ansible/modules/cloud/ovirt/_ovirt_quotas_facts.py,sha256=qPrMfjRyLTmOBNS5e9OlXwP2TqDhtGH2zHMs8LLfE5k,4111 +ansible/modules/cloud/ovirt/_ovirt_quotas_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_scheduling_policies_facts.py,sha256=A0ej9qLjBCbhRVNezDPRBU3eS38_4YvIIeKKY6u075M,4274 +ansible/modules/cloud/ovirt/_ovirt_scheduling_policies_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_snapshots.py,sha256=McbHvozTyfKYVafkdim7QKYgOljb9CsnBZjg7wb7R80,8607 +ansible/modules/cloud/ovirt/_ovirt_snapshots.pyc,, +ansible/modules/cloud/ovirt/_ovirt_snapshots_facts.py,sha256=dZD854A6P2ZsObz7w1HIU9p4a68Dhg69lMll022FKk8,3982 +ansible/modules/cloud/ovirt/_ovirt_snapshots_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_storage_connections.py,sha256=hMc8tfkHzwjpxYu1VtBDBpARGbJHv9rWCDEV4LP8eqU,9316 +ansible/modules/cloud/ovirt/_ovirt_storage_connections.pyc,, +ansible/modules/cloud/ovirt/_ovirt_storage_domains.py,sha256=B6l_ZR6FjqcistkaEpN3XuSama-W52dU0ZQw4DSx6-M,27016 +ansible/modules/cloud/ovirt/_ovirt_storage_domains.pyc,, +ansible/modules/cloud/ovirt/_ovirt_storage_domains_facts.py,sha256=HCvdyn_89Q2igZAujEn3_KEKAKiKGuWhXg579hySlvA,3856 +ansible/modules/cloud/ovirt/_ovirt_storage_domains_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_storage_templates_facts.py,sha256=dIga7Yjn6U0dDE7aL6i3ZfE4ZuBPlwfMj4eclKysHmY,4646 +ansible/modules/cloud/ovirt/_ovirt_storage_templates_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_storage_vms_facts.py,sha256=C1MxSZnqD-EzD1l1WVTBeKmXqWYYXZetnFlL4OCJt2s,4539 +ansible/modules/cloud/ovirt/_ovirt_storage_vms_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_tags.py,sha256=LLItziZxeiGL6W6P2-VqyagPwFnaT0UenDk4z4NqPC4,7920 +ansible/modules/cloud/ovirt/_ovirt_tags.pyc,, +ansible/modules/cloud/ovirt/_ovirt_tags_facts.py,sha256=vcvZrvoSSrZx28H2FDfhLOLv8KhRjmbTou0Bex-LbJQ,4998 +ansible/modules/cloud/ovirt/_ovirt_tags_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_templates.py,sha256=qzapSNmqMm5rJjkl2EKIuTvWzCtX0Re_wa68ohV1Ea0,24979 +ansible/modules/cloud/ovirt/_ovirt_templates.pyc,, +ansible/modules/cloud/ovirt/_ovirt_templates_facts.py,sha256=ruTX0TdX7a0dEAfnSG_iKLeOvvs9KSOgwsNwK9SxDto,3723 +ansible/modules/cloud/ovirt/_ovirt_templates_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_users.py,sha256=stOdUG_OLCKX_fuCtRPmuEWMpkbg1PDXI4bHzuBEVBw,5272 +ansible/modules/cloud/ovirt/_ovirt_users.pyc,, +ansible/modules/cloud/ovirt/_ovirt_users_facts.py,sha256=afVGH9e36tp7fc-I2IR81-lv8LWhrXUKTtiRafHB2bs,3530 +ansible/modules/cloud/ovirt/_ovirt_users_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_vmpools.py,sha256=64s78J-8FBOmNz2v1TUh1YD8Sb1701pb-lE-Qg4BkcA,7804 +ansible/modules/cloud/ovirt/_ovirt_vmpools.pyc,, +ansible/modules/cloud/ovirt/_ovirt_vmpools_facts.py,sha256=eHt-PxLv0RrDuHZy6WlYHpEw0DrWDlwjHnwyfjzo8XY,3558 +ansible/modules/cloud/ovirt/_ovirt_vmpools_facts.pyc,, +ansible/modules/cloud/ovirt/_ovirt_vms.py,sha256=bWWGRPCnFo6VWWi7Qw7U7zcr9HGWN1bNCxnwyaENHwE,98567 +ansible/modules/cloud/ovirt/_ovirt_vms.pyc,, +ansible/modules/cloud/ovirt/_ovirt_vms_facts.py,sha256=XFQb_cZiOjXDbjAAKADUSCYBq-6mTYOAql94zrSghKI,4331 +ansible/modules/cloud/ovirt/_ovirt_vms_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_affinity_group.py,sha256=bNHQ6PM5rojDmXtmNc74ol8pgEgpS4sHF3mX9Z3X3tY,11924 +ansible/modules/cloud/ovirt/ovirt_affinity_group.pyc,, +ansible/modules/cloud/ovirt/ovirt_affinity_label.py,sha256=Tg_O_icccSBjWUbd-6MfDcHn0gg20uFi_HFxbTmr0ak,7067 +ansible/modules/cloud/ovirt/ovirt_affinity_label.pyc,, +ansible/modules/cloud/ovirt/ovirt_affinity_label_facts.py,sha256=J2wz_8HOa65CBRYcEtSYBhuBRf49wkUeSGuJqnkBgic,5876 +ansible/modules/cloud/ovirt/ovirt_affinity_label_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_api_facts.py,sha256=vCs1E4Idp2Y77jq3WVCHxbgNnTGm80ySPQp5qg3j6rM,2435 +ansible/modules/cloud/ovirt/ovirt_api_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_auth.py,sha256=Wg-2_uRVZrOkKGOB4-eCsOE7q_uonxhOctomZqUJN4o,11170 +ansible/modules/cloud/ovirt/ovirt_auth.pyc,, +ansible/modules/cloud/ovirt/ovirt_cluster.py,sha256=VRQQuRdJBD1ShWPdH5j0Fy2ECVTWlI3WHsWG_pOxJS4,31272 +ansible/modules/cloud/ovirt/ovirt_cluster.pyc,, +ansible/modules/cloud/ovirt/ovirt_cluster_facts.py,sha256=n5UW6S2S80ycz36srumj-BpT02-gqseCidadNcOi--0,3660 +ansible/modules/cloud/ovirt/ovirt_cluster_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_datacenter.py,sha256=QZPfWppmDIbPGzP_OHAKds1REfC-yMcw2sL3OsRGNGM,7418 +ansible/modules/cloud/ovirt/ovirt_datacenter.pyc,, +ansible/modules/cloud/ovirt/ovirt_datacenter_facts.py,sha256=27GxTijWJqy4nEkCSxOL3bIMqbeDmAPMXj-c_2T9x6g,3120 +ansible/modules/cloud/ovirt/ovirt_datacenter_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_disk.py,sha256=VRd6wnvHKpdBP1PdmPOcVDG7zxJP3vLmzKsTcAntkKA,27277 +ansible/modules/cloud/ovirt/ovirt_disk.pyc,, +ansible/modules/cloud/ovirt/ovirt_disk_facts.py,sha256=R4SmYxVNbSSTqa7OlyIjNnXtuAgsevq6W8kWOH-eyVI,3438 +ansible/modules/cloud/ovirt/ovirt_disk_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_external_provider.py,sha256=zRTccqmSq-zIL475zT5xiNdcYUi9Y07RuRBR7eC_dYI,14901 +ansible/modules/cloud/ovirt/ovirt_external_provider.pyc,, +ansible/modules/cloud/ovirt/ovirt_external_provider_facts.py,sha256=Aru-fklIL28Tu1F6VSdg2d1IsD0Dn7BSLt6YOwgQcHw,6127 +ansible/modules/cloud/ovirt/ovirt_external_provider_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_group.py,sha256=BbG3JKQr2WlGSFBA71Mc1efsuH-k4-8dSlN8q8NHpYY,5494 +ansible/modules/cloud/ovirt/ovirt_group.pyc,, +ansible/modules/cloud/ovirt/ovirt_group_facts.py,sha256=NlwmA6v_h32jua97ScXmefSSxS26ULrGJT2e0M63Sgw,3549 +ansible/modules/cloud/ovirt/ovirt_group_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_host.py,sha256=4WiUjPE4vEpmjtDCIk-28nndpEJFNzXPvXyLbgChQUY,22997 +ansible/modules/cloud/ovirt/ovirt_host.pyc,, +ansible/modules/cloud/ovirt/ovirt_host_facts.py,sha256=_JGY_J0vPvCeTB0hcGUYheQXsORrj7eM_OvYZekAQOY,3397 +ansible/modules/cloud/ovirt/ovirt_host_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_host_network.py,sha256=hwyrxmBL8ALMwEu-7dzxliXD8DWEjPoHXrNf43-6yg4,18238 +ansible/modules/cloud/ovirt/ovirt_host_network.pyc,, +ansible/modules/cloud/ovirt/ovirt_host_pm.py,sha256=kN-SyuasfxNMsFx8IeW_DWuIHQeutzgOmXQ958EfC18,8366 +ansible/modules/cloud/ovirt/ovirt_host_pm.pyc,, +ansible/modules/cloud/ovirt/ovirt_host_storage_facts.py,sha256=QW3DLg386O0cQeR6k6QHRwaj-Lm8is8LIMyMdJOeqnw,5178 +ansible/modules/cloud/ovirt/ovirt_host_storage_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_mac_pool.py,sha256=7HPZR3eQPX1-R1XoCa8j94wLorooVxONewajhYLt8NU,5018 +ansible/modules/cloud/ovirt/ovirt_mac_pool.pyc,, +ansible/modules/cloud/ovirt/ovirt_network.py,sha256=JOGdU2_yfFPM5E-XHNfcd-ml-Yd246M9hYPdn4XOdUE,10597 +ansible/modules/cloud/ovirt/ovirt_network.pyc,, +ansible/modules/cloud/ovirt/ovirt_network_facts.py,sha256=jlpO1UB4Qiv7d_1r-IEGRUHEoideOBjY5Vc6Q74eSJc,3609 +ansible/modules/cloud/ovirt/ovirt_network_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_nic.py,sha256=agu4qd6E6xNe8_OnozU0vIlzWdu4Zx75Q2dBv0ccASw,9235 +ansible/modules/cloud/ovirt/ovirt_nic.pyc,, +ansible/modules/cloud/ovirt/ovirt_nic_facts.py,sha256=OscSFEtAEAn-_6qwaz4OUFPxUaqSGxqnnDY_fAW2tYE,4093 +ansible/modules/cloud/ovirt/ovirt_nic_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_permission.py,sha256=o3gxaHI6GUJ18i1Pvwf5u6HKXugJVlWChkBquVIOBB0,10372 +ansible/modules/cloud/ovirt/ovirt_permission.pyc,, +ansible/modules/cloud/ovirt/ovirt_permission_facts.py,sha256=hkYNpzBSk991EMKYtLIZSuDFyInwZiE4gM9YDQbAiLo,4987 +ansible/modules/cloud/ovirt/ovirt_permission_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_quota.py,sha256=SLeJ8CD-F8IWPtSQeOUiJKTg-C1TmO5fDFD2wC8gcus,10427 +ansible/modules/cloud/ovirt/ovirt_quota.pyc,, +ansible/modules/cloud/ovirt/ovirt_quota_facts.py,sha256=qPrMfjRyLTmOBNS5e9OlXwP2TqDhtGH2zHMs8LLfE5k,4111 +ansible/modules/cloud/ovirt/ovirt_quota_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_scheduling_policy_facts.py,sha256=A0ej9qLjBCbhRVNezDPRBU3eS38_4YvIIeKKY6u075M,4274 +ansible/modules/cloud/ovirt/ovirt_scheduling_policy_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_snapshot.py,sha256=McbHvozTyfKYVafkdim7QKYgOljb9CsnBZjg7wb7R80,8607 +ansible/modules/cloud/ovirt/ovirt_snapshot.pyc,, +ansible/modules/cloud/ovirt/ovirt_snapshot_facts.py,sha256=dZD854A6P2ZsObz7w1HIU9p4a68Dhg69lMll022FKk8,3982 +ansible/modules/cloud/ovirt/ovirt_snapshot_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_storage_connection.py,sha256=hMc8tfkHzwjpxYu1VtBDBpARGbJHv9rWCDEV4LP8eqU,9316 +ansible/modules/cloud/ovirt/ovirt_storage_connection.pyc,, +ansible/modules/cloud/ovirt/ovirt_storage_domain.py,sha256=B6l_ZR6FjqcistkaEpN3XuSama-W52dU0ZQw4DSx6-M,27016 +ansible/modules/cloud/ovirt/ovirt_storage_domain.pyc,, +ansible/modules/cloud/ovirt/ovirt_storage_domain_facts.py,sha256=HCvdyn_89Q2igZAujEn3_KEKAKiKGuWhXg579hySlvA,3856 +ansible/modules/cloud/ovirt/ovirt_storage_domain_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_storage_template_facts.py,sha256=dIga7Yjn6U0dDE7aL6i3ZfE4ZuBPlwfMj4eclKysHmY,4646 +ansible/modules/cloud/ovirt/ovirt_storage_template_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_storage_vm_facts.py,sha256=C1MxSZnqD-EzD1l1WVTBeKmXqWYYXZetnFlL4OCJt2s,4539 +ansible/modules/cloud/ovirt/ovirt_storage_vm_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_tag.py,sha256=LLItziZxeiGL6W6P2-VqyagPwFnaT0UenDk4z4NqPC4,7920 +ansible/modules/cloud/ovirt/ovirt_tag.pyc,, +ansible/modules/cloud/ovirt/ovirt_tag_facts.py,sha256=vcvZrvoSSrZx28H2FDfhLOLv8KhRjmbTou0Bex-LbJQ,4998 +ansible/modules/cloud/ovirt/ovirt_tag_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_template.py,sha256=qzapSNmqMm5rJjkl2EKIuTvWzCtX0Re_wa68ohV1Ea0,24979 +ansible/modules/cloud/ovirt/ovirt_template.pyc,, +ansible/modules/cloud/ovirt/ovirt_template_facts.py,sha256=ruTX0TdX7a0dEAfnSG_iKLeOvvs9KSOgwsNwK9SxDto,3723 +ansible/modules/cloud/ovirt/ovirt_template_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_user.py,sha256=stOdUG_OLCKX_fuCtRPmuEWMpkbg1PDXI4bHzuBEVBw,5272 +ansible/modules/cloud/ovirt/ovirt_user.pyc,, +ansible/modules/cloud/ovirt/ovirt_user_facts.py,sha256=afVGH9e36tp7fc-I2IR81-lv8LWhrXUKTtiRafHB2bs,3530 +ansible/modules/cloud/ovirt/ovirt_user_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_vm.py,sha256=bWWGRPCnFo6VWWi7Qw7U7zcr9HGWN1bNCxnwyaENHwE,98567 +ansible/modules/cloud/ovirt/ovirt_vm.pyc,, +ansible/modules/cloud/ovirt/ovirt_vm_facts.py,sha256=XFQb_cZiOjXDbjAAKADUSCYBq-6mTYOAql94zrSghKI,4331 +ansible/modules/cloud/ovirt/ovirt_vm_facts.pyc,, +ansible/modules/cloud/ovirt/ovirt_vmpool.py,sha256=64s78J-8FBOmNz2v1TUh1YD8Sb1701pb-lE-Qg4BkcA,7804 +ansible/modules/cloud/ovirt/ovirt_vmpool.pyc,, +ansible/modules/cloud/ovirt/ovirt_vmpool_facts.py,sha256=eHt-PxLv0RrDuHZy6WlYHpEw0DrWDlwjHnwyfjzo8XY,3558 +ansible/modules/cloud/ovirt/ovirt_vmpool_facts.pyc,, +ansible/modules/cloud/packet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/packet/__init__.pyc,, +ansible/modules/cloud/packet/packet_device.py,sha256=63TbRBJ4V71C9DV9nTF_vk56XLsI4Obp05CncC9FJ4w,21342 +ansible/modules/cloud/packet/packet_device.pyc,, +ansible/modules/cloud/packet/packet_sshkey.py,sha256=47vibsdlP9r8jOTIYo1WX0so9J2dMDIOr24_4oQ9pHU,8829 +ansible/modules/cloud/packet/packet_sshkey.pyc,, +ansible/modules/cloud/profitbricks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/profitbricks/__init__.pyc,, +ansible/modules/cloud/profitbricks/profitbricks.py,sha256=08uLu8mChM9nQwAtssNQLql46YukH6Gai-PjWu2aiB4,21469 +ansible/modules/cloud/profitbricks/profitbricks.pyc,, +ansible/modules/cloud/profitbricks/profitbricks_datacenter.py,sha256=q5xfbivz8mu9tkYUDPXPxZEGy0OWN0by3INYSZovXJM,7523 +ansible/modules/cloud/profitbricks/profitbricks_datacenter.pyc,, +ansible/modules/cloud/profitbricks/profitbricks_nic.py,sha256=k1mPxhUikkCNK1vqOTH-UrwP1b0b8rMr-lOoFbH3nVo,8516 +ansible/modules/cloud/profitbricks/profitbricks_nic.pyc,, +ansible/modules/cloud/profitbricks/profitbricks_volume.py,sha256=Gfbfw3UQ9XouP43vdRyD2wcL9g5rbTqdUiAhIkrnmxg,12965 +ansible/modules/cloud/profitbricks/profitbricks_volume.pyc,, +ansible/modules/cloud/profitbricks/profitbricks_volume_attachments.py,sha256=cyNni_sHpLnI6CuMYTQKh_z1f8QWcXmN8yFKO34H9Fg,7782 +ansible/modules/cloud/profitbricks/profitbricks_volume_attachments.pyc,, +ansible/modules/cloud/pubnub/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/pubnub/__init__.pyc,, +ansible/modules/cloud/pubnub/pubnub_blocks.py,sha256=DGbH5HnKkowQTZGUbLpshgwvWB02s88vLi3G8fvbNwM,23806 +ansible/modules/cloud/pubnub/pubnub_blocks.pyc,, +ansible/modules/cloud/rackspace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/rackspace/__init__.pyc,, +ansible/modules/cloud/rackspace/rax.py,sha256=KGzw29wO8H7mgocT8HnC-y6U1AITOqPhyqJIXNYjOpU,33459 +ansible/modules/cloud/rackspace/rax.pyc,, +ansible/modules/cloud/rackspace/rax_cbs.py,sha256=gyZpLpMMrK7gWwSjIginnq6wdbt-0qd1qMBdBGdvmmM,6710 +ansible/modules/cloud/rackspace/rax_cbs.pyc,, +ansible/modules/cloud/rackspace/rax_cbs_attachments.py,sha256=OIu3EGEbEKs1lUeuS621N2lW65lfI49dwmMpnCQ_bHY,6575 +ansible/modules/cloud/rackspace/rax_cbs_attachments.pyc,, +ansible/modules/cloud/rackspace/rax_cdb.py,sha256=cdCxScbsb5jWrou2Jgui9X8O5FpbJu_dMc0qZHEH4PA,7730 +ansible/modules/cloud/rackspace/rax_cdb.pyc,, +ansible/modules/cloud/rackspace/rax_cdb_database.py,sha256=NQBPtuwVZO_EVzbtDlb6EKCBd-JcN-Uhlhm97Cj6Tlo,4470 +ansible/modules/cloud/rackspace/rax_cdb_database.pyc,, +ansible/modules/cloud/rackspace/rax_cdb_user.py,sha256=WzVDSnmXLNRO6PEOQjkTbfIvqPsE8bWqwL3L57FTAqo,5930 +ansible/modules/cloud/rackspace/rax_cdb_user.pyc,, +ansible/modules/cloud/rackspace/rax_clb.py,sha256=kmhpPeGGkriAj9iwnK0WA9Zo1nn3ty4HN_aSiK8T2NA,9095 +ansible/modules/cloud/rackspace/rax_clb.pyc,, +ansible/modules/cloud/rackspace/rax_clb_nodes.py,sha256=3tiQ4krWno_5q5mharIIT2xMkq46Werc6cnY_k0BEEM,8230 +ansible/modules/cloud/rackspace/rax_clb_nodes.pyc,, +ansible/modules/cloud/rackspace/rax_clb_ssl.py,sha256=pXt6FMDt3vffMqTiStiFTDBkgdJSNoHRcY4kyOrRPek,9401 +ansible/modules/cloud/rackspace/rax_clb_ssl.pyc,, +ansible/modules/cloud/rackspace/rax_dns.py,sha256=1KYKe-RD7j26Nr4Q8Wo4a59M5X682-_FGtBnuE7hYUI,4817 +ansible/modules/cloud/rackspace/rax_dns.pyc,, +ansible/modules/cloud/rackspace/rax_dns_record.py,sha256=HPBNrl32uSS5MDROn5eSpIHU1KFotS6Jqw9uvB6i4nI,11386 +ansible/modules/cloud/rackspace/rax_dns_record.pyc,, +ansible/modules/cloud/rackspace/rax_facts.py,sha256=FKClAbM_gC7X1f_86ZoCfDZBqcvVIc4bXDwl2jf0chA,3923 +ansible/modules/cloud/rackspace/rax_facts.pyc,, +ansible/modules/cloud/rackspace/rax_files.py,sha256=cEB4lXJEerj57NYgWYoAufiDaAzbhaf-7LCwo734yqA,11753 +ansible/modules/cloud/rackspace/rax_files.pyc,, +ansible/modules/cloud/rackspace/rax_files_objects.py,sha256=kew_hWyYVhtZ6TX_NGbJEPkoEHn49FR95akgpjSp5uI,18489 +ansible/modules/cloud/rackspace/rax_files_objects.pyc,, +ansible/modules/cloud/rackspace/rax_identity.py,sha256=okmDyGfkTYBG2yURoScG06Mc-w-g3s1rRMaoFqqsAm0,2712 +ansible/modules/cloud/rackspace/rax_identity.pyc,, +ansible/modules/cloud/rackspace/rax_keypair.py,sha256=urVYajutApOEEltJfj7fb0IoDDZxWyOoabv_4x6TLgs,4737 +ansible/modules/cloud/rackspace/rax_keypair.pyc,, +ansible/modules/cloud/rackspace/rax_meta.py,sha256=llIMQGho4axEeiEkK7N5Q64Ol37AG346MJCxBagJXqI,4782 +ansible/modules/cloud/rackspace/rax_meta.pyc,, +ansible/modules/cloud/rackspace/rax_mon_alarm.py,sha256=qg048EGSRTkjEm7LV4bctXMvjdT3LWOfNU4l8kveLn8,7375 +ansible/modules/cloud/rackspace/rax_mon_alarm.pyc,, +ansible/modules/cloud/rackspace/rax_mon_check.py,sha256=Pm7SftwYZwJO-rbeYZZNtajo3KRWtGrNMkKqQWDX938,10762 +ansible/modules/cloud/rackspace/rax_mon_check.pyc,, +ansible/modules/cloud/rackspace/rax_mon_entity.py,sha256=wSEnnHIoMS8MZmhqAP-HRy0eQQa04_OPSLpv675DX9w,5795 +ansible/modules/cloud/rackspace/rax_mon_entity.pyc,, +ansible/modules/cloud/rackspace/rax_mon_notification.py,sha256=CEgi3hM19FNMw8pDPi7nAibYDGwUt4IhxFMPXykC-MY,5180 +ansible/modules/cloud/rackspace/rax_mon_notification.pyc,, +ansible/modules/cloud/rackspace/rax_mon_notification_plan.py,sha256=CQCq2PcxN3Odvte3LSxEE6NZuBMfcz-exc4e7SOUTzo,5690 +ansible/modules/cloud/rackspace/rax_mon_notification_plan.pyc,, +ansible/modules/cloud/rackspace/rax_network.py,sha256=o8TVs7LZpaPGIs4UlTEuKoRpteCHls4nhWrsTXmfaZ0,3691 +ansible/modules/cloud/rackspace/rax_network.pyc,, +ansible/modules/cloud/rackspace/rax_queue.py,sha256=q_JRkg4sSWkwpOAf7sEu_KZWo6FuHr4pNkZ1ECxmepk,3457 +ansible/modules/cloud/rackspace/rax_queue.pyc,, +ansible/modules/cloud/rackspace/rax_scaling_group.py,sha256=w_tQRJ-COUBQ3Q81JhI7807HKom6oevjpgiyFgvpVI4,14430 +ansible/modules/cloud/rackspace/rax_scaling_group.pyc,, +ansible/modules/cloud/rackspace/rax_scaling_policy.py,sha256=nDrJ5g1wuO0msrRHiry20CIyZEsMzcZcJ2g5lx3d0EY,8778 +ansible/modules/cloud/rackspace/rax_scaling_policy.pyc,, +ansible/modules/cloud/scaleway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/scaleway/__init__.pyc,, +ansible/modules/cloud/scaleway/scaleway_compute.py,sha256=-Y9OW_wbwNBs0Mb4OW1sdxszwqxgUSCl1TmHh_uChAo,20567 +ansible/modules/cloud/scaleway/scaleway_compute.pyc,, +ansible/modules/cloud/scaleway/scaleway_image_facts.py,sha256=uKUPmSJjfyiMDxz5NFk-Z5LryQRuMvDfPTfz_48_9v0,3563 +ansible/modules/cloud/scaleway/scaleway_image_facts.pyc,, +ansible/modules/cloud/scaleway/scaleway_ip_facts.py,sha256=buLMF_sU2k1K-Jyri1ohsDG_TM3p7Q4EyPzzRgQu4o8,2017 +ansible/modules/cloud/scaleway/scaleway_ip_facts.pyc,, +ansible/modules/cloud/scaleway/scaleway_organization_facts.py,sha256=0GWdNKLpFUh250ZeiBRpofhkPIt3EcyLTJT6_sNwoJg,2937 +ansible/modules/cloud/scaleway/scaleway_organization_facts.pyc,, +ansible/modules/cloud/scaleway/scaleway_security_group_facts.py,sha256=tz3GdybQtmBv4WSoqrpRfDUOrcebU3zPnOk-vEePqM8,2291 +ansible/modules/cloud/scaleway/scaleway_security_group_facts.pyc,, +ansible/modules/cloud/scaleway/scaleway_server_facts.py,sha256=Tb4JlKQmhuSSKJQrV3RtgO9WvpBgVk1apkMJT_HITtI,6064 +ansible/modules/cloud/scaleway/scaleway_server_facts.pyc,, +ansible/modules/cloud/scaleway/scaleway_snapshot_facts.py,sha256=H8k7YDHKJ9jt-TIN-X158-xdRz5z-q0H8BuhQLtGn7M,2378 +ansible/modules/cloud/scaleway/scaleway_snapshot_facts.pyc,, +ansible/modules/cloud/scaleway/scaleway_sshkey.py,sha256=Lzhw0uy6c9y6QpWr8KXFeFF9VGyycLCWKOQB3ke0hts,4776 +ansible/modules/cloud/scaleway/scaleway_sshkey.pyc,, +ansible/modules/cloud/scaleway/scaleway_volume.py,sha256=cIxJuhQSHW75jPX9wDGcCSBxbFp9bJNUS3K3ll83-G0,4522 +ansible/modules/cloud/scaleway/scaleway_volume.pyc,, +ansible/modules/cloud/scaleway/scaleway_volume_facts.py,sha256=GMWOiYh0r_zV6wsYJGLZFskkacciLXHShPge5Fr261Y,2188 +ansible/modules/cloud/scaleway/scaleway_volume_facts.pyc,, +ansible/modules/cloud/smartos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/smartos/__init__.pyc,, +ansible/modules/cloud/smartos/imgadm.py,sha256=ohCoN1W0nqdlwwaOF-WDvxHZXNTDbw23h-cpZ9qRBhk,9827 +ansible/modules/cloud/smartos/imgadm.pyc,, +ansible/modules/cloud/smartos/smartos_image_facts.py,sha256=xV8CsB7Gv1kBpZPUnLslIiFMg8RnrdpDNxDx-V7DN5c,2857 +ansible/modules/cloud/smartos/smartos_image_facts.pyc,, +ansible/modules/cloud/smartos/vmadm.py,sha256=Wo1fWQReF40227mtaFDuDFX-q7S0Juup-YE2LXYrCak,24315 +ansible/modules/cloud/smartos/vmadm.pyc,, +ansible/modules/cloud/softlayer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/softlayer/__init__.pyc,, +ansible/modules/cloud/softlayer/sl_vm.py,sha256=p7WaiZP-mKthh2bjGREqToPbdBmRVQHVPXhKzq6af7E,11405 +ansible/modules/cloud/softlayer/sl_vm.pyc,, +ansible/modules/cloud/spotinst/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/spotinst/__init__.pyc,, +ansible/modules/cloud/spotinst/spotinst_aws_elastigroup.py,sha256=ORJuvEIhlOOGKIPxFNsVh_LbgAAu3vx_zu8gk0JLmOI,48732 +ansible/modules/cloud/spotinst/spotinst_aws_elastigroup.pyc,, +ansible/modules/cloud/univention/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/univention/__init__.pyc,, +ansible/modules/cloud/univention/udm_dns_record.py,sha256=Z5wKe8ktBef8auWAQubE9Tu4iKwxYJBO5M0ytUu1m1c,5348 +ansible/modules/cloud/univention/udm_dns_record.pyc,, +ansible/modules/cloud/univention/udm_dns_zone.py,sha256=WFKI8kcPgf9HI5V4_nn-385jJkKrHog0_DAiPOJIo6A,6822 +ansible/modules/cloud/univention/udm_dns_zone.pyc,, +ansible/modules/cloud/univention/udm_group.py,sha256=srAIGsuX5g6tRXLIMBS26xEPK3ljTbLa0_3xceRA33o,4788 +ansible/modules/cloud/univention/udm_group.pyc,, +ansible/modules/cloud/univention/udm_share.py,sha256=T6pKny_1CUps1UG5Gni0FztJ5W0T0-zqisEiennjpSs,19018 +ansible/modules/cloud/univention/udm_share.pyc,, +ansible/modules/cloud/univention/udm_user.py,sha256=DPP_EVCOD_WnoUPTn6lxZAf-So67WcNDnKhFaxDqZL4,17946 +ansible/modules/cloud/univention/udm_user.pyc,, +ansible/modules/cloud/vmware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/vmware/__init__.pyc,, +ansible/modules/cloud/vmware/_vsphere_guest.py,sha256=VxSV3vO8GITkJfaB0_pPFgDrEcXSjOFxEh2WVXitbk0,72260 +ansible/modules/cloud/vmware/_vsphere_guest.pyc,, +ansible/modules/cloud/vmware/vca_fw.py,sha256=C9eEihbfnqFhqJzfYIiRgLvDnBGdXQj8MVtuB_IXSDM,7967 +ansible/modules/cloud/vmware/vca_fw.pyc,, +ansible/modules/cloud/vmware/vca_nat.py,sha256=N6NNRzJhgo8iznHXBOlxcy7XNUI30HWA_-6mGA1TQVM,6434 +ansible/modules/cloud/vmware/vca_nat.pyc,, +ansible/modules/cloud/vmware/vca_vapp.py,sha256=S36i1p86XgoqAnDzFwCUZmUzeGLgv16jHO1J1qmPpeg,11413 +ansible/modules/cloud/vmware/vca_vapp.pyc,, +ansible/modules/cloud/vmware/vcenter_folder.py,sha256=eK8CeNSazqPnrsfy5KVhP749yUcHssW03Sxd2ZwghVM,10321 +ansible/modules/cloud/vmware/vcenter_folder.pyc,, +ansible/modules/cloud/vmware/vcenter_license.py,sha256=uWSusrZkiP2RH9vmf9F1_fzqwp2xy_QJ_xabWV5HzTg,5353 +ansible/modules/cloud/vmware/vcenter_license.pyc,, +ansible/modules/cloud/vmware/vmware_about_facts.py,sha256=4fEifnhYY0VB9yWtojSukuXLT2B6AlYnn2ezT-oZRfw,3662 +ansible/modules/cloud/vmware/vmware_about_facts.pyc,, +ansible/modules/cloud/vmware/vmware_category.py,sha256=fs4UWqfnl0kHZywoxu_9UnkBZ_rMs57jdtyumV1CpdE,9365 +ansible/modules/cloud/vmware/vmware_category.pyc,, +ansible/modules/cloud/vmware/vmware_category_facts.py,sha256=JoLS540PfJ_LEyOAjRDP4PA5JNoc89YGCX6RsB4FoQU,4150 +ansible/modules/cloud/vmware/vmware_category_facts.pyc,, +ansible/modules/cloud/vmware/vmware_cfg_backup.py,sha256=Av5E0bN71l-Yh3wDOA7ZlOnW13xbGrNfSrkCgTIVGN4,8900 +ansible/modules/cloud/vmware/vmware_cfg_backup.pyc,, +ansible/modules/cloud/vmware/vmware_cluster.py,sha256=Pb73_Q8rMZ6TUvQdtOiYeYtmrNReJx38l7HmmFsAQLc,10016 +ansible/modules/cloud/vmware/vmware_cluster.pyc,, +ansible/modules/cloud/vmware/vmware_cluster_facts.py,sha256=cj6Fw8BLMP2vg1EpXr03KLmJMNR6AZkjVIUgtxP3ivI,8044 +ansible/modules/cloud/vmware/vmware_cluster_facts.pyc,, +ansible/modules/cloud/vmware/vmware_datacenter.py,sha256=OB0nJehJE6ooSb5NNNdFGorjGsrkgbNhIoDDjhQK8Os,6522 +ansible/modules/cloud/vmware/vmware_datacenter.pyc,, +ansible/modules/cloud/vmware/vmware_datastore_cluster.py,sha256=vcgHx66GWCDa4auJ7EduMrd9HwMDkaAjXCLP3Aw-OjA,5606 +ansible/modules/cloud/vmware/vmware_datastore_cluster.pyc,, +ansible/modules/cloud/vmware/vmware_datastore_facts.py,sha256=tDeOinRdBoaBUDoBrbriKQs5KStfjedESBAVHzBAm-g,6815 +ansible/modules/cloud/vmware/vmware_datastore_facts.pyc,, +ansible/modules/cloud/vmware/vmware_datastore_maintenancemode.py,sha256=ep6HywZswMWCLNLStUQ0BLoV_A5xrjuk-T9KwLMZi0I,8058 +ansible/modules/cloud/vmware/vmware_datastore_maintenancemode.pyc,, +ansible/modules/cloud/vmware/vmware_deploy_ovf.py,sha256=m1AdvuNmnDZufe5Rfb_C1vRYkxHqHQrbl-xqKzpqYPk,18993 +ansible/modules/cloud/vmware/vmware_deploy_ovf.pyc,, +ansible/modules/cloud/vmware/vmware_dns_config.py,sha256=1MSgW30fXBbCfwSytdoHcGAziF2G2h5PqtRezIPAXpQ,3705 +ansible/modules/cloud/vmware/vmware_dns_config.pyc,, +ansible/modules/cloud/vmware/vmware_drs_rule_facts.py,sha256=5SJecN7Z3vd9tm2hyxEfH7ztCWLfQs04ixIQ-_LaDbM,9323 +ansible/modules/cloud/vmware/vmware_drs_rule_facts.pyc,, +ansible/modules/cloud/vmware/vmware_dvs_host.py,sha256=OtU2Q3Tk8lnf-aNLfpWyHVMzsr0-x9WIZcQg8ThGhy0,8762 +ansible/modules/cloud/vmware/vmware_dvs_host.pyc,, +ansible/modules/cloud/vmware/vmware_dvs_portgroup.py,sha256=AKrUNyEo7MGuOpcawpTlWbe-ImPQJI-Bx5MhMlEPNFg,19531 +ansible/modules/cloud/vmware/vmware_dvs_portgroup.pyc,, +ansible/modules/cloud/vmware/vmware_dvswitch.py,sha256=upleWSVefV5G0Ro8bHEJRMaAT899YmBfKHrEWOmcNuY,7782 +ansible/modules/cloud/vmware/vmware_dvswitch.pyc,, +ansible/modules/cloud/vmware/vmware_guest.py,sha256=cFj4jtFF0tDD5RNKoyAIUmrr-f4dMbNUa8QdMLmfY2w,118461 +ansible/modules/cloud/vmware/vmware_guest.pyc,, +ansible/modules/cloud/vmware/vmware_guest_boot_facts.py,sha256=KTmsaGpc8lYMxda9GAmThKT6Rc5KX0l_nKsNYHNogAc,5460 +ansible/modules/cloud/vmware/vmware_guest_boot_facts.pyc,, +ansible/modules/cloud/vmware/vmware_guest_boot_manager.py,sha256=X3aRld_Gup9OsjVy3dFlQrnXfeKVj0_QSiaXZeIURLA,12392 +ansible/modules/cloud/vmware/vmware_guest_boot_manager.pyc,, +ansible/modules/cloud/vmware/vmware_guest_custom_attribute_defs.py,sha256=3pNActEvEPhuad60zUbcuJusdH-vMm7gAjXFY_7G7FA,4751 +ansible/modules/cloud/vmware/vmware_guest_custom_attribute_defs.pyc,, +ansible/modules/cloud/vmware/vmware_guest_custom_attributes.py,sha256=Jr-JO8vjzcvLlBtAaFQmj319tIFRHqWl3R7CR-3OaTY,7298 +ansible/modules/cloud/vmware/vmware_guest_custom_attributes.pyc,, +ansible/modules/cloud/vmware/vmware_guest_disk_facts.py,sha256=NXA3Vtn44NH-rfPD1zMHCbzlC8ghYX-MFJsp9rjOHKA,6447 +ansible/modules/cloud/vmware/vmware_guest_disk_facts.pyc,, +ansible/modules/cloud/vmware/vmware_guest_facts.py,sha256=WS246Z0tmouldrvwgXLhaNihnUoXR2KrAul-SsGGmNw,4214 +ansible/modules/cloud/vmware/vmware_guest_facts.pyc,, +ansible/modules/cloud/vmware/vmware_guest_file_operation.py,sha256=9UIpwjKumOZTKtzDSgDlFLoVqE7gLTL504_AXhlYtqs,18733 +ansible/modules/cloud/vmware/vmware_guest_file_operation.pyc,, +ansible/modules/cloud/vmware/vmware_guest_find.py,sha256=sL5RDH2I-5zrNmkDnupG5FbkQu8xW6U9FnYJ0pc6lR4,4249 +ansible/modules/cloud/vmware/vmware_guest_find.pyc,, +ansible/modules/cloud/vmware/vmware_guest_move.py,sha256=-XnvsL2wEAwsIEaEvInE4fudcYnh2lbWuwfRuBMYxoQ,7055 +ansible/modules/cloud/vmware/vmware_guest_move.pyc,, +ansible/modules/cloud/vmware/vmware_guest_powerstate.py,sha256=1h5gF5kOm0bF5rh038f7kqLixYksXuXUaYs5_wy_Bf0,9024 +ansible/modules/cloud/vmware/vmware_guest_powerstate.pyc,, +ansible/modules/cloud/vmware/vmware_guest_snapshot.py,sha256=ffy79BSoh3t_AvnK7yJeFEq3KdVG_mF4rVKXLMT7TNY,16824 +ansible/modules/cloud/vmware/vmware_guest_snapshot.pyc,, +ansible/modules/cloud/vmware/vmware_guest_snapshot_facts.py,sha256=10vSY5UE1NokUqLeTR9ye-W2G7UlQuH8AQhLx-IIGSE,4970 +ansible/modules/cloud/vmware/vmware_guest_snapshot_facts.pyc,, +ansible/modules/cloud/vmware/vmware_guest_tools_wait.py,sha256=Y-F57bUd73jUV2IVt7Q5Di5Gze-IOvsLo3-uotNWnPU,5733 +ansible/modules/cloud/vmware/vmware_guest_tools_wait.pyc,, +ansible/modules/cloud/vmware/vmware_host.py,sha256=W9zxNMJKFm3VYxzpHeKY67-cOJ-FRMVOC7sSsCgopnI,16475 +ansible/modules/cloud/vmware/vmware_host.pyc,, +ansible/modules/cloud/vmware/vmware_host_acceptance.py,sha256=CFTu1_XM1wjFv8IGM7NMOIIPtEWjTH51Atu9iqWH1UM,6640 +ansible/modules/cloud/vmware/vmware_host_acceptance.pyc,, +ansible/modules/cloud/vmware/vmware_host_capability_facts.py,sha256=p0wIN7hyfAJobsoiet96twdkwRLcIN_Rxr-niKNlCKk,10662 +ansible/modules/cloud/vmware/vmware_host_capability_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_config_facts.py,sha256=4_8qTaqwRywaMZVVy-flGZWWuu1noodRpKExPBHndBA,3108 +ansible/modules/cloud/vmware/vmware_host_config_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_config_manager.py,sha256=HlJcr8B2YkPFKSKzYUTZuMClK1E_qoqk_MagPCn7YlU,7617 +ansible/modules/cloud/vmware/vmware_host_config_manager.pyc,, +ansible/modules/cloud/vmware/vmware_host_datastore.py,sha256=Oqx1jHEWCkbraB7QPN6oZKJx5qz9Nt-2upqfih7_CqM,11382 +ansible/modules/cloud/vmware/vmware_host_datastore.pyc,, +ansible/modules/cloud/vmware/vmware_host_dns_facts.py,sha256=ctWU5Quc7dgoj4iqiuLfbGlGTLtLRquXvqyidlerGlM,4061 +ansible/modules/cloud/vmware/vmware_host_dns_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_facts.py,sha256=7xxAqSgtoRto8NEfEcxjD87HBkFo6MTOZ_YeMmpzs_I,7609 +ansible/modules/cloud/vmware/vmware_host_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_firewall_facts.py,sha256=Qz6a7w4AOjwUkiXOsT_gTtRBjfACI6of63xrrUTjrrE,5072 +ansible/modules/cloud/vmware/vmware_host_firewall_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_firewall_manager.py,sha256=ZU4hMV4vHYHmSQUixEFdVWwaXD8ldA4We5NE4sN4Qgo,8047 +ansible/modules/cloud/vmware/vmware_host_firewall_manager.pyc,, +ansible/modules/cloud/vmware/vmware_host_lockdown.py,sha256=4Fi4jPpX9012_dkE9O0tkRVzLNxnkZn7ZjPsTTwSUSo,8119 +ansible/modules/cloud/vmware/vmware_host_lockdown.pyc,, +ansible/modules/cloud/vmware/vmware_host_ntp.py,sha256=xWe2u__Hgej9nAnjdhFSX6FNA5ehG1PevFOsiAeYIkA,7404 +ansible/modules/cloud/vmware/vmware_host_ntp.pyc,, +ansible/modules/cloud/vmware/vmware_host_ntp_facts.py,sha256=vzRs7sV50eyHrYyuz4pVBd-peAwEk5boIBhUdnQwvD0,4256 +ansible/modules/cloud/vmware/vmware_host_ntp_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_package_facts.py,sha256=wIr7lt72Rkt6U1qyTbdyULproPCWyOvGfevhwwV_TUc,4254 +ansible/modules/cloud/vmware/vmware_host_package_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_powerstate.py,sha256=P0wLi6rfTTByoPLC1xaTc7xTLMcHQsoAulRsyM-TYzo,9086 +ansible/modules/cloud/vmware/vmware_host_powerstate.pyc,, +ansible/modules/cloud/vmware/vmware_host_service_facts.py,sha256=wCrndH9A36sgtCZznawKg6SCHfyPam389RYdAglmLyo,5063 +ansible/modules/cloud/vmware/vmware_host_service_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_service_manager.py,sha256=sFu3gRWRCh3y1ZptucSYdh7xhp9YIM50LW_TiESbnjM,8467 +ansible/modules/cloud/vmware/vmware_host_service_manager.pyc,, +ansible/modules/cloud/vmware/vmware_host_ssl_facts.py,sha256=pZup2zFkDMMAuoywF3LZtBEjGN8efdM8q8L4u21l2zs,4683 +ansible/modules/cloud/vmware/vmware_host_ssl_facts.pyc,, +ansible/modules/cloud/vmware/vmware_host_vmnic_facts.py,sha256=4Iq3t8psD-fAfW_zFkkxAct4zH8SIRKt42apEAOPDNY,6257 +ansible/modules/cloud/vmware/vmware_host_vmnic_facts.pyc,, +ansible/modules/cloud/vmware/vmware_local_role_facts.py,sha256=sesBZp4u6zzvqfm85s86UZnESoIVgu3oQ0fVaO1fN9o,3873 +ansible/modules/cloud/vmware/vmware_local_role_facts.pyc,, +ansible/modules/cloud/vmware/vmware_local_role_manager.py,sha256=1klxwIgNCX1VX5T4JqxEBLwwmvfc_dj9TzhOAEWTLoI,11081 +ansible/modules/cloud/vmware/vmware_local_role_manager.pyc,, +ansible/modules/cloud/vmware/vmware_local_user_facts.py,sha256=LczGxCS6Qsz7aKpOAXcfgfwnqMwm-IdORifMh2q0z6Q,3395 +ansible/modules/cloud/vmware/vmware_local_user_facts.pyc,, +ansible/modules/cloud/vmware/vmware_local_user_manager.py,sha256=TZISus2G_8AS2F0optFLBlbL0Us7U_BbZIXdXdrdYZM,6294 +ansible/modules/cloud/vmware/vmware_local_user_manager.pyc,, +ansible/modules/cloud/vmware/vmware_maintenancemode.py,sha256=SPuYI2XYK6neSgWvIJ-wYseYoVmKV2XxrpC2ZPTrEeY,6686 +ansible/modules/cloud/vmware/vmware_maintenancemode.pyc,, +ansible/modules/cloud/vmware/vmware_migrate_vmk.py,sha256=ztrXAaE7-AE3-suoV55K58RoV8To4uTi8aVThfNKXMM,7020 +ansible/modules/cloud/vmware/vmware_migrate_vmk.pyc,, +ansible/modules/cloud/vmware/vmware_portgroup.py,sha256=spZOZBgiMMCGDqZ6CGg2tGdAXkiyVubcUW5JHPW2Xjc,21273 +ansible/modules/cloud/vmware/vmware_portgroup.pyc,, +ansible/modules/cloud/vmware/vmware_portgroup_facts.py,sha256=tIBzgbkc19A95qqOe9MAARJ4EmimeYoCJFX7xEoNnRw,4997 +ansible/modules/cloud/vmware/vmware_portgroup_facts.pyc,, +ansible/modules/cloud/vmware/vmware_resource_pool.py,sha256=YW34f4yQfpGJ-10c-A-ddjEb10i6q79XM81MbPslnkM,11142 +ansible/modules/cloud/vmware/vmware_resource_pool.pyc,, +ansible/modules/cloud/vmware/vmware_resource_pool_facts.py,sha256=4ZbQTh4jjUSVefIQKEgovoqETxyebr-pIfpGycvpaPo,5704 +ansible/modules/cloud/vmware/vmware_resource_pool_facts.pyc,, +ansible/modules/cloud/vmware/vmware_tag.py,sha256=NOD-mjiF0jykAIPprLUeuP762A5qj4MQaspryLRCQzY,7683 +ansible/modules/cloud/vmware/vmware_tag.pyc,, +ansible/modules/cloud/vmware/vmware_tag_facts.py,sha256=SVO5Do48a9pyOOqMkdw4nTz6ZhTyWoGV9ZGLGgeQvtY,3935 +ansible/modules/cloud/vmware/vmware_tag_facts.pyc,, +ansible/modules/cloud/vmware/vmware_target_canonical_facts.py,sha256=Q53vuKo6hTbnF6PLzNr2klETpR_OGj-vMnpgT2H34gM,6208 +ansible/modules/cloud/vmware/vmware_target_canonical_facts.pyc,, +ansible/modules/cloud/vmware/vmware_vm_facts.py,sha256=cO-QaMRFW696p4BX4TcSbVdjevW45BWJExQtzokwxwI,6619 +ansible/modules/cloud/vmware/vmware_vm_facts.pyc,, +ansible/modules/cloud/vmware/vmware_vm_shell.py,sha256=VTABGOoWpJxHFUj_DeTK5_Q6lvbxyxlQ1YN9klGFlPw,12703 +ansible/modules/cloud/vmware/vmware_vm_shell.pyc,, +ansible/modules/cloud/vmware/vmware_vm_vm_drs_rule.py,sha256=2M75t_ecbuWlkxAlqdYu9YaXbrgnJkMqEPYBhkSTbac,12538 +ansible/modules/cloud/vmware/vmware_vm_vm_drs_rule.pyc,, +ansible/modules/cloud/vmware/vmware_vm_vss_dvs_migrate.py,sha256=Oe9lsrLR5PodMfoVB_W9Y-ukja5iWUEhLzuPL1lW6VY,5254 +ansible/modules/cloud/vmware/vmware_vm_vss_dvs_migrate.pyc,, +ansible/modules/cloud/vmware/vmware_vmkernel.py,sha256=Y5gXyGWZgzkc0P-xGB90UVqVuCfKL1N_cH3DaJrzxCU,25067 +ansible/modules/cloud/vmware/vmware_vmkernel.pyc,, +ansible/modules/cloud/vmware/vmware_vmkernel_facts.py,sha256=NBYwY3wgOdMcMTUEVxA0NZ_Lx8cHl0XOZHneSSeluvc,7237 +ansible/modules/cloud/vmware/vmware_vmkernel_facts.pyc,, +ansible/modules/cloud/vmware/vmware_vmkernel_ip_config.py,sha256=Ib-cv9daqElySTuxzkGOyCo5MBAAt3aP7kqgqmKY344,3638 +ansible/modules/cloud/vmware/vmware_vmkernel_ip_config.pyc,, +ansible/modules/cloud/vmware/vmware_vmotion.py,sha256=-_ed6lQ-r_KL6eRJ5rEmo5DaJOvfTHxt_d6BdzsHKtk,11943 +ansible/modules/cloud/vmware/vmware_vmotion.pyc,, +ansible/modules/cloud/vmware/vmware_vsan_cluster.py,sha256=ihYBlyrh-wROt4IN06J5pTcAmqE-pp_3Srwvpyz94io,3756 +ansible/modules/cloud/vmware/vmware_vsan_cluster.pyc,, +ansible/modules/cloud/vmware/vmware_vswitch.py,sha256=d4VhjAZkR1Qic4-o8Slk1vpRQHAz5LyisDlZ63UgAhU,17512 +ansible/modules/cloud/vmware/vmware_vswitch.pyc,, +ansible/modules/cloud/vmware/vmware_vswitch_facts.py,sha256=ucDbO5-_flZtw_gyHxgXRowKVOwzPFaddXVJsrjnMTg,4499 +ansible/modules/cloud/vmware/vmware_vswitch_facts.pyc,, +ansible/modules/cloud/vmware/vsphere_copy.py,sha256=-n9tCtaDfw5u2gH9H09IGVgYCW-Zq916hV_8-RjxCEc,6233 +ansible/modules/cloud/vmware/vsphere_copy.pyc,, +ansible/modules/cloud/vultr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/vultr/__init__.pyc,, +ansible/modules/cloud/vultr/_vr_account_facts.py,sha256=sFx9QsvercEN_B2FdUG-hs-wEnad2LghbxxzZSf_pVI,3344 +ansible/modules/cloud/vultr/_vr_account_facts.pyc,, +ansible/modules/cloud/vultr/_vr_dns_domain.py,sha256=sqKl4W6IgEDMvohC_NBciOPENEf9Mc-CRz7AYmGUDtc,5091 +ansible/modules/cloud/vultr/_vr_dns_domain.pyc,, +ansible/modules/cloud/vultr/_vr_dns_record.py,sha256=xxA1ZDd1hOtFBgHuIW9qQ4uYe3cA-TrzttircI2rcy4,9588 +ansible/modules/cloud/vultr/_vr_dns_record.pyc,, +ansible/modules/cloud/vultr/_vr_firewall_group.py,sha256=-TRSkbg-TtiBPB0HOpkBj0UfFLM_3YJZtr8as9mmRHo,5529 +ansible/modules/cloud/vultr/_vr_firewall_group.pyc,, +ansible/modules/cloud/vultr/_vr_firewall_rule.py,sha256=Z_ek6PqDL2Bfqc-u9yGfwJABnRYq5pAcgfIuORrELhE,11659 +ansible/modules/cloud/vultr/_vr_firewall_rule.pyc,, +ansible/modules/cloud/vultr/_vr_server.py,sha256=e2F04iP1FeaOSs-mEgAyV2YGDSJu3wQ5WAM5gRJSzNA,30470 +ansible/modules/cloud/vultr/_vr_server.pyc,, +ansible/modules/cloud/vultr/_vr_ssh_key.py,sha256=MJ4Y3Tr_VBR6gW6C0tUT_LrPuYksfo6uin4AAXxIOrU,6176 +ansible/modules/cloud/vultr/_vr_ssh_key.pyc,, +ansible/modules/cloud/vultr/_vr_startup_script.py,sha256=VZ3IeQNk3Dk5suOZuLRZlt_fMcxFUM7Uyi7e_yE0NFw,7123 +ansible/modules/cloud/vultr/_vr_startup_script.pyc,, +ansible/modules/cloud/vultr/_vr_user.py,sha256=WbOJanB7eYAzQKd7BrzajkuzCpDEBcWoM-X4vFDTeT8,8097 +ansible/modules/cloud/vultr/_vr_user.pyc,, +ansible/modules/cloud/vultr/vultr_account_facts.py,sha256=sFx9QsvercEN_B2FdUG-hs-wEnad2LghbxxzZSf_pVI,3344 +ansible/modules/cloud/vultr/vultr_account_facts.pyc,, +ansible/modules/cloud/vultr/vultr_block_storage.py,sha256=qjdG94aIGbKMt2S1x2rYRIH-8VKjmVBXFlSxHhkJjZE,6663 +ansible/modules/cloud/vultr/vultr_block_storage.pyc,, +ansible/modules/cloud/vultr/vultr_block_storage_facts.py,sha256=F3nJjtLCaGjoDx_xFQoU2aBhYCmtbVRwVtdzh8nfU9M,3500 +ansible/modules/cloud/vultr/vultr_block_storage_facts.pyc,, +ansible/modules/cloud/vultr/vultr_dns_domain.py,sha256=sqKl4W6IgEDMvohC_NBciOPENEf9Mc-CRz7AYmGUDtc,5091 +ansible/modules/cloud/vultr/vultr_dns_domain.pyc,, +ansible/modules/cloud/vultr/vultr_dns_domain_facts.py,sha256=u5I7V-IkbzOPBpmw_SENWD-uVV7fYbJor5agtjnCt2w,2815 +ansible/modules/cloud/vultr/vultr_dns_domain_facts.pyc,, +ansible/modules/cloud/vultr/vultr_dns_record.py,sha256=xxA1ZDd1hOtFBgHuIW9qQ4uYe3cA-TrzttircI2rcy4,9588 +ansible/modules/cloud/vultr/vultr_dns_record.pyc,, +ansible/modules/cloud/vultr/vultr_firewall_group.py,sha256=-TRSkbg-TtiBPB0HOpkBj0UfFLM_3YJZtr8as9mmRHo,5529 +ansible/modules/cloud/vultr/vultr_firewall_group.pyc,, +ansible/modules/cloud/vultr/vultr_firewall_group_facts.py,sha256=CHP5gj_UySZsVgF_wjPT6u0vm9d4oQvUPNY7NwanEEc,3465 +ansible/modules/cloud/vultr/vultr_firewall_group_facts.pyc,, +ansible/modules/cloud/vultr/vultr_firewall_rule.py,sha256=Z_ek6PqDL2Bfqc-u9yGfwJABnRYq5pAcgfIuORrELhE,11659 +ansible/modules/cloud/vultr/vultr_firewall_rule.pyc,, +ansible/modules/cloud/vultr/vultr_network.py,sha256=O-8RMDHglDi46JUTTYhiw-KFbVaWvXElU4oUbUb3IMk,6216 +ansible/modules/cloud/vultr/vultr_network.pyc,, +ansible/modules/cloud/vultr/vultr_network_facts.py,sha256=4SmN26MOwQYrTocFhJavJg3gyfDAvdFe_vsbeHHb6Bk,3510 +ansible/modules/cloud/vultr/vultr_network_facts.pyc,, +ansible/modules/cloud/vultr/vultr_os_facts.py,sha256=GOdDoTRPgSowXJcBniLYubFlxUdTrj8yG5b0EWZgNV4,2989 +ansible/modules/cloud/vultr/vultr_os_facts.pyc,, +ansible/modules/cloud/vultr/vultr_plan_facts.py,sha256=Q0OnUb80KAMnIipt8NDvfLet1waZGlD7CRzt1e4zzM4,3647 +ansible/modules/cloud/vultr/vultr_plan_facts.pyc,, +ansible/modules/cloud/vultr/vultr_region_facts.py,sha256=yV1fZWmTyLa_2Wpu4NU1EYNGHsKSd1NP0TFzJRwjhg0,3297 +ansible/modules/cloud/vultr/vultr_region_facts.pyc,, +ansible/modules/cloud/vultr/vultr_server.py,sha256=e2F04iP1FeaOSs-mEgAyV2YGDSJu3wQ5WAM5gRJSzNA,30470 +ansible/modules/cloud/vultr/vultr_server.pyc,, +ansible/modules/cloud/vultr/vultr_server_facts.py,sha256=aeueGx4DuY5cKukdNdPeG1kDcZSpSbEjapql5QCTTq0,5680 +ansible/modules/cloud/vultr/vultr_server_facts.pyc,, +ansible/modules/cloud/vultr/vultr_ssh_key.py,sha256=MJ4Y3Tr_VBR6gW6C0tUT_LrPuYksfo6uin4AAXxIOrU,6176 +ansible/modules/cloud/vultr/vultr_ssh_key.pyc,, +ansible/modules/cloud/vultr/vultr_ssh_key_facts.py,sha256=KhzNvqtds_F8KDOAIH84XCHItvHwTGsAWYScUUNzFL0,3070 +ansible/modules/cloud/vultr/vultr_ssh_key_facts.pyc,, +ansible/modules/cloud/vultr/vultr_startup_script.py,sha256=VZ3IeQNk3Dk5suOZuLRZlt_fMcxFUM7Uyi7e_yE0NFw,7123 +ansible/modules/cloud/vultr/vultr_startup_script.pyc,, +ansible/modules/cloud/vultr/vultr_startup_script_facts.py,sha256=yIb4-elNLccVxWx3TLhXKk0BkJWHtE7rhrvXgzQlBIM,3440 +ansible/modules/cloud/vultr/vultr_startup_script_facts.pyc,, +ansible/modules/cloud/vultr/vultr_user.py,sha256=WbOJanB7eYAzQKd7BrzajkuzCpDEBcWoM-X4vFDTeT8,8097 +ansible/modules/cloud/vultr/vultr_user.pyc,, +ansible/modules/cloud/vultr/vultr_user_facts.py,sha256=3a76-NuxpakpthDHvJ7cyEaR3Ndu5ZWktACA6WdlMrU,2887 +ansible/modules/cloud/vultr/vultr_user_facts.pyc,, +ansible/modules/cloud/webfaction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/cloud/webfaction/__init__.pyc,, +ansible/modules/cloud/webfaction/webfaction_app.py,sha256=JTboC6yxXD_9LCCHFhxrOfpPaYKH4N3Tj-U43Krtbzg,5927 +ansible/modules/cloud/webfaction/webfaction_app.pyc,, +ansible/modules/cloud/webfaction/webfaction_db.py,sha256=Dx0_27TiPyuh8C3M2EP9yYZd8pwbbGt15tYmpWyUWs0,5879 +ansible/modules/cloud/webfaction/webfaction_db.pyc,, +ansible/modules/cloud/webfaction/webfaction_domain.py,sha256=mv2a5yG8HfRp_dkxBCUTkWHbXBj-WUt7bsGcX0hfRYI,4973 +ansible/modules/cloud/webfaction/webfaction_domain.pyc,, +ansible/modules/cloud/webfaction/webfaction_mailbox.py,sha256=vm9VCP074IuToBBnphIRlTwKBiCdb9OMSSzkeUZ6PvE,3990 +ansible/modules/cloud/webfaction/webfaction_mailbox.pyc,, +ansible/modules/cloud/webfaction/webfaction_site.py,sha256=C85WQjlZlt_gE7zUiWOJNt-ADpOhv0634-a_3AH7dNo,6493 +ansible/modules/cloud/webfaction/webfaction_site.pyc,, +ansible/modules/clustering/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/clustering/__init__.pyc,, +ansible/modules/clustering/consul.py,sha256=DMIjkp2lPUuITNEpukwT4Hv5FMg14mG4jdkFZ27h_ys,19938 +ansible/modules/clustering/consul.pyc,, +ansible/modules/clustering/consul_acl.py,sha256=MTE5yuPNsAqani_bP5MX_m-OssYdMNWzKeeSZ8FbKHM,22127 +ansible/modules/clustering/consul_acl.pyc,, +ansible/modules/clustering/consul_kv.py,sha256=5E2NbbrVQSO1M9W4elAV4YaByDll2lPF1zfz4ICTe1Y,11185 +ansible/modules/clustering/consul_kv.pyc,, +ansible/modules/clustering/consul_session.py,sha256=LGi2IcwqHPFW0arjyMel2HSi1eWjOvRRv7aiTihU0cA,8927 +ansible/modules/clustering/consul_session.pyc,, +ansible/modules/clustering/etcd3.py,sha256=FbTVUVtRM4vU0UrLZLSwCnP8EEkel4mRbnvWlJ7P8WQ,5933 +ansible/modules/clustering/etcd3.pyc,, +ansible/modules/clustering/k8s/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/clustering/k8s/__init__.pyc,, +ansible/modules/clustering/k8s/_k8s_raw.py,sha256=UMwMnu85MbJVszEGJCrc_0sbxWNAnwhPnnwD6ki0Nzo,4928 +ansible/modules/clustering/k8s/_k8s_raw.pyc,, +ansible/modules/clustering/k8s/_kubernetes.py,sha256=4OuOem4BMX0Kbuj_u9H6as4GuJjbb1-bY7VMS4HiV90,16556 +ansible/modules/clustering/k8s/_kubernetes.pyc,, +ansible/modules/clustering/k8s/k8s.py,sha256=UMwMnu85MbJVszEGJCrc_0sbxWNAnwhPnnwD6ki0Nzo,4928 +ansible/modules/clustering/k8s/k8s.pyc,, +ansible/modules/clustering/k8s/k8s_facts.py,sha256=SWf4FL3mZn8PK7pHEaDTiqJSDgjtrPuVM7UPjUvlvXQ,4809 +ansible/modules/clustering/k8s/k8s_facts.pyc,, +ansible/modules/clustering/k8s/k8s_scale.py,sha256=Dw0EHrzgk_2auyfpfzS-M14bfDJSf9muXJoFuUnB3qA,3328 +ansible/modules/clustering/k8s/k8s_scale.pyc,, +ansible/modules/clustering/openshift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/clustering/openshift/__init__.pyc,, +ansible/modules/clustering/openshift/_oc.py,sha256=bh4lYoT9U91WcuQeyxL4-LTB8Hi5mIoUeXR6EHim8Gs,14983 +ansible/modules/clustering/openshift/_oc.pyc,, +ansible/modules/clustering/openshift/_openshift_raw.py,sha256=UMwMnu85MbJVszEGJCrc_0sbxWNAnwhPnnwD6ki0Nzo,4928 +ansible/modules/clustering/openshift/_openshift_raw.pyc,, +ansible/modules/clustering/openshift/_openshift_scale.py,sha256=Dw0EHrzgk_2auyfpfzS-M14bfDJSf9muXJoFuUnB3qA,3328 +ansible/modules/clustering/openshift/_openshift_scale.pyc,, +ansible/modules/clustering/pacemaker_cluster.py,sha256=xPxfg9znTU0kBSEnwTx7tIshYOygSTzShVS_jTnxOPs,7080 +ansible/modules/clustering/pacemaker_cluster.pyc,, +ansible/modules/clustering/znode.py,sha256=_b2yGxG3YXAzHwYVCyrwkTUf_e8qtucXRq-FbIAnvbQ,7599 +ansible/modules/clustering/znode.pyc,, +ansible/modules/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/commands/__init__.pyc,, +ansible/modules/commands/command.py,sha256=hGA_49iS24zBzwMCKmX223xIAZLYq3V6wHaSY2gE220,10320 +ansible/modules/commands/command.pyc,, +ansible/modules/commands/expect.py,sha256=KoU34e4nBkAKO7uqbRWNJTshb-aMUJ97QK0L1HE4K28,7569 +ansible/modules/commands/expect.pyc,, +ansible/modules/commands/psexec.py,sha256=I-ZW6Fgw38Kh-yxWPNjONhiVOrOdYNjOksQrBH_0jPg,19126 +ansible/modules/commands/psexec.pyc,, +ansible/modules/commands/raw.py,sha256=46pGdGfDEraepQSlQbP-PnZx9FFwa_io48KAWHUFge0,3052 +ansible/modules/commands/raw.pyc,, +ansible/modules/commands/script.py,sha256=W4zPsle-eGamvY846gDxhq_izYDFWHGMzKL9yzuIaZ8,3103 +ansible/modules/commands/script.pyc,, +ansible/modules/commands/shell.py,sha256=ogNOiS_sFfJLSOSYLW_iG76UU0Q2eSE9CbMdR0Wqtow,6017 +ansible/modules/commands/shell.pyc,, +ansible/modules/commands/telnet.py,sha256=zFBNxaeTfShDXX37Sxt9BNWersiu3OGekw6dzNTE0-Y,2788 +ansible/modules/commands/telnet.pyc,, +ansible/modules/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/crypto/__init__.pyc,, +ansible/modules/crypto/acme/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/crypto/acme/__init__.pyc,, +ansible/modules/crypto/acme/_letsencrypt.py,sha256=QNgShSX6SPWNSuhgK-CvvmezZmO0GYqvRk4CT3dQico,40625 +ansible/modules/crypto/acme/_letsencrypt.pyc,, +ansible/modules/crypto/acme/acme_account.py,sha256=w9HAWTbhFWfhWFG9D9suqJ_Rg37X7F_EVQ2zuSJBS6I,10284 +ansible/modules/crypto/acme/acme_account.pyc,, +ansible/modules/crypto/acme/acme_account_facts.py,sha256=0Ik6YMvVX9JOBCG505q2Q1UbhhDRhHDiSxGO3JMRO44,5181 +ansible/modules/crypto/acme/acme_account_facts.pyc,, +ansible/modules/crypto/acme/acme_certificate.py,sha256=QNgShSX6SPWNSuhgK-CvvmezZmO0GYqvRk4CT3dQico,40625 +ansible/modules/crypto/acme/acme_certificate.pyc,, +ansible/modules/crypto/acme/acme_certificate_revoke.py,sha256=RfRszitTCuk7fuygEdvjzGReY9kQkmEdfgcCumPx4DE,9759 +ansible/modules/crypto/acme/acme_certificate_revoke.pyc,, +ansible/modules/crypto/acme/acme_challenge_cert_helper.py,sha256=dDn2bdSROy2l7K_t4ZUsq4cdV0joCCerhali9384L9g,9512 +ansible/modules/crypto/acme/acme_challenge_cert_helper.pyc,, +ansible/modules/crypto/certificate_complete_chain.py,sha256=5MQx4qRmvxJ85NjZ4AozgeSD5VhSv6NuvXb8HzJKFxs,12444 +ansible/modules/crypto/certificate_complete_chain.pyc,, +ansible/modules/crypto/openssl_certificate.py,sha256=zejkqYxXwq0zGgSLJW5ptRfKh5MY1ZUXDwNwE-HAeAM,47966 +ansible/modules/crypto/openssl_certificate.pyc,, +ansible/modules/crypto/openssl_csr.py,sha256=x6LTK-DuNveXk5e28Zx0AGfGWbpoxQtPLbFh25JfSmc,25937 +ansible/modules/crypto/openssl_csr.pyc,, +ansible/modules/crypto/openssl_dhparam.py,sha256=fAr9vN6953CsW-MVp9K8hkdZldDTaPB4KAcTKGkRDdo,7266 +ansible/modules/crypto/openssl_dhparam.pyc,, +ansible/modules/crypto/openssl_pkcs12.py,sha256=YUoSMaWoJSB-uWzyCQ7diAAXq4dnj9zQAA_eJxMvjSk,11048 +ansible/modules/crypto/openssl_pkcs12.pyc,, +ansible/modules/crypto/openssl_privatekey.py,sha256=2qxRVyPe3IixISyM4m1DLq0H9r5HGgTIj5u-Ypx6eNk,9545 +ansible/modules/crypto/openssl_privatekey.pyc,, +ansible/modules/crypto/openssl_publickey.py,sha256=I40TT8UalG1ogHogj359Nu514D_QE_NSOvB57WyZjwc,11001 +ansible/modules/crypto/openssl_publickey.pyc,, +ansible/modules/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/__init__.pyc,, +ansible/modules/database/influxdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/influxdb/__init__.pyc,, +ansible/modules/database/influxdb/influxdb_database.py,sha256=tkvgzlw4K_v2LCMXHGwIdxTp-7KdloTGPY-ShXIBP0w,3747 +ansible/modules/database/influxdb/influxdb_database.pyc,, +ansible/modules/database/influxdb/influxdb_query.py,sha256=ci6KoVleM1C1eearu7idpnhYXUxh7eSldljE63JeUj8,2642 +ansible/modules/database/influxdb/influxdb_query.pyc,, +ansible/modules/database/influxdb/influxdb_retention_policy.py,sha256=d-95rNiNet8yV9gdkcd4YnNHa-VMHT4-QjO9-eZZbig,5923 +ansible/modules/database/influxdb/influxdb_retention_policy.pyc,, +ansible/modules/database/influxdb/influxdb_user.py,sha256=EoL4dumsuueZW8SOa_Tgu4Zhr4dcGbO8Rj6yEW9ge7U,5353 +ansible/modules/database/influxdb/influxdb_user.pyc,, +ansible/modules/database/influxdb/influxdb_write.py,sha256=RGVLsiolMHas5u_qtLrXJUQ99E3IDafKSMOWgHqb110,2493 +ansible/modules/database/influxdb/influxdb_write.pyc,, +ansible/modules/database/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/misc/__init__.pyc,, +ansible/modules/database/misc/elasticsearch_plugin.py,sha256=UAkvVjgOIwup4jwMCmLxfaWGE-Mlm-fE90ejvnLJJ3Y,9640 +ansible/modules/database/misc/elasticsearch_plugin.pyc,, +ansible/modules/database/misc/kibana_plugin.py,sha256=GHlkOepgHq6_DhyYNl1nkkxDpOctk_OLQdMOYkRYwY8,6303 +ansible/modules/database/misc/kibana_plugin.pyc,, +ansible/modules/database/misc/redis.py,sha256=1pFEnWbJD2rzXJK8TzmKHqez-mDfHIPWXY627SI6hxw,9760 +ansible/modules/database/misc/redis.pyc,, +ansible/modules/database/misc/riak.py,sha256=Gfaq9kcRzu-7A7UaNiaxcy6w4gDEzVM6FZb_LmZqwNc,7213 +ansible/modules/database/misc/riak.pyc,, +ansible/modules/database/mongodb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/mongodb/__init__.pyc,, +ansible/modules/database/mongodb/mongodb_parameter.py,sha256=RiqHT5vM31KSyj7j-6TaA-7NDZeQRs6MY5CU56TEvfE,6637 +ansible/modules/database/mongodb/mongodb_parameter.pyc,, +ansible/modules/database/mongodb/mongodb_user.py,sha256=oX1CyWJb3iQyq0_NLpjrCblWKtvk3y0Ix-9UtIPy454,15461 +ansible/modules/database/mongodb/mongodb_user.pyc,, +ansible/modules/database/mssql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/mssql/__init__.pyc,, +ansible/modules/database/mssql/mssql_db.py,sha256=ijHjtaQ-F9biAO83BT_9ExxudCgyLywxAmDjymXzv5w,6862 +ansible/modules/database/mssql/mssql_db.pyc,, +ansible/modules/database/mysql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/mysql/__init__.pyc,, +ansible/modules/database/mysql/mysql_db.py,sha256=Uz3gCZICeD6L19bGBGE7b3lCDJwTlpjWww-pO4VEzA0,15602 +ansible/modules/database/mysql/mysql_db.pyc,, +ansible/modules/database/mysql/mysql_replication.py,sha256=7cQQ-tF1NtgBlPsN8k2Se1aV_3LNFFxQYB6ykxnOLQc,12366 +ansible/modules/database/mysql/mysql_replication.pyc,, +ansible/modules/database/mysql/mysql_user.py,sha256=mr2ttAvbAYmdawBmGdLDCrJTh6Q0HhNdmnXvrxNOoFM,23438 +ansible/modules/database/mysql/mysql_user.pyc,, +ansible/modules/database/mysql/mysql_variables.py,sha256=FJQ23s8jdRyfawphbtKL2Jfl9EtnYjsxG0EO0iF3gv8,5543 +ansible/modules/database/mysql/mysql_variables.pyc,, +ansible/modules/database/postgresql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/postgresql/__init__.pyc,, +ansible/modules/database/postgresql/postgresql_db.py,sha256=jQvN2g0BSm2h4M8hlv6VJqdAyYkW3gXbL_7z7ou7Dvc,16571 +ansible/modules/database/postgresql/postgresql_db.pyc,, +ansible/modules/database/postgresql/postgresql_ext.py,sha256=0uJwqMyB_4kZUa9qfdREZLIg6fdof1C5pGgWDtuGRRk,5528 +ansible/modules/database/postgresql/postgresql_ext.pyc,, +ansible/modules/database/postgresql/postgresql_lang.py,sha256=FeKCJRFmChpbXqaPCFKoPIwGmPAxKq62fgjd9x6iFMA,9303 +ansible/modules/database/postgresql/postgresql_lang.pyc,, +ansible/modules/database/postgresql/postgresql_privs.py,sha256=QyS373eORqkShlPCGzTyM7jjSyMRs_cw1vNeykRdI0A,30461 +ansible/modules/database/postgresql/postgresql_privs.pyc,, +ansible/modules/database/postgresql/postgresql_schema.py,sha256=4EY_6Ht1YGmxME2wu0tu_1wl8JInTHIwSfVQ_aeEJb8,7989 +ansible/modules/database/postgresql/postgresql_schema.pyc,, +ansible/modules/database/postgresql/postgresql_user.py,sha256=_9HlZgV2Tb0Y7Q9f15LGHsb7N1XMcNX9q_EOMqKRywI,32608 +ansible/modules/database/postgresql/postgresql_user.pyc,, +ansible/modules/database/proxysql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/proxysql/__init__.pyc,, +ansible/modules/database/proxysql/proxysql_backend_servers.py,sha256=3GCRfdgAQyk144cwgaclUcGKiVMaB6TEzt7oo1tU7N8,17618 +ansible/modules/database/proxysql/proxysql_backend_servers.pyc,, +ansible/modules/database/proxysql/proxysql_global_variables.py,sha256=_QKc9NSAvq3zUWEAI8f2IbyzVCIlcKg5XKzFakS1dgw,8254 +ansible/modules/database/proxysql/proxysql_global_variables.pyc,, +ansible/modules/database/proxysql/proxysql_manage_config.py,sha256=JwV_CwMzItMvxxKRWaEAK0cANzRX7K1yGMfz2ZTw7mw,7756 +ansible/modules/database/proxysql/proxysql_manage_config.pyc,, +ansible/modules/database/proxysql/proxysql_mysql_users.py,sha256=8iQ2N_ZiuTyvgJeI0zapZkZYtX14VI-aDisxijZL86k,16081 +ansible/modules/database/proxysql/proxysql_mysql_users.pyc,, +ansible/modules/database/proxysql/proxysql_query_rules.py,sha256=mhYiMnuJU9bPD-AU6hyWRGCrZNwp4mpZ4gtb_55rxxA,21767 +ansible/modules/database/proxysql/proxysql_query_rules.pyc,, +ansible/modules/database/proxysql/proxysql_replication_hostgroups.py,sha256=1h2Mwjw52rY8csM-nDx_ZwJpG6h83p0FsGpJdQJcTIE,13353 +ansible/modules/database/proxysql/proxysql_replication_hostgroups.pyc,, +ansible/modules/database/proxysql/proxysql_scheduler.py,sha256=B5AfRNAYZdh8UteoLbSrAdO_JuQEGEGlWCO78YJJ-4c,13727 +ansible/modules/database/proxysql/proxysql_scheduler.pyc,, +ansible/modules/database/vertica/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/database/vertica/__init__.pyc,, +ansible/modules/database/vertica/vertica_configuration.py,sha256=QKIkXbNrqe84CwK_L5njJRD0mrbro70N-4RcXBD6ZXQ,6329 +ansible/modules/database/vertica/vertica_configuration.pyc,, +ansible/modules/database/vertica/vertica_facts.py,sha256=JnfjF_WNVgBy33KXSQ8TrNE-gphCe2s7crCjIWe9xlc,8958 +ansible/modules/database/vertica/vertica_facts.pyc,, +ansible/modules/database/vertica/vertica_role.py,sha256=WzKuNeCwOF8WAI71I31knnJkIXpSyGXTRHiIqtz92AU,7933 +ansible/modules/database/vertica/vertica_role.pyc,, +ansible/modules/database/vertica/vertica_schema.py,sha256=JxuBLskblz5oErOf1xt65EIvo7tFY85xsZEd5r1iVjA,11388 +ansible/modules/database/vertica/vertica_schema.pyc,, +ansible/modules/database/vertica/vertica_user.py,sha256=7s8VWsEWJCfVQq4IL4V-IBYI89AuWbgwH_S-b_4T4gc,14081 +ansible/modules/database/vertica/vertica_user.pyc,, +ansible/modules/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/files/__init__.pyc,, +ansible/modules/files/acl.py,sha256=HoNF8CRIKGJqrjjrpo1ne7VMdaC_mnkOSWrGoB4PHNs,11964 +ansible/modules/files/acl.pyc,, +ansible/modules/files/archive.py,sha256=WxyN-J6vBpvWPaNEhfyHjOCONvf5Fl9y0LZpg9Kg08Q,17464 +ansible/modules/files/archive.pyc,, +ansible/modules/files/assemble.py,sha256=ClIfJQ8sEo3iEiflBdg8xPeIZK-hzOvbiboxOoB7s5c,8351 +ansible/modules/files/assemble.pyc,, +ansible/modules/files/blockinfile.py,sha256=wAVtsWKqYzuo0GLbiOs2Up8bggNCYAO_C0GR-4Iwfmo,11618 +ansible/modules/files/blockinfile.pyc,, +ansible/modules/files/copy.py,sha256=1v74IysvwLKh8iJsFIDXQQNVLbpn7OB56qfkz20e_VE,17645 +ansible/modules/files/copy.pyc,, +ansible/modules/files/fetch.py,sha256=3wonC5Rq7SXBKkrYkSe7PKXCY3qMMzo0ZLp8jidJMV4,3636 +ansible/modules/files/fetch.pyc,, +ansible/modules/files/file.py,sha256=wDOxS1InA8CWMfjD7FhPVzeq1DsGfc9njoamWWaxCC4,37332 +ansible/modules/files/file.pyc,, +ansible/modules/files/find.py,sha256=z4WBHlH_VoGEhp1QQJa8991BnlcrMGGu4XkVfR6i2Q8,15269 +ansible/modules/files/find.pyc,, +ansible/modules/files/ini_file.py,sha256=KNtfjrtzR6JThPr08j4vvwdslnvfouD0UMah4OwF5DM,11941 +ansible/modules/files/ini_file.pyc,, +ansible/modules/files/iso_extract.py,sha256=BWe-kbtgVPdf4VF7CTyG-J2ziLINIlZ9WR1JsEHLII4,6645 +ansible/modules/files/iso_extract.pyc,, +ansible/modules/files/lineinfile.py,sha256=hgNL6xJnmi7DwfiAeE41RRxph06zhXz0REp04ZDbnbA,19084 +ansible/modules/files/lineinfile.pyc,, +ansible/modules/files/patch.py,sha256=S_W6DKgdzXcj5ub9WSbp84pQLQJ-kDZKepkwveZMwlg,6754 +ansible/modules/files/patch.pyc,, +ansible/modules/files/replace.py,sha256=93Q-Vr0ggN7rvuNgKW7Yfr0LbVfqPP1Z5V9yANtthqY,10884 +ansible/modules/files/replace.pyc,, +ansible/modules/files/stat.py,sha256=5b1cMHUVlUQ_hrpgRv9JQEgQOJru66o5PUeRqO4DUak,19654 +ansible/modules/files/stat.pyc,, +ansible/modules/files/synchronize.py,sha256=-34rrvafqi00nAJXdrWehUUjW-6agXvKYZN8J5uE5gE,20402 +ansible/modules/files/synchronize.pyc,, +ansible/modules/files/tempfile.py,sha256=85ObYIiMgoqMYlN_XtC2d-aA_Hnh2kRy1cNSwMurDvI,3141 +ansible/modules/files/tempfile.pyc,, +ansible/modules/files/template.py,sha256=NH2nf_BXb1U_G5r18X8I3n2Xhn4p9skauHSmWGD4_WQ,6786 +ansible/modules/files/template.pyc,, +ansible/modules/files/unarchive.py,sha256=jIaoHmdH0v9lMUHUKiwYCP00aexh-6BL99pWYxBjxKU,35875 +ansible/modules/files/unarchive.pyc,, +ansible/modules/files/xattr.py,sha256=8FMHgR8yapQwZswcOpweFo-1hxbTHTikYZSXJwh25VY,6842 +ansible/modules/files/xattr.pyc,, +ansible/modules/files/xml.py,sha256=en3LX9ivicystZgqlMpmlFL1RyucTUifi51Gw4NgJEo,31805 +ansible/modules/files/xml.pyc,, +ansible/modules/identity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/identity/__init__.pyc,, +ansible/modules/identity/cyberark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/identity/cyberark/__init__.pyc,, +ansible/modules/identity/cyberark/cyberark_authentication.py,sha256=i3teqTXxlAuiKDgSHJqrHs2Mwrcgnjmt__F-sQCO5iw,10846 +ansible/modules/identity/cyberark/cyberark_authentication.pyc,, +ansible/modules/identity/cyberark/cyberark_user.py,sha256=FZMOB1rWjsSOq8S9LsPY5wABK1wKqcY_LBwrOuxeCNg,16083 +ansible/modules/identity/cyberark/cyberark_user.pyc,, +ansible/modules/identity/ipa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/identity/ipa/__init__.pyc,, +ansible/modules/identity/ipa/ipa_config.py,sha256=m0PbEIBfWT2gTzMfhTQzG8Xc-AkHHmByaTplBQ8sWuI,4030 +ansible/modules/identity/ipa/ipa_config.pyc,, +ansible/modules/identity/ipa/ipa_dnsrecord.py,sha256=4vkAIjrTV4IE-iMm5qOWIbu71PhMgkpyMBLEHNt9H64,9619 +ansible/modules/identity/ipa/ipa_dnsrecord.pyc,, +ansible/modules/identity/ipa/ipa_dnszone.py,sha256=FlRDFroImHbIUXldKeiz92xOSvV6uPeLXNW5zj9Bmdk,3832 +ansible/modules/identity/ipa/ipa_dnszone.pyc,, +ansible/modules/identity/ipa/ipa_group.py,sha256=BUEurTWrBaFzzqNKA4e-PFNxlaF_0ITCiShWG42l9mY,8359 +ansible/modules/identity/ipa/ipa_group.pyc,, +ansible/modules/identity/ipa/ipa_hbacrule.py,sha256=jNUrb0CX49CDjtxUpDPVpRIaz9u-3PvpDsoDly4zJWk,13226 +ansible/modules/identity/ipa/ipa_hbacrule.pyc,, +ansible/modules/identity/ipa/ipa_host.py,sha256=iQQ7ndyz-R9wUd6DL1AYon_pDsqPclnGrVJMfC-V5B4,10421 +ansible/modules/identity/ipa/ipa_host.pyc,, +ansible/modules/identity/ipa/ipa_hostgroup.py,sha256=8PzhemDYyeQa_ZOPQgdTzY75rNW6Hhq1TZKxJOzidi8,7060 +ansible/modules/identity/ipa/ipa_hostgroup.pyc,, +ansible/modules/identity/ipa/ipa_role.py,sha256=wqRA-vJt7UoFZXuNfy4P1A71hJvyQYxk4f5nfKv1k8Y,10522 +ansible/modules/identity/ipa/ipa_role.pyc,, +ansible/modules/identity/ipa/ipa_service.py,sha256=C1R6u4Vlra_h-Ru5kTZzJC4gV64r9sxMKuZi0qKhYZw,6558 +ansible/modules/identity/ipa/ipa_service.pyc,, +ansible/modules/identity/ipa/ipa_subca.py,sha256=rGYdb0qXsfsvx2mvXpo7zP_FfnNxXF_VTK-oQooBGhE,7483 +ansible/modules/identity/ipa/ipa_subca.pyc,, +ansible/modules/identity/ipa/ipa_sudocmd.py,sha256=VIgM3A8z9ZHLa6OQ-IjJ6yj2bHAWg73UgqdNEBsKKnw,4596 +ansible/modules/identity/ipa/ipa_sudocmd.pyc,, +ansible/modules/identity/ipa/ipa_sudocmdgroup.py,sha256=AfQ-8dJd7Wb13B95bbyYWW8_0_5Fr8z6gru3h8ZmI-8,6070 +ansible/modules/identity/ipa/ipa_sudocmdgroup.pyc,, +ansible/modules/identity/ipa/ipa_sudorule.py,sha256=em6L5Hu_PX7ZAPkg5-zxJODt4H4qyaQWkBiYBotzvvc,15853 +ansible/modules/identity/ipa/ipa_sudorule.pyc,, +ansible/modules/identity/ipa/ipa_user.py,sha256=NI34qA-Cu_3cNpt-CNxDdVROP5BnEB1THgs3Ehdr2Nw,10973 +ansible/modules/identity/ipa/ipa_user.pyc,, +ansible/modules/identity/ipa/ipa_vault.py,sha256=K1A8fw9wZ0TEQaJD90pUF3xcp_vceHMbJY43WneGilk,7749 +ansible/modules/identity/ipa/ipa_vault.pyc,, +ansible/modules/identity/keycloak/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/identity/keycloak/__init__.pyc,, +ansible/modules/identity/keycloak/keycloak_client.py,sha256=2i_VnNhDX-kj3z245m1upv0sQc7rzuh895xgjLu24Vc,31840 +ansible/modules/identity/keycloak/keycloak_client.pyc,, +ansible/modules/identity/keycloak/keycloak_clienttemplate.py,sha256=VYabzJpdwhum5fPjhw8MOkl6YCiLIBLEzdui94QxxYw,15123 +ansible/modules/identity/keycloak/keycloak_clienttemplate.pyc,, +ansible/modules/identity/onepassword_facts.py,sha256=wtj-IXs1e3b6PCDO76ANLCTAhF7RhNgadpQB8PPLsSE,14065 +ansible/modules/identity/onepassword_facts.pyc,, +ansible/modules/identity/opendj/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/identity/opendj/__init__.pyc,, +ansible/modules/identity/opendj/opendj_backendprop.py,sha256=g-OHvHflMecNBEXsDUcJE6FJqjB8_v2M3JrGmBYwId0,6939 +ansible/modules/identity/opendj/opendj_backendprop.pyc,, +ansible/modules/inventory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/inventory/__init__.pyc,, +ansible/modules/inventory/add_host.py,sha256=6koVyzrKQY7dQYreKOfyWr6sSl1TiXEmGcbD5bI1sDk,2701 +ansible/modules/inventory/add_host.pyc,, +ansible/modules/inventory/group_by.py,sha256=gg9Cy9Mui69iBzDSzAFJa1IR_en5rlPWibUHSnz2oIM,1462 +ansible/modules/inventory/group_by.pyc,, +ansible/modules/messaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/messaging/__init__.pyc,, +ansible/modules/messaging/rabbitmq_binding.py,sha256=UldH4UyWAefGkalG2zZvgiH56FmH-7KKOnSTUdJLssU,9568 +ansible/modules/messaging/rabbitmq_binding.pyc,, +ansible/modules/messaging/rabbitmq_exchange.py,sha256=SQV7E2707ZfmuqA7J_-5p7IBy8PExu24DIMBepLv-Vk,6995 +ansible/modules/messaging/rabbitmq_exchange.pyc,, +ansible/modules/messaging/rabbitmq_parameter.py,sha256=NuIBMvYcQN1bUEIh9tJDMv2sn6iAR6IjNhzB-exVyKk,4420 +ansible/modules/messaging/rabbitmq_parameter.pyc,, +ansible/modules/messaging/rabbitmq_plugin.py,sha256=4ZgsQhjgX24n6c3iKsoy4KyXZfznpZlcYL_ADBpNCCs,4629 +ansible/modules/messaging/rabbitmq_plugin.pyc,, +ansible/modules/messaging/rabbitmq_policy.py,sha256=6Ok9SAFJUxJXs16pCLXcYp4cIgRhjYKnwSieuHhBUnA,4535 +ansible/modules/messaging/rabbitmq_policy.pyc,, +ansible/modules/messaging/rabbitmq_queue.py,sha256=ZsBQ-GV1c3BSRlMkXg95FWpw3-t7H0kHHW1RdtTrZZA,9692 +ansible/modules/messaging/rabbitmq_queue.pyc,, +ansible/modules/messaging/rabbitmq_user.py,sha256=Ib_KlMMW9Pb6L36NItWOYZUoVFYI2nqx4KbsmRQU5ls,10493 +ansible/modules/messaging/rabbitmq_user.pyc,, +ansible/modules/messaging/rabbitmq_vhost.py,sha256=qliBj3tZVAvSJBqBoTdJ0D3cWRxY_tJ1C1Q3I9qx9g8,3941 +ansible/modules/messaging/rabbitmq_vhost.pyc,, +ansible/modules/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/monitoring/__init__.pyc,, +ansible/modules/monitoring/airbrake_deployment.py,sha256=9ircZw6fcgCKiXeNwKVfto_lPrRFOA4cQT36tDgo10Q,3587 +ansible/modules/monitoring/airbrake_deployment.pyc,, +ansible/modules/monitoring/bigpanda.py,sha256=9_52cSZmLVSJadnR5x0ZUuiqd3tH8uDEuERg3XB7j40,5714 +ansible/modules/monitoring/bigpanda.pyc,, +ansible/modules/monitoring/circonus_annotation.py,sha256=BRHL9b1CFxb-0Iv9Sa01xtaXtWfp3_7mPZ9Syi7xnVM,7162 +ansible/modules/monitoring/circonus_annotation.pyc,, +ansible/modules/monitoring/datadog_event.py,sha256=in_fYB4TrjkZVQ_owbjQ80r1EfHsxFdsPEsDFbZVzrI,5077 +ansible/modules/monitoring/datadog_event.pyc,, +ansible/modules/monitoring/datadog_monitor.py,sha256=PjILVGpiECPQtjf6G93GDKuo3LnUcNR0K2rx35gRbqI,13669 +ansible/modules/monitoring/datadog_monitor.pyc,, +ansible/modules/monitoring/grafana_dashboard.py,sha256=C6_RWnyu09Eof7sPErYXk0qeA1M1gV3p0YldGrE3MSk,15172 +ansible/modules/monitoring/grafana_dashboard.pyc,, +ansible/modules/monitoring/grafana_datasource.py,sha256=lw0Kc__dxZpVNc4lEi0T4P3Lesf3H0qekAIp9cmoo2k,18929 +ansible/modules/monitoring/grafana_datasource.pyc,, +ansible/modules/monitoring/grafana_plugin.py,sha256=mlTb4eCWkwt24FbjhrxSLUtvS0vwkMLNbNRd_9Y7DPw,7426 +ansible/modules/monitoring/grafana_plugin.pyc,, +ansible/modules/monitoring/honeybadger_deployment.py,sha256=spNL54M2WeyAUFxxoSqhxBtNxA634ylEO-nhqBUZQso,3646 +ansible/modules/monitoring/honeybadger_deployment.pyc,, +ansible/modules/monitoring/icinga2_feature.py,sha256=l74bNbMALpU1TtDYOEGYm2b5LaS6alduGnYKHV6Rae0,4294 +ansible/modules/monitoring/icinga2_feature.pyc,, +ansible/modules/monitoring/icinga2_host.py,sha256=wrGY8pLzn-s4308AoFEepvLSiPpwYioM5yKI6zcqpMI,10047 +ansible/modules/monitoring/icinga2_host.pyc,, +ansible/modules/monitoring/librato_annotation.py,sha256=i1wjLv7Kur_pXALCz8_DFucxf01bfnnoMf6L1qcZAh4,5249 +ansible/modules/monitoring/librato_annotation.pyc,, +ansible/modules/monitoring/logentries.py,sha256=ILU5jRX6SUnk2Y8dQ_XcQyxQb2ZjygHAVoF3YkXoShw,4339 +ansible/modules/monitoring/logentries.pyc,, +ansible/modules/monitoring/logicmonitor.py,sha256=61mG-sZddya7ZkJk8ZajDoxvmUoV0H3OWAY_2E3N764,73767 +ansible/modules/monitoring/logicmonitor.pyc,, +ansible/modules/monitoring/logicmonitor_facts.py,sha256=uVApsI_XWQMQicFvl_wkBmKdKIe3zKj8v7Hxp_Sn0RQ,19997 +ansible/modules/monitoring/logicmonitor_facts.pyc,, +ansible/modules/monitoring/logstash_plugin.py,sha256=M8GLapN0xK2pz-Pq8lt77obxB1AuWq_UJOfa92Pvhs0,4568 +ansible/modules/monitoring/logstash_plugin.pyc,, +ansible/modules/monitoring/monit.py,sha256=o70YhWQHrF48ZabefxVZruh7n-1GvTH5ri0cIwSY8V0,7631 +ansible/modules/monitoring/monit.pyc,, +ansible/modules/monitoring/nagios.py,sha256=q4VERDBa8uxQkE2XTLxZ_zLmaIPMpFTViF8wC6HoChs,36216 +ansible/modules/monitoring/nagios.pyc,, +ansible/modules/monitoring/newrelic_deployment.py,sha256=JcDoU3QO-fM3miOZ__eX_gHMS_7sP8iKJKV2jYNy8Ww,4358 +ansible/modules/monitoring/newrelic_deployment.pyc,, +ansible/modules/monitoring/pagerduty.py,sha256=SWl2M9XSsyAu6uSimaBebkLzVqYPvOeScmTT8Q4KxHE,8404 +ansible/modules/monitoring/pagerduty.pyc,, +ansible/modules/monitoring/pagerduty_alert.py,sha256=IBjv1pSZ7rrL7ZgY4sTRh9TRToi0fH7DwbXZSz-yHBY,8678 +ansible/modules/monitoring/pagerduty_alert.pyc,, +ansible/modules/monitoring/pingdom.py,sha256=kQFxiGvQjmIib8Vzldd8CV4ydXpQlSF9g34_4H-jDFU,3626 +ansible/modules/monitoring/pingdom.pyc,, +ansible/modules/monitoring/rollbar_deployment.py,sha256=XEspl7_YtZ2SVSRmVcLRQNFBuLck3i5aFkLhn6xZ_Vs,3691 +ansible/modules/monitoring/rollbar_deployment.pyc,, +ansible/modules/monitoring/sensu_check.py,sha256=kjeuytS31RLNV1tzXi-631RHCDekz5gCgiMltD8k0xM,12707 +ansible/modules/monitoring/sensu_check.pyc,, +ansible/modules/monitoring/sensu_client.py,sha256=GwZ6B3t4xKtzx6_-3W93KPhYbIm0916dr7OgR35vmRI,8980 +ansible/modules/monitoring/sensu_client.pyc,, +ansible/modules/monitoring/sensu_handler.py,sha256=fdmrhfgzCnYN0Fa_YnpidBnEYbwwo0RaC9y7ZX3iDvE,9201 +ansible/modules/monitoring/sensu_handler.pyc,, +ansible/modules/monitoring/sensu_silence.py,sha256=4VE014tjwVH3CFbumDUzUMQK_Y-jCpB8TEBYd93wiGk,8475 +ansible/modules/monitoring/sensu_silence.pyc,, +ansible/modules/monitoring/sensu_subscription.py,sha256=kf6H1sbDwHLxNVOiOW37pywutqUubPZgmgjuxlbWc5A,4896 +ansible/modules/monitoring/sensu_subscription.pyc,, +ansible/modules/monitoring/spectrum_device.py,sha256=oT9ADughsZqlJFsOMlYTRxYoDgpFWOffrG0d3kjYBP8,10638 +ansible/modules/monitoring/spectrum_device.pyc,, +ansible/modules/monitoring/stackdriver.py,sha256=Tz5gHxR3Ds9CsyL9R1TP6IgdqOL_cK5O4P22jG__ro4,6450 +ansible/modules/monitoring/stackdriver.pyc,, +ansible/modules/monitoring/statusio_maintenance.py,sha256=TylkHAfzJ1iQSwqZnYA-4iQrRv40hUBR4dzdV_WOPb4,16873 +ansible/modules/monitoring/statusio_maintenance.pyc,, +ansible/modules/monitoring/uptimerobot.py,sha256=h1CNYpuvW8nEgatuuQ7yOzQ5poWtrkdYEbsJf8YTAg8,3712 +ansible/modules/monitoring/uptimerobot.pyc,, +ansible/modules/monitoring/zabbix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/monitoring/zabbix/__init__.pyc,, +ansible/modules/monitoring/zabbix/zabbix_group.py,sha256=xZnXusaMnIo2benKzEGlIigbs7n7Nt_LqQMIP8m1YrM,6570 +ansible/modules/monitoring/zabbix/zabbix_group.pyc,, +ansible/modules/monitoring/zabbix/zabbix_group_facts.py,sha256=eZgAijGcfrRvdz_s1a1MABtaqbeZJlmBwUbS6TUi5rI,4403 +ansible/modules/monitoring/zabbix/zabbix_group_facts.pyc,, +ansible/modules/monitoring/zabbix/zabbix_host.py,sha256=byjPK-bSBk_hCE2LjF4uPskWQcOXXiHa42dw2xDcLrs,37008 +ansible/modules/monitoring/zabbix/zabbix_host.pyc,, +ansible/modules/monitoring/zabbix/zabbix_host_facts.py,sha256=2I28KzX9z_eQHQpereEngWtOyjy2BiVH1MBW0pq3LII,7306 +ansible/modules/monitoring/zabbix/zabbix_host_facts.pyc,, +ansible/modules/monitoring/zabbix/zabbix_hostmacro.py,sha256=00Csz3FWG4Ro9V_fPAEul7kq3nMUVEwRZ7GrunkuCbQ,8600 +ansible/modules/monitoring/zabbix/zabbix_hostmacro.pyc,, +ansible/modules/monitoring/zabbix/zabbix_maintenance.py,sha256=ieyScuaXlwLWN0kvvVIhwDhPxzQUNuEzccq2SJeXpSc,12826 +ansible/modules/monitoring/zabbix/zabbix_maintenance.pyc,, +ansible/modules/monitoring/zabbix/zabbix_proxy.py,sha256=93dW7dYxbHyN14acr1g8uyI4yIOZEguwBg1Dd-0DOAw,12457 +ansible/modules/monitoring/zabbix/zabbix_proxy.pyc,, +ansible/modules/monitoring/zabbix/zabbix_screen.py,sha256=J_7T_nwR9-PRogunLBLpLDoFNGQYTre60kl9uJebvi8,17257 +ansible/modules/monitoring/zabbix/zabbix_screen.pyc,, +ansible/modules/monitoring/zabbix/zabbix_template.py,sha256=wVK5GshAJZYg8CFan3_IBo1QvXd9IdNJ6UF-FFC_FiI,19439 +ansible/modules/monitoring/zabbix/zabbix_template.pyc,, +ansible/modules/net_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/net_tools/__init__.pyc,, +ansible/modules/net_tools/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/net_tools/basics/__init__.pyc,, +ansible/modules/net_tools/basics/get_url.py,sha256=bxKZ7C8gr_2l16iRQbYyuMrDrfkQXZtmjXUxpb-y9Po,22693 +ansible/modules/net_tools/basics/get_url.pyc,, +ansible/modules/net_tools/basics/slurp.py,sha256=VPfKNBGrGmp48hCY35VCYDurABKubJgKbKG2fBprerE,2371 +ansible/modules/net_tools/basics/slurp.pyc,, +ansible/modules/net_tools/basics/uri.py,sha256=Hg9exlYdSSbGg3ql0AJvk8RLgbCYo41DkZPMVi7vrY4,21457 +ansible/modules/net_tools/basics/uri.pyc,, +ansible/modules/net_tools/cloudflare_dns.py,sha256=4E_EvJXCvoDOtSybXEdgra6-bfYfnltBogFTgWzrrEg,33473 +ansible/modules/net_tools/cloudflare_dns.pyc,, +ansible/modules/net_tools/dnsimple.py,sha256=Yq97RSx0GRi8ubR0gJCsixQ4Ofb3ulfa0CnxAg4BIAM,11868 +ansible/modules/net_tools/dnsimple.pyc,, +ansible/modules/net_tools/dnsmadeeasy.py,sha256=rN-cFxLXcvvxVfG9N1R3I2Rn7j-a69dSR_hpMBuHS4Y,23583 +ansible/modules/net_tools/dnsmadeeasy.pyc,, +ansible/modules/net_tools/exoscale/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/net_tools/exoscale/__init__.pyc,, +ansible/modules/net_tools/exoscale/exo_dns_domain.py,sha256=jDLoNPiRK9ubm0QXk6Pc8WzKt7vEz6ABrEkXbU5k8KU,5831 +ansible/modules/net_tools/exoscale/exo_dns_domain.pyc,, +ansible/modules/net_tools/exoscale/exo_dns_record.py,sha256=ef9A0p0bYXKRnLBE_wdRCfAPcR3Vd09_aiMCHOrhIUE,9700 +ansible/modules/net_tools/exoscale/exo_dns_record.pyc,, +ansible/modules/net_tools/haproxy.py,sha256=Rsp86GIKL4o4lnSk52qQb18UNQeHJ2dYkG5vUh0Qoc8,16289 +ansible/modules/net_tools/haproxy.pyc,, +ansible/modules/net_tools/infinity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/net_tools/infinity/__init__.pyc,, +ansible/modules/net_tools/infinity/infinity.py,sha256=ObLIXyyPZmFQsjuoBOccCmcDHAlBTQk-XmAixl3zjQQ,22383 +ansible/modules/net_tools/infinity/infinity.pyc,, +ansible/modules/net_tools/ip_netns.py,sha256=3zJ4dVBd4bBSfX1pU0N1pIJla0VQdZxXE1aMK4kBpTI,4044 +ansible/modules/net_tools/ip_netns.pyc,, +ansible/modules/net_tools/ipify_facts.py,sha256=wXepuSADXHJt7yfSM6702jUbv1cO7tyjK0s6E7Ee2sM,2944 +ansible/modules/net_tools/ipify_facts.pyc,, +ansible/modules/net_tools/ipinfoio_facts.py,sha256=_mEc-bPLM7mhKc1rjGYLKoHozS6xEktfMBg8ybzVToQ,3611 +ansible/modules/net_tools/ipinfoio_facts.pyc,, +ansible/modules/net_tools/ldap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/net_tools/ldap/__init__.pyc,, +ansible/modules/net_tools/ldap/ldap_attr.py,sha256=7lje3jBqkPub-FVQn6w0QosG6bov42i3IAS7hpryH4k,8466 +ansible/modules/net_tools/ldap/ldap_attr.pyc,, +ansible/modules/net_tools/ldap/ldap_entry.py,sha256=7k3XGqeXyGi4-LxXeIGKDUUVcPA5lNIMY8qFSkrt3b8,7230 +ansible/modules/net_tools/ldap/ldap_entry.pyc,, +ansible/modules/net_tools/ldap/ldap_passwd.py,sha256=324psr5nZiaWpH2yHuop4WlZcfdfF63mcEwfYLSFibY,3822 +ansible/modules/net_tools/ldap/ldap_passwd.pyc,, +ansible/modules/net_tools/lldp.py,sha256=0iTW6LfP4Ez6pseELgNziGQuppJc8Rz8nv7XwK6CO5o,2499 +ansible/modules/net_tools/lldp.pyc,, +ansible/modules/net_tools/netcup_dns.py,sha256=NrBZXh131ouYqEesd0-OwZHfG3ieGC1vPMOA2KdIcxU,7419 +ansible/modules/net_tools/netcup_dns.pyc,, +ansible/modules/net_tools/nios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/net_tools/nios/__init__.pyc,, +ansible/modules/net_tools/nios/nios_a_record.py,sha256=R9thnnEuiUEhPCXMZR1zuW_zHA17g4Xu0g_6COyYjsI,4053 +ansible/modules/net_tools/nios/nios_a_record.pyc,, +ansible/modules/net_tools/nios/nios_aaaa_record.py,sha256=owD_0UWYW_gRrcE-WO3EXQZK1KRr1KhHldaXUhVU5zc,4188 +ansible/modules/net_tools/nios/nios_aaaa_record.pyc,, +ansible/modules/net_tools/nios/nios_cname_record.py,sha256=_LjlyRGqKk6hNnhR7ZpQzMkQTETc2gyIu_gm6JLrosA,4168 +ansible/modules/net_tools/nios/nios_cname_record.pyc,, +ansible/modules/net_tools/nios/nios_dns_view.py,sha256=PDTZ8CHEEultBkzHpbimCp2VcdOfAf8iZ2LaoeJFihw,4192 +ansible/modules/net_tools/nios/nios_dns_view.pyc,, +ansible/modules/net_tools/nios/nios_host_record.py,sha256=1eBFm3-eMWpg8DCXrj3-A7kvgEIJmlfIGSYXqtBOso8,8805 +ansible/modules/net_tools/nios/nios_host_record.pyc,, +ansible/modules/net_tools/nios/nios_mx_record.py,sha256=PkNTwDAih1wtjn4gPDhiEFsz5agTgC5NedA8f5Ii_w0,4314 +ansible/modules/net_tools/nios/nios_mx_record.pyc,, +ansible/modules/net_tools/nios/nios_naptr_record.py,sha256=l-2kltv41OGwN8NtqBJ0TY-nYyVb5B5g0mgbvUe16Oo,5884 +ansible/modules/net_tools/nios/nios_naptr_record.pyc,, +ansible/modules/net_tools/nios/nios_network.py,sha256=RxuwnKb0ZNHNv73WgP9nhbCAn63GU11g6bbZTmzN2-o,7988 +ansible/modules/net_tools/nios/nios_network.pyc,, +ansible/modules/net_tools/nios/nios_network_view.py,sha256=ZaVOChIwyeCACyA0IJI3FLNBGbatfFXs9FW2l_qq09c,3871 +ansible/modules/net_tools/nios/nios_network_view.pyc,, +ansible/modules/net_tools/nios/nios_ptr_record.py,sha256=8H4meVM83rMxD8ueffuC7wPpPJXZqFL2zt4D6Q_DZzM,4645 +ansible/modules/net_tools/nios/nios_ptr_record.pyc,, +ansible/modules/net_tools/nios/nios_srv_record.py,sha256=dFyvGtfhXolUCexYGhB_G----R56gmC_2VOaFx7kldk,4710 +ansible/modules/net_tools/nios/nios_srv_record.pyc,, +ansible/modules/net_tools/nios/nios_txt_record.py,sha256=Y14GF1aI_mMd1i5UDvTdNmK8cxJItntKwEMyjqQzoiU,3904 +ansible/modules/net_tools/nios/nios_txt_record.pyc,, +ansible/modules/net_tools/nios/nios_zone.py,sha256=TW2URZZohKV5T6O-xvpzUFEEiwXrSSfUuTuSfgU1lKs,6891 +ansible/modules/net_tools/nios/nios_zone.pyc,, +ansible/modules/net_tools/nmcli.py,sha256=qQRoxObJqihvWf8hGya8g3HTXkviKfL3o-PcoZnnLR8,46439 +ansible/modules/net_tools/nmcli.pyc,, +ansible/modules/net_tools/nsupdate.py,sha256=uwHexatUuDdbExNhSUdX65mEU1RmfJ-kHPy-f1Su0JU,14085 +ansible/modules/net_tools/nsupdate.pyc,, +ansible/modules/net_tools/omapi_host.py,sha256=Rd_qLaDkipWYYpmxnLXyHQPrB7ZM2w-6omd1Lln4HWU,11809 +ansible/modules/net_tools/omapi_host.pyc,, +ansible/modules/net_tools/snmp_facts.py,sha256=0HJ0R5WkfQYXkqp1lV1t18dv6z-ciHh40wJgipIAFTs,15054 +ansible/modules/net_tools/snmp_facts.pyc,, +ansible/modules/network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/__init__.pyc,, +ansible/modules/network/a10/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/a10/__init__.pyc,, +ansible/modules/network/a10/a10_server.py,sha256=_5OZRKvdmztu2tTunBbuLdDfn5fmtawaW8Bl519Oql0,10778 +ansible/modules/network/a10/a10_server.pyc,, +ansible/modules/network/a10/a10_server_axapi3.py,sha256=s4Aw34MIHZ0Em7Axappfsnj1ayaoCBaGlFI23lAJ7ng,8970 +ansible/modules/network/a10/a10_server_axapi3.pyc,, +ansible/modules/network/a10/a10_service_group.py,sha256=b63NDQSGnD46xNpXe_lkGi7Dvye_OOs7wljlhUpvY1U,13221 +ansible/modules/network/a10/a10_service_group.pyc,, +ansible/modules/network/a10/a10_virtual_server.py,sha256=fs6UoJc2Hdlc1V75WA0REpMUQuxN7KuR_Y_6l6maWic,11177 +ansible/modules/network/a10/a10_virtual_server.pyc,, +ansible/modules/network/aci/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/aci/__init__.pyc,, +ansible/modules/network/aci/_aci_intf_policy_fc.py,sha256=4bpxD4ku7td7YzVh-8PBcUevEh5SWom9KxZ6ctjuu2Q,6142 +ansible/modules/network/aci/_aci_intf_policy_fc.pyc,, +ansible/modules/network/aci/_aci_intf_policy_l2.py,sha256=Q1KBij-n3JduxtrqKV0AWaPR5dNdCy_04XPMYvnCbck,7055 +ansible/modules/network/aci/_aci_intf_policy_l2.pyc,, +ansible/modules/network/aci/_aci_intf_policy_lldp.py,sha256=5wfFENFkN8Y6ufdx6N8PS6oQtLNs25hX-FgqLryhXAA,6599 +ansible/modules/network/aci/_aci_intf_policy_lldp.pyc,, +ansible/modules/network/aci/_aci_intf_policy_mcp.py,sha256=iYzMZYQqs_i8uiX712KuAU8_B1OeePVemyR0ajaeNvE,6090 +ansible/modules/network/aci/_aci_intf_policy_mcp.pyc,, +ansible/modules/network/aci/_aci_intf_policy_port_channel.py,sha256=MTYwWf9dttvOqm2MJ3ic3TJDf7YOPmIKWjen1wdyTGk,9753 +ansible/modules/network/aci/_aci_intf_policy_port_channel.pyc,, +ansible/modules/network/aci/_aci_intf_policy_port_security.py,sha256=CRG6jyZaxL_q8hpBjtAky5d6WMMqPlJy_zDTBkdhuWE,6396 +ansible/modules/network/aci/_aci_intf_policy_port_security.pyc,, +ansible/modules/network/aci/aci_aaa_user.py,sha256=Y43x4c3vmkjpc1GcMHC1R6tvnw75ffBT5qgBYWp1SO0,10003 +ansible/modules/network/aci/aci_aaa_user.pyc,, +ansible/modules/network/aci/aci_aaa_user_certificate.py,sha256=L_WF3KDpzlLs0UBj0zd3IDcWI71wh3Wn3Cx7T76lpG4,7856 +ansible/modules/network/aci/aci_aaa_user_certificate.pyc,, +ansible/modules/network/aci/aci_access_port_to_interface_policy_leaf_profile.py,sha256=czu_al0-cXy3vuBRl9Ot7Uo6_hpXIfpC78jckFp_384,11809 +ansible/modules/network/aci/aci_access_port_to_interface_policy_leaf_profile.pyc,, +ansible/modules/network/aci/aci_aep.py,sha256=mQbBtIR-J54FaVo3gpEa-M2H7HVyzQqGkz7lO8gR5W0,7041 +ansible/modules/network/aci/aci_aep.pyc,, +ansible/modules/network/aci/aci_aep_to_domain.py,sha256=FLazg3c0XSHuM8uao8xK0aK3MZLNAYLfZeXIQOImW4s,8861 +ansible/modules/network/aci/aci_aep_to_domain.pyc,, +ansible/modules/network/aci/aci_ap.py,sha256=YBUG_dpwHKCnoDPJWycGNk78SqfQd1uSNHyBws_7l5s,6939 +ansible/modules/network/aci/aci_ap.pyc,, +ansible/modules/network/aci/aci_bd.py,sha256=oC9E9ZJbVGEJ6-abhyy1rs-HI7VsOmYjIbupMpRzxcU,14800 +ansible/modules/network/aci/aci_bd.pyc,, +ansible/modules/network/aci/aci_bd_subnet.py,sha256=ogQ3FZf3SJSedfoHNeRAcEBcB1aoUMdg19MBVRY7p6k,13290 +ansible/modules/network/aci/aci_bd_subnet.pyc,, +ansible/modules/network/aci/aci_bd_to_l3out.py,sha256=divn-9bSP9HtHuRV2ifMMwmn7O3AEgBf8efZIo-bGl0,6334 +ansible/modules/network/aci/aci_bd_to_l3out.pyc,, +ansible/modules/network/aci/aci_config_rollback.py,sha256=oRXYGm_YgQPahY8RmTDLhpibv5J4zhIHiWgavI3Wfeo,9565 +ansible/modules/network/aci/aci_config_rollback.pyc,, +ansible/modules/network/aci/aci_config_snapshot.py,sha256=0rAkqTusDqdeR066fLgy-7m5LhCxyp2m2o2JFxcrH3Y,9721 +ansible/modules/network/aci/aci_config_snapshot.pyc,, +ansible/modules/network/aci/aci_contract.py,sha256=639CumRWRaEUkgtr0JXL44hkJTMWitRgyFZjZNkGbv8,8613 +ansible/modules/network/aci/aci_contract.pyc,, +ansible/modules/network/aci/aci_contract_subject.py,sha256=_LPYrlAvlpozwdCpAlt-e2mp4ylFw9MD7vGEUOj14DI,10537 +ansible/modules/network/aci/aci_contract_subject.pyc,, +ansible/modules/network/aci/aci_contract_subject_to_filter.py,sha256=i2VFN2LXP9h87pZU3uUFPLw4KKOopyZ9J6NN7aH3jpk,8943 +ansible/modules/network/aci/aci_contract_subject_to_filter.pyc,, +ansible/modules/network/aci/aci_domain.py,sha256=G1-aWrWlcp3g-wl9ikm1P9rA-T98ozn_iNh5nEbUaug,12031 +ansible/modules/network/aci/aci_domain.pyc,, +ansible/modules/network/aci/aci_domain_to_encap_pool.py,sha256=IAAVRAHVgz4-VGGyu1cAnbUhjHGJ5K3LFg8XYTw48uE,11289 +ansible/modules/network/aci/aci_domain_to_encap_pool.pyc,, +ansible/modules/network/aci/aci_domain_to_vlan_pool.py,sha256=XEt67KhC5nv1ltGz6GAyiZsY0UFz9nYAToZdHxeNR_M,10592 +ansible/modules/network/aci/aci_domain_to_vlan_pool.pyc,, +ansible/modules/network/aci/aci_encap_pool.py,sha256=wwpGPObFAwBjL_HYZSISi4aQutytr74C_pzmJCL3MhE,8448 +ansible/modules/network/aci/aci_encap_pool.pyc,, +ansible/modules/network/aci/aci_encap_pool_range.py,sha256=pUcasG08mIXfRMaoIuSj3xyoHHVHTSVlPgjDYCcOFr0,13102 +ansible/modules/network/aci/aci_encap_pool_range.pyc,, +ansible/modules/network/aci/aci_epg.py,sha256=FWEk0oDzeHzt02DgRqYy_uKmTKZnolFxXv_quJ09o_A,10221 +ansible/modules/network/aci/aci_epg.pyc,, +ansible/modules/network/aci/aci_epg_monitoring_policy.py,sha256=0e2OSOdPuMtzITrZL9DE8SU0_RuUI7UdFh7Kbvsbtdg,6477 +ansible/modules/network/aci/aci_epg_monitoring_policy.pyc,, +ansible/modules/network/aci/aci_epg_to_contract.py,sha256=OMlkyK_YMMUv36NcOwEuDUXVk0N8Ll8AKWjuJ88pDEU,9591 +ansible/modules/network/aci/aci_epg_to_contract.pyc,, +ansible/modules/network/aci/aci_epg_to_domain.py,sha256=FprQM02vv9jv6lutY2vfpyNQIik5Lg29mcIfQiRKjPY,12494 +ansible/modules/network/aci/aci_epg_to_domain.pyc,, +ansible/modules/network/aci/aci_fabric_node.py,sha256=zmyE8imSsDChRWRI-VfJKVX3eUiDE7Ki2Vif0NavYuA,7704 +ansible/modules/network/aci/aci_fabric_node.pyc,, +ansible/modules/network/aci/aci_filter.py,sha256=y57K7pibYwByuvvojyWrAQn_tV0UqDlDOAWtZO23Q6c,7094 +ansible/modules/network/aci/aci_filter.pyc,, +ansible/modules/network/aci/aci_filter_entry.py,sha256=ipjWbV6_bqo561C11n7NzSS4SfwMU1jz3ghrdBuKkmo,12332 +ansible/modules/network/aci/aci_filter_entry.pyc,, +ansible/modules/network/aci/aci_firmware_source.py,sha256=_VFE0RkptZVbdMAURqvedhnq9qEb2YFEg91tPPRM49Q,7508 +ansible/modules/network/aci/aci_firmware_source.pyc,, +ansible/modules/network/aci/aci_interface_policy_fc.py,sha256=4bpxD4ku7td7YzVh-8PBcUevEh5SWom9KxZ6ctjuu2Q,6142 +ansible/modules/network/aci/aci_interface_policy_fc.pyc,, +ansible/modules/network/aci/aci_interface_policy_l2.py,sha256=Q1KBij-n3JduxtrqKV0AWaPR5dNdCy_04XPMYvnCbck,7055 +ansible/modules/network/aci/aci_interface_policy_l2.pyc,, +ansible/modules/network/aci/aci_interface_policy_leaf_policy_group.py,sha256=qU_mXoZKGlBOzIYUJdIgxNQWTVZdPmz1z2Qrs6x7NnQ,18242 +ansible/modules/network/aci/aci_interface_policy_leaf_policy_group.pyc,, +ansible/modules/network/aci/aci_interface_policy_leaf_profile.py,sha256=x3jPLwse969OymLCcMAKPzsIjvYMvKiSndaeNJwIhgU,6845 +ansible/modules/network/aci/aci_interface_policy_leaf_profile.pyc,, +ansible/modules/network/aci/aci_interface_policy_lldp.py,sha256=5wfFENFkN8Y6ufdx6N8PS6oQtLNs25hX-FgqLryhXAA,6599 +ansible/modules/network/aci/aci_interface_policy_lldp.pyc,, +ansible/modules/network/aci/aci_interface_policy_mcp.py,sha256=iYzMZYQqs_i8uiX712KuAU8_B1OeePVemyR0ajaeNvE,6090 +ansible/modules/network/aci/aci_interface_policy_mcp.pyc,, +ansible/modules/network/aci/aci_interface_policy_ospf.py,sha256=8HdvCTZwKUYu-w5U3xQ8navlmqeuqOlfPIh_WG4RbFA,13570 +ansible/modules/network/aci/aci_interface_policy_ospf.pyc,, +ansible/modules/network/aci/aci_interface_policy_port_channel.py,sha256=MTYwWf9dttvOqm2MJ3ic3TJDf7YOPmIKWjen1wdyTGk,9753 +ansible/modules/network/aci/aci_interface_policy_port_channel.pyc,, +ansible/modules/network/aci/aci_interface_policy_port_security.py,sha256=CRG6jyZaxL_q8hpBjtAky5d6WMMqPlJy_zDTBkdhuWE,6396 +ansible/modules/network/aci/aci_interface_policy_port_security.pyc,, +ansible/modules/network/aci/aci_interface_selector_to_switch_policy_leaf_profile.py,sha256=MPDUz5CdUiYA22f7tzR8u3v9BF1x4M3ovb9RsD2K8Zw,7609 +ansible/modules/network/aci/aci_interface_selector_to_switch_policy_leaf_profile.pyc,, +ansible/modules/network/aci/aci_l3out.py,sha256=0ZQz00ZeZwjBprjBcJJg2GWUNZtyZFZYY5oPIlHMLA0,10006 +ansible/modules/network/aci/aci_l3out.pyc,, +ansible/modules/network/aci/aci_l3out_route_tag_policy.py,sha256=UjLK5HOD0deU2K1NIncu0WOCvWVnmUQF5f3E160uH7s,6638 +ansible/modules/network/aci/aci_l3out_route_tag_policy.pyc,, +ansible/modules/network/aci/aci_rest.py,sha256=Fc5UwrFJOwQPEpEVv3CTXGuRR_JJ_jpLS6DE917klQs,14013 +ansible/modules/network/aci/aci_rest.pyc,, +ansible/modules/network/aci/aci_static_binding_to_epg.py,sha256=f_O9nXNftZk8DLvepCYnZmWGOUjHLbLSt78EVCv2fRg,14587 +ansible/modules/network/aci/aci_static_binding_to_epg.pyc,, +ansible/modules/network/aci/aci_switch_leaf_selector.py,sha256=cUrUNrJmkD9-IqUVA5FB59iPh3aqQO93iyeeWGRdJzk,10217 +ansible/modules/network/aci/aci_switch_leaf_selector.pyc,, +ansible/modules/network/aci/aci_switch_policy_leaf_profile.py,sha256=qryWgFYp3xRGRDcZwJ9KOdDnrcmc6zIKp6XkwinjZyQ,6327 +ansible/modules/network/aci/aci_switch_policy_leaf_profile.pyc,, +ansible/modules/network/aci/aci_switch_policy_vpc_protection_group.py,sha256=1ZErMHkoeoeZ8oUZoIxb3khfmgkhsisOMkKswDkTQCU,8566 +ansible/modules/network/aci/aci_switch_policy_vpc_protection_group.pyc,, +ansible/modules/network/aci/aci_taboo_contract.py,sha256=GnEwkqU60TrB4RUjO7DoEYBPo6Iz7_cEKkU0b7sXZJA,7456 +ansible/modules/network/aci/aci_taboo_contract.pyc,, +ansible/modules/network/aci/aci_tenant.py,sha256=BL7Q8aFDJQgybfgRZPJdY3hENvoHQcB_ULALMz3zbcg,6198 +ansible/modules/network/aci/aci_tenant.pyc,, +ansible/modules/network/aci/aci_tenant_action_rule_profile.py,sha256=dLrqilyTn4Nh1rJIBLUtzS4zbyfpKG_0N5RPHvoXTxE,6408 +ansible/modules/network/aci/aci_tenant_action_rule_profile.pyc,, +ansible/modules/network/aci/aci_tenant_ep_retention_policy.py,sha256=3dgpoblfhdcojZOAKNuBBDC-NUw_yBvVLvVNOZDVt1Y,10632 +ansible/modules/network/aci/aci_tenant_ep_retention_policy.pyc,, +ansible/modules/network/aci/aci_tenant_span_dst_group.py,sha256=5-q1b9TJVot7cp_gqPYjWh2R4JLh5VKwMglc53N_xCY,6386 +ansible/modules/network/aci/aci_tenant_span_dst_group.pyc,, +ansible/modules/network/aci/aci_tenant_span_src_group.py,sha256=RcJ4HsPUi6CWiZAgorSLj4nnl097-e8WfsN17-maKs0,7001 +ansible/modules/network/aci/aci_tenant_span_src_group.pyc,, +ansible/modules/network/aci/aci_tenant_span_src_group_to_dst_group.py,sha256=5D6imMWeZvffpeKwM6_QM2kiw1iyaDEYHqbRjkkngDY,6906 +ansible/modules/network/aci/aci_tenant_span_src_group_to_dst_group.pyc,, +ansible/modules/network/aci/aci_vlan_pool.py,sha256=oH5ZyOuKO3wucZaC5DdGk7P_1BsJBOLSJ1YSi2Ejk4g,7236 +ansible/modules/network/aci/aci_vlan_pool.pyc,, +ansible/modules/network/aci/aci_vlan_pool_encap_block.py,sha256=jtieUd1a0tXI4hHFaGIdNaUT1e0g4jyzeOGqn4v0Tw8,10186 +ansible/modules/network/aci/aci_vlan_pool_encap_block.pyc,, +ansible/modules/network/aci/aci_vrf.py,sha256=W4t0F2Yo1C2FuKdA0S2WtFeeVsEjRYBUQjWmbCxcI7g,7733 +ansible/modules/network/aci/aci_vrf.pyc,, +ansible/modules/network/aireos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/aireos/__init__.pyc,, +ansible/modules/network/aireos/aireos_command.py,sha256=rREJEZ1BKxatlPSHgUDjPRDrYbE0ydF8RbBWePSZlks,6929 +ansible/modules/network/aireos/aireos_command.pyc,, +ansible/modules/network/aireos/aireos_config.py,sha256=PwDnhgckSDChLolet7wt-8qWi2horHiW8igbSg1ws54,12342 +ansible/modules/network/aireos/aireos_config.pyc,, +ansible/modules/network/aos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/aos/__init__.pyc,, +ansible/modules/network/aos/_aos_asn_pool.py,sha256=TBt2dW3VnEEzqGAwn3XKxsOKu0oLsRhKZZ0GC_Djsis,10674 +ansible/modules/network/aos/_aos_asn_pool.pyc,, +ansible/modules/network/aos/_aos_blueprint.py,sha256=DBgSw0RFX26uGGl16TqF-yC0_AVcDbzy4FI8AOXBQ08,9101 +ansible/modules/network/aos/_aos_blueprint.pyc,, +ansible/modules/network/aos/_aos_blueprint_param.py,sha256=WFQnvL4spKuK0kggYpd94vGwForlNkRqiPvP4nn9UCU,13083 +ansible/modules/network/aos/_aos_blueprint_param.pyc,, +ansible/modules/network/aos/_aos_blueprint_virtnet.py,sha256=SvS6nglFJENJ5EaYWvztz9g954zj4lO06OJ9NfkH3J0,7631 +ansible/modules/network/aos/_aos_blueprint_virtnet.pyc,, +ansible/modules/network/aos/_aos_device.py,sha256=GX7kTMIBiLPXDwlwo_vmHynZrJAhuUf-lw7fEvqwfUY,6951 +ansible/modules/network/aos/_aos_device.pyc,, +ansible/modules/network/aos/_aos_external_router.py,sha256=-HgUXL25rPM8q5eiF-STkpyWEeiZj3-Q9FzB7QhXIuw,11050 +ansible/modules/network/aos/_aos_external_router.pyc,, +ansible/modules/network/aos/_aos_ip_pool.py,sha256=tBTEPX74xVJCCSdIKBdUYzSM0B0qRP-jNCu96QB7NZI,10551 +ansible/modules/network/aos/_aos_ip_pool.pyc,, +ansible/modules/network/aos/_aos_logical_device.py,sha256=w7cWMDf2Q9h2zkUguorJQo0Ru-ohEBHljyoT_T25fRE,8173 +ansible/modules/network/aos/_aos_logical_device.pyc,, +ansible/modules/network/aos/_aos_logical_device_map.py,sha256=qtc-Wu2btJgocsXGJ-tJDG8kc2HW7WhO6psqtajtKvU,9094 +ansible/modules/network/aos/_aos_logical_device_map.pyc,, +ansible/modules/network/aos/_aos_login.py,sha256=BgKOLTcWapbNbwQ3QhKVAYZ0UsgYNsk6E7X4vqzE7ac,4110 +ansible/modules/network/aos/_aos_login.pyc,, +ansible/modules/network/aos/_aos_rack_type.py,sha256=BHNrD0fae-8yORG6vHEJTIQ5lSPZqG2e6wf6Ap7_2eI,7790 +ansible/modules/network/aos/_aos_rack_type.pyc,, +ansible/modules/network/aos/_aos_template.py,sha256=2LHQ_UjxnORbG69my5kKEeIaegkrprNspRA3Omq-pg0,8372 +ansible/modules/network/aos/_aos_template.pyc,, +ansible/modules/network/aruba/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/aruba/__init__.pyc,, +ansible/modules/network/aruba/aruba_command.py,sha256=mXk81osqoAcKD6FyRfavI8Qt3e6_aTrnGAvF8O7TccI,6777 +ansible/modules/network/aruba/aruba_command.pyc,, +ansible/modules/network/aruba/aruba_config.py,sha256=9Zxxdtftpyc7BDic3fJhTLDPn4ZrUb1IJwE03i9yMx0,15163 +ansible/modules/network/aruba/aruba_config.pyc,, +ansible/modules/network/asa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/asa/__init__.pyc,, +ansible/modules/network/asa/asa_acl.py,sha256=o6iVQPenT2-rJ_JsTTF73uiOE10_3RD9RYDw5U21RSY,7433 +ansible/modules/network/asa/asa_acl.pyc,, +ansible/modules/network/asa/asa_command.py,sha256=00k4kSMNZVtBO6DzoFT6umGLbp4kFSOxUoBNdnbyCjU,5615 +ansible/modules/network/asa/asa_command.pyc,, +ansible/modules/network/asa/asa_config.py,sha256=tuvrt74Y0PoGPWtKnf2tLxP81yc2IwJwNb6nTtZZ24c,10134 +ansible/modules/network/asa/asa_config.pyc,, +ansible/modules/network/avi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/avi/__init__.pyc,, +ansible/modules/network/avi/avi_actiongroupconfig.py,sha256=gRNkO509Z7-EfaqPksDC9foqgJ--P_kLYDgPRD79PQE,5478 +ansible/modules/network/avi/avi_actiongroupconfig.pyc,, +ansible/modules/network/avi/avi_alertconfig.py,sha256=K-bUh5BbnDgWV0d8EwDxhATcZmRXNG10hsAl9lIjp1g,12181 +ansible/modules/network/avi/avi_alertconfig.pyc,, +ansible/modules/network/avi/avi_alertemailconfig.py,sha256=P6zGrbHx3VDVf5mhF3CIfrvrBQYWvOBPqhoMNCdKIO4,3870 +ansible/modules/network/avi/avi_alertemailconfig.pyc,, +ansible/modules/network/avi/avi_alertscriptconfig.py,sha256=FvmI7GehdQsCtuPv3kwsspNgtwMBiYKrTbXIZ65h9Nw,3661 +ansible/modules/network/avi/avi_alertscriptconfig.pyc,, +ansible/modules/network/avi/avi_alertsyslogconfig.py,sha256=oC4OjTdFyodnnr-kns4ACI-luoAKNTdOrp620VWTAtw,3833 +ansible/modules/network/avi/avi_alertsyslogconfig.pyc,, +ansible/modules/network/avi/avi_analyticsprofile.py,sha256=qOPm5-mjLjnIB0Up1iZu2zo_ve5uskuhB42EtxTTu2c,29131 +ansible/modules/network/avi/avi_analyticsprofile.pyc,, +ansible/modules/network/avi/avi_api_session.py,sha256=PKADrKt_NufEyh95smddhh1P1iICWQrXFVtUOtU6gps,8314 +ansible/modules/network/avi/avi_api_session.pyc,, +ansible/modules/network/avi/avi_api_version.py,sha256=mAEwrEhVXIogLqDEydldn-ng3HbNYvcAwHn4l-8xoH0,2545 +ansible/modules/network/avi/avi_api_version.pyc,, +ansible/modules/network/avi/avi_applicationpersistenceprofile.py,sha256=3kOSkW4hi4BhLn8wvEdv4wrcwSD8jGHSUD8jNXRETp4,6701 +ansible/modules/network/avi/avi_applicationpersistenceprofile.pyc,, +ansible/modules/network/avi/avi_applicationprofile.py,sha256=vMMRMR7-WagXUO3ZCJv3RW5Ma8sacPCe6u4o8C5R-Zg,7146 +ansible/modules/network/avi/avi_applicationprofile.pyc,, +ansible/modules/network/avi/avi_authprofile.py,sha256=mQ9P1Voq7dgteBere_Hv0N8Fqfl3hZIrBX1hRXidv80,5006 +ansible/modules/network/avi/avi_authprofile.pyc,, +ansible/modules/network/avi/avi_autoscalelaunchconfig.py,sha256=BECHNL7Jv5n90tuHNxRxchylktpBQvDke8bXBkXjjXM,4476 +ansible/modules/network/avi/avi_autoscalelaunchconfig.pyc,, +ansible/modules/network/avi/avi_backup.py,sha256=AnyIzGrUsnxc35o1liO4Jw6ATRs0nt35H4HSVtLn7DA,4096 +ansible/modules/network/avi/avi_backup.pyc,, +ansible/modules/network/avi/avi_backupconfiguration.py,sha256=UjcKIti_Fj3azQWp7dOZmaMqQ4YRWMjGYi_s8xalxmM,4821 +ansible/modules/network/avi/avi_backupconfiguration.pyc,, +ansible/modules/network/avi/avi_certificatemanagementprofile.py,sha256=9pV2CPfIjYIMsXhVdvgKIrWsxx60ZnHcSl60FlDQcGE,3783 +ansible/modules/network/avi/avi_certificatemanagementprofile.pyc,, +ansible/modules/network/avi/avi_cloud.py,sha256=H9Cmoa7OGCuPF31QRuG6GD4PMg7P13NhChvDuloSdr8,10708 +ansible/modules/network/avi/avi_cloud.pyc,, +ansible/modules/network/avi/avi_cloudconnectoruser.py,sha256=cBH7If1lnr9264dz-kaIqeHXluLllNOu3iImcWUT9y0,4187 +ansible/modules/network/avi/avi_cloudconnectoruser.pyc,, +ansible/modules/network/avi/avi_cloudproperties.py,sha256=ecUTr4ZAj0iJ-ZO-YKGFfv3KcCIAC798PTSjDFhm3Bs,3785 +ansible/modules/network/avi/avi_cloudproperties.pyc,, +ansible/modules/network/avi/avi_cluster.py,sha256=cRR3BK9Mw0G80BpgPXgOxzbdVURpnfuqhug1YG3yJKg,3936 +ansible/modules/network/avi/avi_cluster.pyc,, +ansible/modules/network/avi/avi_clusterclouddetails.py,sha256=bPzaF4iqqQrHGzcvF5PkKThvkyU3hEgsQfJsmRT1T7w,3609 +ansible/modules/network/avi/avi_clusterclouddetails.pyc,, +ansible/modules/network/avi/avi_controllerproperties.py,sha256=ohJ9wEKTuQry--Hm0E8EiFP9LHndmA49IxZV1fvkM90,16486 +ansible/modules/network/avi/avi_controllerproperties.pyc,, +ansible/modules/network/avi/avi_customipamdnsprofile.py,sha256=_bhvh7t2o0bnL8ffsYI7cy_scpzeWxmenoSYdsV6ZQ0,3906 +ansible/modules/network/avi/avi_customipamdnsprofile.pyc,, +ansible/modules/network/avi/avi_dnspolicy.py,sha256=I3svpbfMFx5jCej6HuhhIXe6hezvo-iddqZ9QBBaLZM,3825 +ansible/modules/network/avi/avi_dnspolicy.pyc,, +ansible/modules/network/avi/avi_errorpagebody.py,sha256=obp88BngeAL12NqdBhihQC2o7durHN5_nxz_jP4DTQ0,3552 +ansible/modules/network/avi/avi_errorpagebody.pyc,, +ansible/modules/network/avi/avi_errorpageprofile.py,sha256=8W2wrGvDxPYREWRSqhy3XyBjZqhC4wUZdbmxx-pVH7Q,4469 +ansible/modules/network/avi/avi_errorpageprofile.pyc,, +ansible/modules/network/avi/avi_gslb.py,sha256=Y1U6lI8kd55tdZLILXqT-8fof1hwqHL451blFucK5GM,6716 +ansible/modules/network/avi/avi_gslb.pyc,, +ansible/modules/network/avi/avi_gslbapplicationpersistenceprofile.py,sha256=rJgn2xhTgyBC672WlnJ2uluCVhHW2CZsF7CTdA3iZrA,3672 +ansible/modules/network/avi/avi_gslbapplicationpersistenceprofile.pyc,, +ansible/modules/network/avi/avi_gslbgeodbprofile.py,sha256=EASlL6ElIQQlCI8Ra4LC_XWCplSy1f2ucKEPT1o-lSY,4215 +ansible/modules/network/avi/avi_gslbgeodbprofile.pyc,, +ansible/modules/network/avi/avi_gslbhealthmonitor.py,sha256=W-vdnjO93ZguAXWlcruqF4fq-LpQXnjVPq3K-X47Jus,6453 +ansible/modules/network/avi/avi_gslbhealthmonitor.pyc,, +ansible/modules/network/avi/avi_gslbservice.py,sha256=WJbiP5aylr-W2WERT-ZjgjHoBYs-cbWMMflD4XWJz_8,9660 +ansible/modules/network/avi/avi_gslbservice.pyc,, +ansible/modules/network/avi/avi_gslbservice_patch_member.py,sha256=GmhcDhqBSJMaRf0xUZISl0P2nIkoCNdZ1CG3-gWMhsA,10405 +ansible/modules/network/avi/avi_gslbservice_patch_member.pyc,, +ansible/modules/network/avi/avi_hardwaresecuritymodulegroup.py,sha256=VCD8VxXpQBnj1IlBiQW1pDnIa6gaq293IgHEnpbFjOo,3637 +ansible/modules/network/avi/avi_hardwaresecuritymodulegroup.pyc,, +ansible/modules/network/avi/avi_healthmonitor.py,sha256=QSjToQ48YYCTiDPXm5PCIyu81-NBd8fjjqNjDFA5iWA,7366 +ansible/modules/network/avi/avi_healthmonitor.pyc,, +ansible/modules/network/avi/avi_httppolicyset.py,sha256=u4cA1h4wciPPl0Yw5-KJnG-yBF0unIUQD98ENMAG_SY,5400 +ansible/modules/network/avi/avi_httppolicyset.pyc,, +ansible/modules/network/avi/avi_ipaddrgroup.py,sha256=CsdxDphaRdmWk3ub-yK4Vj3lgVvnK0uniz_OFO9rcD0,4970 +ansible/modules/network/avi/avi_ipaddrgroup.pyc,, +ansible/modules/network/avi/avi_ipamdnsproviderprofile.py,sha256=LjsO84v-TDDFYH-YZNF8aKPLaCY4Z0yZ7jj9sIKpbXs,5882 +ansible/modules/network/avi/avi_ipamdnsproviderprofile.pyc,, +ansible/modules/network/avi/avi_l4policyset.py,sha256=4j4rPgV6mSrJhBFICnVjv_kA2BFikoMiE1J0XroZk7g,4122 +ansible/modules/network/avi/avi_l4policyset.pyc,, +ansible/modules/network/avi/avi_microservicegroup.py,sha256=kkNbLc2wuGrQRCJ_TIDRA2t-cfpjnexSMw4Twqmig4Y,3926 +ansible/modules/network/avi/avi_microservicegroup.pyc,, +ansible/modules/network/avi/avi_network.py,sha256=ad1F5XcG0A3T0Amj0Bgd0_cq8yKXqMHTKS668AbxAiY,4997 +ansible/modules/network/avi/avi_network.pyc,, +ansible/modules/network/avi/avi_networkprofile.py,sha256=rmEnZL8Ia35C2YMej7lR8zsVXVVIHR5QXmBOsDpmOJM,3895 +ansible/modules/network/avi/avi_networkprofile.pyc,, +ansible/modules/network/avi/avi_networksecuritypolicy.py,sha256=76_Vt77UgZtgTRiAX-N3JZxGePCNQyxlClYeYca15HA,4303 +ansible/modules/network/avi/avi_networksecuritypolicy.pyc,, +ansible/modules/network/avi/avi_pkiprofile.py,sha256=My_Ul0jROI3tfB7QoZTVJDRfmeiIOJ-DqbkvRQK-PNI,5529 +ansible/modules/network/avi/avi_pkiprofile.pyc,, +ansible/modules/network/avi/avi_pool.py,sha256=KTD5Qpgw5n1kurEgaHwqxRAu2lByiIMVxkPbTDoclh8,20373 +ansible/modules/network/avi/avi_pool.pyc,, +ansible/modules/network/avi/avi_poolgroup.py,sha256=LS29P8r1TOlG4rUXVZQASNgD9x_cYrryFZ6B0xNmIec,5711 +ansible/modules/network/avi/avi_poolgroup.pyc,, +ansible/modules/network/avi/avi_poolgroupdeploymentpolicy.py,sha256=HEa2f3tJ2r4coO9pOg1s5-3igt_tRlLcT50f1mnu1As,5862 +ansible/modules/network/avi/avi_poolgroupdeploymentpolicy.pyc,, +ansible/modules/network/avi/avi_prioritylabels.py,sha256=h_xIVNZq6KbOjiTLMOCBlMnijFKvOM-4jdkY05ZMuYY,3755 +ansible/modules/network/avi/avi_prioritylabels.pyc,, +ansible/modules/network/avi/avi_role.py,sha256=HBaWYaZpMRg30bif-AhioAPzkGRQjHtz2F6B0FwRM94,3381 +ansible/modules/network/avi/avi_role.pyc,, +ansible/modules/network/avi/avi_scheduler.py,sha256=G-udKIFpkaEmP5yBCSJepBLx6mCtNjMn_yDYJ07QllM,5258 +ansible/modules/network/avi/avi_scheduler.pyc,, +ansible/modules/network/avi/avi_seproperties.py,sha256=aYVxnt6WVNcR0GEQHhpEutZwcOCamJXzjMohJlO9fFU,3650 +ansible/modules/network/avi/avi_seproperties.pyc,, +ansible/modules/network/avi/avi_serverautoscalepolicy.py,sha256=7_LuxC4Xf_Xgtjb1vZ64UmHWiMxnw_5XYswlhSNLhJg,7492 +ansible/modules/network/avi/avi_serverautoscalepolicy.pyc,, +ansible/modules/network/avi/avi_serviceengine.py,sha256=UF0YED6Z6tqfa5rDgZAVHoaWwPzjImyvfvHBsToYfyo,5932 +ansible/modules/network/avi/avi_serviceengine.pyc,, +ansible/modules/network/avi/avi_serviceenginegroup.py,sha256=6BHRyip3x_xeqUiTz5dbUA_vSxrs7-kN0-C5g-4eyuo,37898 +ansible/modules/network/avi/avi_serviceenginegroup.pyc,, +ansible/modules/network/avi/avi_snmptrapprofile.py,sha256=gxINoKDpif7PVCfQem8LBmvK1ffe36Ei3shV-lJCQwY,3537 +ansible/modules/network/avi/avi_snmptrapprofile.pyc,, +ansible/modules/network/avi/avi_sslkeyandcertificate.py,sha256=AQ4j1svtIRtGIRQpKWw_WCZhQ683Y2iX-hq4xutO57U,5892 +ansible/modules/network/avi/avi_sslkeyandcertificate.pyc,, +ansible/modules/network/avi/avi_sslprofile.py,sha256=DeCB4RxB3bzWIpXUOV_12hJVPlSeXWeWJPnyALJaLIw,8497 +ansible/modules/network/avi/avi_sslprofile.pyc,, +ansible/modules/network/avi/avi_stringgroup.py,sha256=f4-fyCXAZG4o3wTqq9fvOz9WpriyLwYQU_XX-pa2thk,4230 +ansible/modules/network/avi/avi_stringgroup.pyc,, +ansible/modules/network/avi/avi_systemconfiguration.py,sha256=-RMRIHs7wIwah7HaHitaukAjp5i6QPkCAO9FVooG4bE,6580 +ansible/modules/network/avi/avi_systemconfiguration.pyc,, +ansible/modules/network/avi/avi_tenant.py,sha256=KYvt0eLElJ7bQjeuG_PIw8GApWUawLOSzfE9zNUCuvQ,4010 +ansible/modules/network/avi/avi_tenant.pyc,, +ansible/modules/network/avi/avi_trafficcloneprofile.py,sha256=cU93VCNK2ADrfQLQ-m9pp7zjyjv-x4mb9YWc1Kd8kT4,4161 +ansible/modules/network/avi/avi_trafficcloneprofile.pyc,, +ansible/modules/network/avi/avi_useraccount.py,sha256=tzxaTl-UQANZ-2-ZEulqmHmSEHczJxiLIez1ZdRPvbw,3979 +ansible/modules/network/avi/avi_useraccount.pyc,, +ansible/modules/network/avi/avi_useraccountprofile.py,sha256=g1AF63de6nKrVENTK7CxdxXhV_DXvEfrrggf6QsryOk,4861 +ansible/modules/network/avi/avi_useraccountprofile.pyc,, +ansible/modules/network/avi/avi_virtualservice.py,sha256=hki6mrssD38QAwQV5v5QAhZ1uEnMSmqo3Fityc4mki4,28097 +ansible/modules/network/avi/avi_virtualservice.pyc,, +ansible/modules/network/avi/avi_vrfcontext.py,sha256=U93cc_lPvkEFTFJyt4o8LcuoRaihUp4UB9Rg3gzyyzY,4674 +ansible/modules/network/avi/avi_vrfcontext.pyc,, +ansible/modules/network/avi/avi_vsdatascriptset.py,sha256=1deVH9whJ2mvFIIuPUnWY7oHwYKWKACsSl-Ni_iDZYg,4760 +ansible/modules/network/avi/avi_vsdatascriptset.pyc,, +ansible/modules/network/avi/avi_vsvip.py,sha256=aYxaw-23-bbhLbUFfU9Iva7W2AjQaUL6ANeIEBMxiYk,4733 +ansible/modules/network/avi/avi_vsvip.pyc,, +ansible/modules/network/avi/avi_wafpolicy.py,sha256=YTcHsBTkvXz7s77fn25ep-RtGNoWnuGHDPrWBRkdrnY,5676 +ansible/modules/network/avi/avi_wafpolicy.pyc,, +ansible/modules/network/avi/avi_wafprofile.py,sha256=1QqlGPYSIhK-47s2t-mTIr2ZHxp7P_ASbY47ZS0JUrg,3805 +ansible/modules/network/avi/avi_wafprofile.pyc,, +ansible/modules/network/avi/avi_webhook.py,sha256=QGaOPDgxOIYiF2RgVzD1lNnnGO1h-lh_m7oNAO-ky7Y,3902 +ansible/modules/network/avi/avi_webhook.pyc,, +ansible/modules/network/bigswitch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/bigswitch/__init__.pyc,, +ansible/modules/network/bigswitch/bcf_switch.py,sha256=119VrZRTPA3PHFAXNNSkctlyQpshpPp-uPzYlg1PwEA,5086 +ansible/modules/network/bigswitch/bcf_switch.pyc,, +ansible/modules/network/bigswitch/bigmon_chain.py,sha256=UOuCu5R9rGW3TjPzPDkeq8K0xUINoe81pPi_4ESFShk,4195 +ansible/modules/network/bigswitch/bigmon_chain.pyc,, +ansible/modules/network/bigswitch/bigmon_policy.py,sha256=Br_gYbmR6dTtIWOePiQJ1uHqPxbLk4pFO2iYgE-FN8I,6482 +ansible/modules/network/bigswitch/bigmon_policy.pyc,, +ansible/modules/network/citrix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/citrix/__init__.pyc,, +ansible/modules/network/citrix/_netscaler.py,sha256=5Nz7cgEZJZ0ImN6A88-4fT49_xT1huBjHmLKKx3O98w,4966 +ansible/modules/network/citrix/_netscaler.pyc,, +ansible/modules/network/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/cli/__init__.pyc,, +ansible/modules/network/cli/cli_command.py,sha256=PzsgTTfXHV__eWYrSrwwS5qUnC8RmllBKrGqB4lwFfM,5050 +ansible/modules/network/cli/cli_command.pyc,, +ansible/modules/network/cli/cli_config.py,sha256=OmbnKex_zS53o9EUFtXC_iXrG6Giyrulcxv7dRJ6wIg,12598 +ansible/modules/network/cli/cli_config.pyc,, +ansible/modules/network/cloudengine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/cloudengine/__init__.pyc,, +ansible/modules/network/cloudengine/ce_aaa_server.py,sha256=RTrsvgLhUtrb4QF6oAs5nGj45Oaqba5ejUJ-ZiDUu14,70248 +ansible/modules/network/cloudengine/ce_aaa_server.pyc,, +ansible/modules/network/cloudengine/ce_aaa_server_host.py,sha256=Q3ofH9hZXyzbsa60xLU-Yn3OpA35R5SHFSXZtfu3LvM,105166 +ansible/modules/network/cloudengine/ce_aaa_server_host.pyc,, +ansible/modules/network/cloudengine/ce_acl.py,sha256=TWs4MRbnR5FMuAUcMnLDzQbvyefAiDwOMHn-MK_j5sE,35676 +ansible/modules/network/cloudengine/ce_acl.pyc,, +ansible/modules/network/cloudengine/ce_acl_advance.py,sha256=_ftDEi76LcyF_WkSjaFgsBZjIFcR5_KPgoJIVdm1QLQ,73319 +ansible/modules/network/cloudengine/ce_acl_advance.pyc,, +ansible/modules/network/cloudengine/ce_acl_interface.py,sha256=RfbawrSzNJwhrFWKYo0FD_dNU9bf6b4P9kYHtClF_Fc,9127 +ansible/modules/network/cloudengine/ce_acl_interface.pyc,, +ansible/modules/network/cloudengine/ce_bfd_global.py,sha256=uVu6UEpwj1ye6HJfGiyIRkdQHIYIFRBB-ar2uDAHXk4,21174 +ansible/modules/network/cloudengine/ce_bfd_global.pyc,, +ansible/modules/network/cloudengine/ce_bfd_session.py,sha256=vh6yG9tkHnm5yt3MM0AiYHucLzkvRT7u6rcXGOJ0Icc,20235 +ansible/modules/network/cloudengine/ce_bfd_session.pyc,, +ansible/modules/network/cloudengine/ce_bfd_view.py,sha256=OHp5i6b_ZpP5jrczEyntQqAHqT-ywLgH8eET-vbZiao,20134 +ansible/modules/network/cloudengine/ce_bfd_view.pyc,, +ansible/modules/network/cloudengine/ce_bgp.py,sha256=aTMUB1g3x5U4p3U20QsmepLeWHETxu2Q_iWhgUGKaho,80680 +ansible/modules/network/cloudengine/ce_bgp.pyc,, +ansible/modules/network/cloudengine/ce_bgp_af.py,sha256=VuWJh7PAdOWVzOEZVt7uJcchgDlz7GKNNEAKYmThZZs,133213 +ansible/modules/network/cloudengine/ce_bgp_af.pyc,, +ansible/modules/network/cloudengine/ce_bgp_neighbor.py,sha256=Pk8yaPf4FHM0XI63AH1wqncj8W1ZXr72YNFjVMs9Ddo,72401 +ansible/modules/network/cloudengine/ce_bgp_neighbor.pyc,, +ansible/modules/network/cloudengine/ce_bgp_neighbor_af.py,sha256=YXdr4zeLVRWsmUsiqXQAQ7FhW6UYythH_2kjbe1ur24,107431 +ansible/modules/network/cloudengine/ce_bgp_neighbor_af.pyc,, +ansible/modules/network/cloudengine/ce_command.py,sha256=tk1rWPvttYkT00kIuv22RayzHaTmybBkFienIpl0k0k,7719 +ansible/modules/network/cloudengine/ce_command.pyc,, +ansible/modules/network/cloudengine/ce_config.py,sha256=FzSCchjxW2nvhHUMp7jbsvTdUu0sl6ZHkm483y8_F68,11037 +ansible/modules/network/cloudengine/ce_config.pyc,, +ansible/modules/network/cloudengine/ce_dldp.py,sha256=XGqIYMJx4AKdRQFvpf1vTwhndwHBljmAmznLLlE96zY,18816 +ansible/modules/network/cloudengine/ce_dldp.pyc,, +ansible/modules/network/cloudengine/ce_dldp_interface.py,sha256=7JJaL64mNwDF-9H8qXDuAiIivuNjgD3-WZVdVFgo1bE,22697 +ansible/modules/network/cloudengine/ce_dldp_interface.pyc,, +ansible/modules/network/cloudengine/ce_eth_trunk.py,sha256=4bmcLQLjezdoLf6f4vA_OvN4n26elCfRgn4Idu8ykmw,22807 +ansible/modules/network/cloudengine/ce_eth_trunk.pyc,, +ansible/modules/network/cloudengine/ce_evpn_bd_vni.py,sha256=Gl8vDXyWueuluqADN5F7eXAp2CGBxTZBMKO5MR5HmuA,39544 +ansible/modules/network/cloudengine/ce_evpn_bd_vni.pyc,, +ansible/modules/network/cloudengine/ce_evpn_bgp.py,sha256=Cl0lDTwM_IepVBnl2hYJPrFQyHprZPJuJQlTZQhh0m0,26926 +ansible/modules/network/cloudengine/ce_evpn_bgp.pyc,, +ansible/modules/network/cloudengine/ce_evpn_bgp_rr.py,sha256=5IdH-z-1h6CuRNaVr1StCglCNc3SCOoOVKNmftv2gFs,18115 +ansible/modules/network/cloudengine/ce_evpn_bgp_rr.pyc,, +ansible/modules/network/cloudengine/ce_evpn_global.py,sha256=ZZyd8QyBXNA38YP60FvEL14x0ghZ1IbDqA-fL_OW8-U,6911 +ansible/modules/network/cloudengine/ce_evpn_global.pyc,, +ansible/modules/network/cloudengine/ce_facts.py,sha256=6bR8ayN6543O4u74LT_KJM-njSV9L0ItH8MhyTm5XD8,11122 +ansible/modules/network/cloudengine/ce_facts.pyc,, +ansible/modules/network/cloudengine/ce_file_copy.py,sha256=HS-t-8H5rQfxpg6Oxk9_0HC91Fth5xOW-eKXOW3kSB4,12627 +ansible/modules/network/cloudengine/ce_file_copy.pyc,, +ansible/modules/network/cloudengine/ce_info_center_debug.py,sha256=PdxxC1GqQL2gnVIi-C2TTa69Fo0UP-qqdr0-6UdIMms,21612 +ansible/modules/network/cloudengine/ce_info_center_debug.pyc,, +ansible/modules/network/cloudengine/ce_info_center_global.py,sha256=3o2ONpScbFiiuW58TcOaQEbOUsNb4UeJoRbAJocDStU,69972 +ansible/modules/network/cloudengine/ce_info_center_global.pyc,, +ansible/modules/network/cloudengine/ce_info_center_log.py,sha256=93_e3_hnMz3280sX4AdvecOI-IcomhvYz8XxvXjxTGs,20348 +ansible/modules/network/cloudengine/ce_info_center_log.pyc,, +ansible/modules/network/cloudengine/ce_info_center_trap.py,sha256=lWjEu5aOt3RAVFE1XnfZeKi7MoE3xJeeVmQ5YlK0vd8,25017 +ansible/modules/network/cloudengine/ce_info_center_trap.pyc,, +ansible/modules/network/cloudengine/ce_interface.py,sha256=0dLBneXp4b8zw1tOknv17WOkqXuJtEtIBOIIyGI7Gh0,30669 +ansible/modules/network/cloudengine/ce_interface.pyc,, +ansible/modules/network/cloudengine/ce_interface_ospf.py,sha256=QFblwzNp4g82esJEWLLXZgic2WOlUDTKGKGvzd_b9-8,30841 +ansible/modules/network/cloudengine/ce_interface_ospf.pyc,, +ansible/modules/network/cloudengine/ce_ip_interface.py,sha256=VBF_4Rq44Pb126knmP3CHZ5WSMzHG69JyIBHHVRIVqM,24050 +ansible/modules/network/cloudengine/ce_ip_interface.pyc,, +ansible/modules/network/cloudengine/ce_link_status.py,sha256=a34Fq35GjFdeaktP9RAR2wn6G5VgJ1I8OouXBV9YlKE,22134 +ansible/modules/network/cloudengine/ce_link_status.pyc,, +ansible/modules/network/cloudengine/ce_mlag_config.py,sha256=ynMUXZ7irCO7Mq-mEIUC2qeTJM9L5TppQ4cKOJ4wt_E,33408 +ansible/modules/network/cloudengine/ce_mlag_config.pyc,, +ansible/modules/network/cloudengine/ce_mlag_interface.py,sha256=e-4vPdBIq2pG_ld6xDj6dG6ryzJQbQtjzjMUPJ_h1hI,35456 +ansible/modules/network/cloudengine/ce_mlag_interface.pyc,, +ansible/modules/network/cloudengine/ce_mtu.py,sha256=l-XeLg2P5KIV39Fo5hrnKjYMNfxyH60DeSQIbRFi73w,19870 +ansible/modules/network/cloudengine/ce_mtu.pyc,, +ansible/modules/network/cloudengine/ce_netconf.py,sha256=oLCwoJYciXjWSme2C3UWEur44wNU6u95P3jSXjFSLWY,5962 +ansible/modules/network/cloudengine/ce_netconf.pyc,, +ansible/modules/network/cloudengine/ce_netstream_aging.py,sha256=zKbYid0vrK9NitwRYy9jWoAMbwCIYS1T5APLqSjXFlg,18023 +ansible/modules/network/cloudengine/ce_netstream_aging.pyc,, +ansible/modules/network/cloudengine/ce_netstream_export.py,sha256=J6Vxsg_A_bBGkY8INWpn_0ioR_IZiZs6eSybNf97kEg,19053 +ansible/modules/network/cloudengine/ce_netstream_export.pyc,, +ansible/modules/network/cloudengine/ce_netstream_global.py,sha256=_YPaaXgkoAZVQuVhpxXd9W49AGqOYyZzc1Ag2InR56o,36150 +ansible/modules/network/cloudengine/ce_netstream_global.pyc,, +ansible/modules/network/cloudengine/ce_netstream_template.py,sha256=M75nWncyIU-cBWzIfsxBOP2hSD5U-xdw1MIKdwm_UK8,15753 +ansible/modules/network/cloudengine/ce_netstream_template.pyc,, +ansible/modules/network/cloudengine/ce_ntp.py,sha256=BPGqhX8A6m5EhQrqlsOGuvpnmK0iCKeQqYVzkWuri1Q,20808 +ansible/modules/network/cloudengine/ce_ntp.pyc,, +ansible/modules/network/cloudengine/ce_ntp_auth.py,sha256=qBOw99ffZg0mgJVhIGXggxyDdlLhppEv6Cd4lqEBAeA,18447 +ansible/modules/network/cloudengine/ce_ntp_auth.pyc,, +ansible/modules/network/cloudengine/ce_ospf.py,sha256=NBADpS51QfySApMIM6dpAA2AVp1Nex-ENUTAAFJ9z8w,34549 +ansible/modules/network/cloudengine/ce_ospf.pyc,, +ansible/modules/network/cloudengine/ce_ospf_vrf.py,sha256=aJvjVRgLee4LZ_VJtlrV3urI05vnYF70sBerkEmLhLg,68757 +ansible/modules/network/cloudengine/ce_ospf_vrf.pyc,, +ansible/modules/network/cloudengine/ce_reboot.py,sha256=PM-eBWQW0MzP5n9wZ9k_MW6ynCpvSKhS81gyxY5uB3w,4237 +ansible/modules/network/cloudengine/ce_reboot.pyc,, +ansible/modules/network/cloudengine/ce_rollback.py,sha256=_d26BSN1N150URRy6_fxXZL8QhKajaPz7a3UvWJivro,16873 +ansible/modules/network/cloudengine/ce_rollback.pyc,, +ansible/modules/network/cloudengine/ce_sflow.py,sha256=F1pATaPx3SjWkIrgqKSv0XLR_e8PIrPVdoq46Stk4oA,51346 +ansible/modules/network/cloudengine/ce_sflow.pyc,, +ansible/modules/network/cloudengine/ce_snmp_community.py,sha256=1nv8pO0ERMvQH-z2qba5Rb9-wQDhplYd7Nvb3i2epDk,32872 +ansible/modules/network/cloudengine/ce_snmp_community.pyc,, +ansible/modules/network/cloudengine/ce_snmp_contact.py,sha256=XEPqWVmYW4zDJ5o3_q104iIV8unD4LLm9LQA8pzFKK8,6786 +ansible/modules/network/cloudengine/ce_snmp_contact.pyc,, +ansible/modules/network/cloudengine/ce_snmp_location.py,sha256=-MMPlLigiUdrdWYLCYB8oT2EPFuBFPXg4OYYjGXfYIA,6748 +ansible/modules/network/cloudengine/ce_snmp_location.pyc,, +ansible/modules/network/cloudengine/ce_snmp_target_host.py,sha256=qfGVOHraqB6rEvHCjXyghQ2_rdXthGq1NXk1sRUYPi4,32039 +ansible/modules/network/cloudengine/ce_snmp_target_host.pyc,, +ansible/modules/network/cloudengine/ce_snmp_traps.py,sha256=cvhdaLJPqBYbwg_AQu54YM7_SSMa5CsIdAXt8KeqfU0,19349 +ansible/modules/network/cloudengine/ce_snmp_traps.pyc,, +ansible/modules/network/cloudengine/ce_snmp_user.py,sha256=3PxbJHVYHcYFkB9PMXMiZfySfn-xz9We9vISy9wjvtw,38903 +ansible/modules/network/cloudengine/ce_snmp_user.pyc,, +ansible/modules/network/cloudengine/ce_startup.py,sha256=_jw8iHLKm5HETxNkJotN0usC0dxTSIRBjR40xGlEvAI,15263 +ansible/modules/network/cloudengine/ce_startup.pyc,, +ansible/modules/network/cloudengine/ce_static_route.py,sha256=7rfQW8FQlJU8p2D76lVFDWpK-q6dTIe4GE6n4U2sQ3Q,29478 +ansible/modules/network/cloudengine/ce_static_route.pyc,, +ansible/modules/network/cloudengine/ce_stp.py,sha256=YB0VdoWt9M21t3An1lNu_xyA_9B15Wriw0pYue4VtLQ,36991 +ansible/modules/network/cloudengine/ce_stp.pyc,, +ansible/modules/network/cloudengine/ce_switchport.py,sha256=k-srKOK3eLDgoj458_--3Y01H7YqqCgMiE3h_8hRcD0,27435 +ansible/modules/network/cloudengine/ce_switchport.pyc,, +ansible/modules/network/cloudengine/ce_vlan.py,sha256=Dcxp_KlN1xysS_YS5MtPd_AENGiRk1VUtq_E5fJTDco,20922 +ansible/modules/network/cloudengine/ce_vlan.pyc,, +ansible/modules/network/cloudengine/ce_vrf.py,sha256=ZnnPzZ2PEHUatfDmHBw_HDICQ5-cD1e7QrmeSus4sz8,10803 +ansible/modules/network/cloudengine/ce_vrf.pyc,, +ansible/modules/network/cloudengine/ce_vrf_af.py,sha256=pEZiyw-bexQnulZGh71Cl6jd10Eqms81QZIV1qkTVek,30343 +ansible/modules/network/cloudengine/ce_vrf_af.pyc,, +ansible/modules/network/cloudengine/ce_vrf_interface.py,sha256=3jMo6ycCi4fC5YqhcPPQLlCFellIw-AituZANBzRYeg,15571 +ansible/modules/network/cloudengine/ce_vrf_interface.pyc,, +ansible/modules/network/cloudengine/ce_vrrp.py,sha256=aP-b0z0VruJNDLQD1tLYY-RzVjNJAdBUoV-tHCQr7qI,54601 +ansible/modules/network/cloudengine/ce_vrrp.pyc,, +ansible/modules/network/cloudengine/ce_vxlan_arp.py,sha256=4eGWS001VtjB4YHL7jwdj3mbUV-ocA_nb4V1xiGdSZI,23695 +ansible/modules/network/cloudengine/ce_vxlan_arp.pyc,, +ansible/modules/network/cloudengine/ce_vxlan_gateway.py,sha256=7ztc7YyUY6tmJUKhf01YA9ItVGM5-aKycQJdm3OEszM,33800 +ansible/modules/network/cloudengine/ce_vxlan_gateway.pyc,, +ansible/modules/network/cloudengine/ce_vxlan_global.py,sha256=AMRxoltq_OrsWeOM_NjRFDate8Gdd-UPZ8MGprctMfo,18761 +ansible/modules/network/cloudengine/ce_vxlan_global.pyc,, +ansible/modules/network/cloudengine/ce_vxlan_tunnel.py,sha256=ZxTHAGhA1Tvk8X4cMqfh8OQIF29_LcPaCswfFSEMIeE,31157 +ansible/modules/network/cloudengine/ce_vxlan_tunnel.pyc,, +ansible/modules/network/cloudengine/ce_vxlan_vap.py,sha256=a5CO-oYfrCQthMQj_x-SiOJh8xkJu0NmzJCfhQnzDjk,34126 +ansible/modules/network/cloudengine/ce_vxlan_vap.pyc,, +ansible/modules/network/cloudvision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/cloudvision/__init__.pyc,, +ansible/modules/network/cloudvision/cv_server_provision.py,sha256=9V-Z1C9Yb0k2NUnyCE3vqX9YvMKWb_qFCPCfOjETLLo,24361 +ansible/modules/network/cloudvision/cv_server_provision.pyc,, +ansible/modules/network/cnos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/cnos/__init__.pyc,, +ansible/modules/network/cnos/cnos_backup.py,sha256=PKH_N-ED2PXZtcVzn5vP-ZYJzUV4bxKytOv-WI2s13k,9976 +ansible/modules/network/cnos/cnos_backup.pyc,, +ansible/modules/network/cnos/cnos_bgp.py,sha256=tJn7Y7X7rapA4Q13-fH-ZI2xIdGfbWSiuGokIy9L_hA,44107 +ansible/modules/network/cnos/cnos_bgp.pyc,, +ansible/modules/network/cnos/cnos_command.py,sha256=z3GHiU5tsBpcONjwvnTYa6tmOwctK1WzdC9hvr2MgSs,8463 +ansible/modules/network/cnos/cnos_command.pyc,, +ansible/modules/network/cnos/cnos_conditional_command.py,sha256=EJNbCI--Bybty3mFISvpvqCGrxtT45gPjP40GbqxG6g,5851 +ansible/modules/network/cnos/cnos_conditional_command.pyc,, +ansible/modules/network/cnos/cnos_conditional_template.py,sha256=5ReAJ4rVpxefsidk5bdgEBdUX1shhwCV8zhHe5hxQBg,6938 +ansible/modules/network/cnos/cnos_conditional_template.pyc,, +ansible/modules/network/cnos/cnos_config.py,sha256=CCMBtseYeDqCJSLaNlJ_w2d_Yi23G7xdpKvR2SzlBI8,11557 +ansible/modules/network/cnos/cnos_config.pyc,, +ansible/modules/network/cnos/cnos_factory.py,sha256=k6g00D0MnoK7_pzuhBILwRRztFGW0JsgZcmBj7Vz4Y0,3534 +ansible/modules/network/cnos/cnos_factory.pyc,, +ansible/modules/network/cnos/cnos_facts.py,sha256=cIRIN93fXXbj9GMq9PBrsRuA_bo7lE10Twyp67XQP4w,19997 +ansible/modules/network/cnos/cnos_facts.pyc,, +ansible/modules/network/cnos/cnos_image.py,sha256=PayAWld4y2FL5Dnb5dg9EH5vDadM0UdR0fmk3oJB5_w,8925 +ansible/modules/network/cnos/cnos_image.pyc,, +ansible/modules/network/cnos/cnos_interface.py,sha256=QR-nKa4dgXb3ki4_82aajBnZElcjSVPmFNoZEMEtUGY,18503 +ansible/modules/network/cnos/cnos_interface.pyc,, +ansible/modules/network/cnos/cnos_portchannel.py,sha256=PQb14kbmoxAbO3b3IXWLFQFbF9twJK7h89vCTeP5dT8,17312 +ansible/modules/network/cnos/cnos_portchannel.pyc,, +ansible/modules/network/cnos/cnos_reload.py,sha256=W4z_BzqEwWUOLjYdu9P2_5m_zRRM38e84I951bdjI7E,3423 +ansible/modules/network/cnos/cnos_reload.pyc,, +ansible/modules/network/cnos/cnos_rollback.py,sha256=opB2Q_0Tzq-oAySvxMO41lBTZNyjcy_Lai7Vvhy9t4g,10667 +ansible/modules/network/cnos/cnos_rollback.pyc,, +ansible/modules/network/cnos/cnos_save.py,sha256=LwWGTDaA-IH5lxOZE_n9yf4r1Mueg_GdfaUvVgBBWNg,3602 +ansible/modules/network/cnos/cnos_save.pyc,, +ansible/modules/network/cnos/cnos_showrun.py,sha256=iEmsEN-c9dLXS0iQWrDbKxg5qxYwVPkUSoSBp7-oWR0,3517 +ansible/modules/network/cnos/cnos_showrun.pyc,, +ansible/modules/network/cnos/cnos_template.py,sha256=Ww1oPeTV2s0uX4kQII9zk_2retZxYjAM-yEFfcdeYNU,5468 +ansible/modules/network/cnos/cnos_template.pyc,, +ansible/modules/network/cnos/cnos_vlag.py,sha256=JWouflu34HNlRI1DNHap5zST7BWjF7elAhOUhDMuylw,15347 +ansible/modules/network/cnos/cnos_vlag.pyc,, +ansible/modules/network/cnos/cnos_vlan.py,sha256=sbSSwzKAx8U1RagrKFHuBVOIBUUAxQAQz07KF27NAIU,20029 +ansible/modules/network/cnos/cnos_vlan.pyc,, +ansible/modules/network/cumulus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/cumulus/__init__.pyc,, +ansible/modules/network/cumulus/_cl_bond.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_bond.pyc,, +ansible/modules/network/cumulus/_cl_bridge.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_bridge.pyc,, +ansible/modules/network/cumulus/_cl_img_install.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_img_install.pyc,, +ansible/modules/network/cumulus/_cl_interface.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_interface.pyc,, +ansible/modules/network/cumulus/_cl_interface_policy.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_interface_policy.pyc,, +ansible/modules/network/cumulus/_cl_license.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_license.pyc,, +ansible/modules/network/cumulus/_cl_ports.py,sha256=2jbKrWOFSO6Vk75IoeVcPZJ_biJX6CXCHBCAD1wP57k,554 +ansible/modules/network/cumulus/_cl_ports.pyc,, +ansible/modules/network/cumulus/nclu.py,sha256=jMcSrIO3ATN41FjV3KK-I5TUr6Rn_IgfGL6e5RC6Ag8,7544 +ansible/modules/network/cumulus/nclu.pyc,, +ansible/modules/network/dellos10/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/dellos10/__init__.pyc,, +ansible/modules/network/dellos10/dellos10_command.py,sha256=VpFw1Tc-Hi_49BkqMi1qGJFcgy6WkMc2VmxuIFcyk2A,7197 +ansible/modules/network/dellos10/dellos10_command.pyc,, +ansible/modules/network/dellos10/dellos10_config.py,sha256=A0jHN1zl5s3i0nW4Rpsg1scjydFGA1lzpv599pO3-r4,11607 +ansible/modules/network/dellos10/dellos10_config.pyc,, +ansible/modules/network/dellos10/dellos10_facts.py,sha256=oNIBJmEKDcgNn-DOu1DAy6gUG1oPLFfVAYpGJncjbqg,15173 +ansible/modules/network/dellos10/dellos10_facts.pyc,, +ansible/modules/network/dellos6/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/dellos6/__init__.pyc,, +ansible/modules/network/dellos6/dellos6_command.py,sha256=z9LPBTdYa9avDyv51OHWF4iaV0mNKfKI5USan72oiZU,7161 +ansible/modules/network/dellos6/dellos6_command.pyc,, +ansible/modules/network/dellos6/dellos6_config.py,sha256=-9bbvUyc4wmF19s05zL1rlk8gZ2dC_Z3QE2zn517iro,11504 +ansible/modules/network/dellos6/dellos6_config.pyc,, +ansible/modules/network/dellos6/dellos6_facts.py,sha256=ciHgXDvnpqdHD4Vc4PzruME-UpTbHqPZjvlxiVVmgcI,14237 +ansible/modules/network/dellos6/dellos6_facts.pyc,, +ansible/modules/network/dellos9/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/dellos9/__init__.pyc,, +ansible/modules/network/dellos9/dellos9_command.py,sha256=9U8CrV0IH6r2Y6g2tQokTz9PLw1OMeM-3oWgfUS4YSQ,7456 +ansible/modules/network/dellos9/dellos9_command.pyc,, +ansible/modules/network/dellos9/dellos9_config.py,sha256=GoEkTHvKTuWkwPSQKLjHgH7PPxi6BjyPSjcsI1ta4FI,11967 +ansible/modules/network/dellos9/dellos9_config.pyc,, +ansible/modules/network/dellos9/dellos9_facts.py,sha256=gpDC0HcD7uKKB34MbPCIzXWX7OpHQSCcNysFO-6lLgE,17592 +ansible/modules/network/dellos9/dellos9_facts.pyc,, +ansible/modules/network/edgeos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/edgeos/__init__.pyc,, +ansible/modules/network/edgeos/edgeos_command.py,sha256=t2BcL8vmHwVG3PYRBOc93TdMHoKlUUxwLcAsojCzJGc,6080 +ansible/modules/network/edgeos/edgeos_command.pyc,, +ansible/modules/network/edgeos/edgeos_config.py,sha256=5rRe6Af51WstwCSBDqjcsiNC1DWng2MJe00evEAAFpE,9204 +ansible/modules/network/edgeos/edgeos_config.pyc,, +ansible/modules/network/edgeos/edgeos_facts.py,sha256=yOooS3rklicr7l1rB111fomGt8Ofbx-9LrBgEZer7sw,8337 +ansible/modules/network/edgeos/edgeos_facts.pyc,, +ansible/modules/network/enos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/enos/__init__.pyc,, +ansible/modules/network/enos/enos_command.py,sha256=GneSFgEy2-ax_5ypZT4UlQLucwyHs0--9ORgQzf5j98,6472 +ansible/modules/network/enos/enos_command.pyc,, +ansible/modules/network/enos/enos_config.py,sha256=S31sKbylBaty0MRtIehlkR6kGgnw0mJ4Y0WKgCTbUbI,9575 +ansible/modules/network/enos/enos_config.pyc,, +ansible/modules/network/enos/enos_facts.py,sha256=aAYLBwKxzR676rZdpCgpM4nQm9N67QzI1s_E-Rv5Rts,15756 +ansible/modules/network/enos/enos_facts.pyc,, +ansible/modules/network/eos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/eos/__init__.pyc,, +ansible/modules/network/eos/eos_banner.py,sha256=27ny-F28PkwFb6tp54XNkc18emwWRfn8Hdc7xc-jwCw,6284 +ansible/modules/network/eos/eos_banner.pyc,, +ansible/modules/network/eos/eos_command.py,sha256=iCzDG2tZlwiMuZiUF1vWmw-Uur3UZMcVfneZITGQpks,8519 +ansible/modules/network/eos/eos_command.pyc,, +ansible/modules/network/eos/eos_config.py,sha256=CjtvkKcW3DReoluqUwC_-r_kG1bWprs90xuuVyaR9ZY,19586 +ansible/modules/network/eos/eos_config.pyc,, +ansible/modules/network/eos/eos_eapi.py,sha256=IphAlBsTv1wHNFUqwR4VsbfxUa1dn2yw-hnrzJ24MVE,14834 +ansible/modules/network/eos/eos_eapi.pyc,, +ansible/modules/network/eos/eos_facts.py,sha256=c-WxKXxCqyVfPmjizv1SGGz6Z3_uGLNTUhVjU8X53pM,10981 +ansible/modules/network/eos/eos_facts.pyc,, +ansible/modules/network/eos/eos_interface.py,sha256=9GcJrhUPCVHlqlmK2eeBN6JADm7OvYzMhaYbdCf5-I8,15155 +ansible/modules/network/eos/eos_interface.pyc,, +ansible/modules/network/eos/eos_l2_interface.py,sha256=ZdRnoujgN00VQ6p2HIEvLornrxsMKPUm7Z-hD95Uc9M,10670 +ansible/modules/network/eos/eos_l2_interface.pyc,, +ansible/modules/network/eos/eos_l3_interface.py,sha256=PZsWjMnGu65oh-e43g5T7BDziDeGqy_sVpeYw6YwMXU,9077 +ansible/modules/network/eos/eos_l3_interface.pyc,, +ansible/modules/network/eos/eos_linkagg.py,sha256=KkX2hUFrO-6VGYc52yrXNyjUUdhynBM61Ec2GAjtnG8,10540 +ansible/modules/network/eos/eos_linkagg.pyc,, +ansible/modules/network/eos/eos_lldp.py,sha256=8JF7hYpXjZr4KM1RL4gJi8jnrvgPP7Wjz2g1UfG1uX8,2962 +ansible/modules/network/eos/eos_lldp.pyc,, +ansible/modules/network/eos/eos_logging.py,sha256=9lPzS2oKMAxIOqBXQRgbgxC53iZV1Qtsj3khKNAvJRM,11827 +ansible/modules/network/eos/eos_logging.pyc,, +ansible/modules/network/eos/eos_static_route.py,sha256=LjuBLKhXDO31mlnHG9jKjuqeNHLCmFCEh_Fj5RU-KO8,7483 +ansible/modules/network/eos/eos_static_route.pyc,, +ansible/modules/network/eos/eos_system.py,sha256=aLEVYsG95O4KLTffbAWGc2XhEPOGUPEDTPKQHkfBc4A,11456 +ansible/modules/network/eos/eos_system.pyc,, +ansible/modules/network/eos/eos_user.py,sha256=ZwhkZgLvDqDv6UE2nozaqGeOh3JkdBF36DYBelSMdYE,13203 +ansible/modules/network/eos/eos_user.pyc,, +ansible/modules/network/eos/eos_vlan.py,sha256=N047PNHX849BiWcoQmykyzq0wLmeGqv5Tug24eEBwmc,11418 +ansible/modules/network/eos/eos_vlan.pyc,, +ansible/modules/network/eos/eos_vrf.py,sha256=i4k0UO5spTUTRGJqRR0d_eozC2GI0Jj5p2i0Fz9Thcg,10745 +ansible/modules/network/eos/eos_vrf.pyc,, +ansible/modules/network/exos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/exos/__init__.pyc,, +ansible/modules/network/exos/exos_command.py,sha256=ZvME5p9OGjnlQ0H-IMNqUBMfx0liYXZyeVddProcKFs,7945 +ansible/modules/network/exos/exos_command.pyc,, +ansible/modules/network/exos/exos_config.py,sha256=45ZUkQbJ6ECqZ39N1JQq_grf7z03xrvEBnH4YClR1AI,16047 +ansible/modules/network/exos/exos_config.pyc,, +ansible/modules/network/exos/exos_facts.py,sha256=QBzomwNTK73Im7zKcTE7SkCec2SNwtcKOq-jTY2elKM,13983 +ansible/modules/network/exos/exos_facts.pyc,, +ansible/modules/network/f5/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/f5/__init__.pyc,, +ansible/modules/network/f5/_bigip_facts.py,sha256=834BRVPjn1SBMPx-6vI8mRgDGhx17kd9KIFyO6XtmNs,65279 +ansible/modules/network/f5/_bigip_facts.pyc,, +ansible/modules/network/f5/_bigip_gtm_facts.py,sha256=9O63UQ31E25rPYNUiYkd6k6a8dez7bT8umImzL3THXY,31448 +ansible/modules/network/f5/_bigip_gtm_facts.pyc,, +ansible/modules/network/f5/_bigip_security_address_list.py,sha256=2Vv7ubesyacAfxUD7EbZ9y-iduPvg8WH-fSzaMuCrIk,30204 +ansible/modules/network/f5/_bigip_security_address_list.pyc,, +ansible/modules/network/f5/_bigip_security_port_list.py,sha256=L175p138E9d4LUwgBTmXdXqfNvM2yBZU322BrWX00Ac,17550 +ansible/modules/network/f5/_bigip_security_port_list.pyc,, +ansible/modules/network/f5/bigip_appsvcs_extension.py,sha256=wRJervHtbt1fHfqJYUBZWK-9zT2n0ZuhwCYrX5wQO2o,15556 +ansible/modules/network/f5/bigip_appsvcs_extension.pyc,, +ansible/modules/network/f5/bigip_asm_policy.py,sha256=Rm_u-LnihPom2nj710uWehKBBDpEj3TBGEq_kHB7xeA,31542 +ansible/modules/network/f5/bigip_asm_policy.pyc,, +ansible/modules/network/f5/bigip_cli_alias.py,sha256=JMGupWDMuPtZPMEP5iLiSQJ-nm03YuLOZVVejhNMkBc,12168 +ansible/modules/network/f5/bigip_cli_alias.pyc,, +ansible/modules/network/f5/bigip_cli_script.py,sha256=Kp0suPBW2VTvAGu5kOFEHyy5vNpibnHqYUKK2q6R3a0,14006 +ansible/modules/network/f5/bigip_cli_script.pyc,, +ansible/modules/network/f5/bigip_command.py,sha256=2cMNSEqDbyM_YURLloqSIsV5pev6TKqi1DRj8THk034,24038 +ansible/modules/network/f5/bigip_command.pyc,, +ansible/modules/network/f5/bigip_config.py,sha256=AupO7wnzcduG7cwYU_iLiriHLgXqawLHWxNyvTThjJg,10925 +ansible/modules/network/f5/bigip_config.pyc,, +ansible/modules/network/f5/bigip_configsync_action.py,sha256=_2qm24czxrOmk9QdD8RfNKV8I-gs7yB20eyjs2Vbam4,12415 +ansible/modules/network/f5/bigip_configsync_action.pyc,, +ansible/modules/network/f5/bigip_data_group.py,sha256=VaHtZah4W0OakSa_G8ndEyGuvMhYUWDXzp3zFN66aHE,37181 +ansible/modules/network/f5/bigip_data_group.pyc,, +ansible/modules/network/f5/bigip_device_auth.py,sha256=8Tblj22xzlHE3vCMZ140ZENTW9r0cSrxtYw6gOakMz0,24796 +ansible/modules/network/f5/bigip_device_auth.pyc,, +ansible/modules/network/f5/bigip_device_connectivity.py,sha256=GRV6Jee9jaVMqZmEdPVW8aZuFbojLywdyT20RAzOlRM,21097 +ansible/modules/network/f5/bigip_device_connectivity.pyc,, +ansible/modules/network/f5/bigip_device_dns.py,sha256=ejRfcdVgoA-R9RUFZjWUHuE4iVLJhHstdbv53NfrYuA,10741 +ansible/modules/network/f5/bigip_device_dns.pyc,, +ansible/modules/network/f5/bigip_device_facts.py,sha256=1JuMHclyj-iHwA4eK2SFMApMB-gokCBH_q4Gu6gIcKs,422115 +ansible/modules/network/f5/bigip_device_facts.pyc,, +ansible/modules/network/f5/bigip_device_group.py,sha256=uf-_SOJdQR-M2DJ36scfRl1VjvkEbkHkQ3suMucMBO4,17392 +ansible/modules/network/f5/bigip_device_group.pyc,, +ansible/modules/network/f5/bigip_device_group_member.py,sha256=84lrgM4K3RNV-JVFYUynon5g0A2KfFttP8_vD03-2s4,7479 +ansible/modules/network/f5/bigip_device_group_member.pyc,, +ansible/modules/network/f5/bigip_device_httpd.py,sha256=rcv4hUqhJMoJ93-7DsMsJ7LGQY6_gI5X4QPPDK6dA88,22148 +ansible/modules/network/f5/bigip_device_httpd.pyc,, +ansible/modules/network/f5/bigip_device_license.py,sha256=jG8KzspkMn7c5NQURp9nmhBBRpsDZ-VTqg8Aks-SC4g,22363 +ansible/modules/network/f5/bigip_device_license.pyc,, +ansible/modules/network/f5/bigip_device_ntp.py,sha256=NRdn5ru1_ycmMD3F8WjJxEclRsdCuvEfpQd4mkLoVb0,7943 +ansible/modules/network/f5/bigip_device_ntp.pyc,, +ansible/modules/network/f5/bigip_device_sshd.py,sha256=l31-2_5GLlgN7Q2rJQNuHvoYDvW2w_3pJ5_oxooauFM,10017 +ansible/modules/network/f5/bigip_device_sshd.pyc,, +ansible/modules/network/f5/bigip_device_trust.py,sha256=3ABe4YkgSVw1i1esEMQgsCP3baa5VLs8YqcZdElHj0k,11178 +ansible/modules/network/f5/bigip_device_trust.pyc,, +ansible/modules/network/f5/bigip_firewall_address_list.py,sha256=2Vv7ubesyacAfxUD7EbZ9y-iduPvg8WH-fSzaMuCrIk,30204 +ansible/modules/network/f5/bigip_firewall_address_list.pyc,, +ansible/modules/network/f5/bigip_firewall_dos_profile.py,sha256=8gfhfadARTaDGZ6k7mUSPN1pEW5z1xIaqql-gzZtVL4,13169 +ansible/modules/network/f5/bigip_firewall_dos_profile.pyc,, +ansible/modules/network/f5/bigip_firewall_policy.py,sha256=YVk6wpD68m0N0U2zSd_Tia61zyQzbpBYhpTp3WLFdjM,17264 +ansible/modules/network/f5/bigip_firewall_policy.pyc,, +ansible/modules/network/f5/bigip_firewall_port_list.py,sha256=L175p138E9d4LUwgBTmXdXqfNvM2yBZU322BrWX00Ac,17550 +ansible/modules/network/f5/bigip_firewall_port_list.pyc,, +ansible/modules/network/f5/bigip_firewall_rule.py,sha256=ji2ENIK9mg8Xv8Qk8ZKB6ZkG1KNLHFncYIz6xSYwJA0,38683 +ansible/modules/network/f5/bigip_firewall_rule.pyc,, +ansible/modules/network/f5/bigip_firewall_rule_list.py,sha256=UclZGQ7_rxydgLYC4ln7gSTJDo2dUGGpDZEP40kDiMU,17291 +ansible/modules/network/f5/bigip_firewall_rule_list.pyc,, +ansible/modules/network/f5/bigip_gtm_datacenter.py,sha256=bOB2Z2-YzRO-S9-mjqqmod5eEe7zH8C1Ec7NE8y9q4w,13189 +ansible/modules/network/f5/bigip_gtm_datacenter.pyc,, +ansible/modules/network/f5/bigip_gtm_global.py,sha256=CM9lVBwMMWumFMZSyjGBdPDuG5BcOmUqv0pweE7xonw,10178 +ansible/modules/network/f5/bigip_gtm_global.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_bigip.py,sha256=qXbqRHAr-5Waj2Q4kFb1vncQ9jiBnijck8GCN9dgpAA,19899 +ansible/modules/network/f5/bigip_gtm_monitor_bigip.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_external.py,sha256=eO9vUJB29nUgmcxxczc8SJMYNxnbvOJQ67DO4RKp9iE,20272 +ansible/modules/network/f5/bigip_gtm_monitor_external.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_firepass.py,sha256=uPmozD-ZAWyJK4JNdDW1XWhZrOvRVOAWj5W9JYM3_9g,23540 +ansible/modules/network/f5/bigip_gtm_monitor_firepass.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_http.py,sha256=I5cqWi4oaMFg15ArbzBbPB6W2uq97MV1CWQZlQDxAps,24152 +ansible/modules/network/f5/bigip_gtm_monitor_http.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_https.py,sha256=4xxH9sjyvwqHx8v0bIUpQde1Rh9W-NkOVaL6y46F3XI,27929 +ansible/modules/network/f5/bigip_gtm_monitor_https.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_tcp.py,sha256=jmmHSHqZWLrepicYOrgYU-CIzLW0TF-_G0H54bzu9us,22770 +ansible/modules/network/f5/bigip_gtm_monitor_tcp.pyc,, +ansible/modules/network/f5/bigip_gtm_monitor_tcp_half_open.py,sha256=rSabJRPF-04Z0LJJYCFMjPXMAwVXGoMxAMIGG0bYDAE,21377 +ansible/modules/network/f5/bigip_gtm_monitor_tcp_half_open.pyc,, +ansible/modules/network/f5/bigip_gtm_pool.py,sha256=7H3u9hmXLKc3rz4igvtauyNHTYu1iT3N3fBynD41-Cg,36811 +ansible/modules/network/f5/bigip_gtm_pool.pyc,, +ansible/modules/network/f5/bigip_gtm_pool_member.py,sha256=HQ0XXSe9xvZCZ33WpAEWzFu5OL9fFa2dStq57hHCiww,21512 +ansible/modules/network/f5/bigip_gtm_pool_member.pyc,, +ansible/modules/network/f5/bigip_gtm_server.py,sha256=g7Ut8gmFOYDXfXTC3MTjUABZRqan62nsRLW0ZBaMSR4,31450 +ansible/modules/network/f5/bigip_gtm_server.pyc,, +ansible/modules/network/f5/bigip_gtm_virtual_server.py,sha256=Wa3E45dglGCFEsUey2uGv08uyvMxmWx1LNvTMnoDxW4,37162 +ansible/modules/network/f5/bigip_gtm_virtual_server.pyc,, +ansible/modules/network/f5/bigip_gtm_wide_ip.py,sha256=ktzb_QJUA5QGUPmC8hGYT0k4pmHlFu6KuWpbKwJTfM8,24464 +ansible/modules/network/f5/bigip_gtm_wide_ip.pyc,, +ansible/modules/network/f5/bigip_hostname.py,sha256=ZEEOvmOxjb3IWGbikZSwv39gaSSDG8m4ae_Wgm2czpg,7419 +ansible/modules/network/f5/bigip_hostname.pyc,, +ansible/modules/network/f5/bigip_iapp_service.py,sha256=guI1Pe9uJ6daFKvHg3-Blm5wYeIlXk4Dx6mVPT1_7Mw,28259 +ansible/modules/network/f5/bigip_iapp_service.pyc,, +ansible/modules/network/f5/bigip_iapp_template.py,sha256=phdyd2oC8tKScCLMANzjEaW-AcKQ-P7OPJIGNEks80c,15691 +ansible/modules/network/f5/bigip_iapp_template.pyc,, +ansible/modules/network/f5/bigip_iapplx_package.py,sha256=1NgP5frWToYSeekxwzWS254ZL2oHOgDxVwYG65ho5cE,11731 +ansible/modules/network/f5/bigip_iapplx_package.pyc,, +ansible/modules/network/f5/bigip_irule.py,sha256=Rcxblsvf-34WEYdIwsz72MX3fndXaMM2m45wzLf6xaw,12644 +ansible/modules/network/f5/bigip_irule.pyc,, +ansible/modules/network/f5/bigip_log_destination.py,sha256=nXm9LjdIW08qLyo7g6Ms4W6-LLnIiYfp9E5GyIsuBlY,22231 +ansible/modules/network/f5/bigip_log_destination.pyc,, +ansible/modules/network/f5/bigip_log_publisher.py,sha256=HArOZQ4v3dVieCNoR6qZjPVMRNnrsxOVFrAUvWl7g20,11406 +ansible/modules/network/f5/bigip_log_publisher.pyc,, +ansible/modules/network/f5/bigip_management_route.py,sha256=2kUq2LD1fObv2ALL_jnrKSdvJ31CH_u6C-YbT-09JM0,12049 +ansible/modules/network/f5/bigip_management_route.pyc,, +ansible/modules/network/f5/bigip_monitor_dns.py,sha256=Tqne1E93yTthNepXkDtR2hziQIHIF2gYNmQsQECE2kQ,35164 +ansible/modules/network/f5/bigip_monitor_dns.pyc,, +ansible/modules/network/f5/bigip_monitor_external.py,sha256=pP1spIuRnqc2OBcgXmGW-_G9qLxtuJiPcvoSgqOeVLQ,22421 +ansible/modules/network/f5/bigip_monitor_external.pyc,, +ansible/modules/network/f5/bigip_monitor_http.py,sha256=wbtYPHEEE8QoeImMR8XAK5hxHdzZPNYtIwa4X1rziMY,20817 +ansible/modules/network/f5/bigip_monitor_http.pyc,, +ansible/modules/network/f5/bigip_monitor_https.py,sha256=5tn8efyoKLre8vWWP2t8ua6dtBJzITH_Rjs7BcMwW2A,20578 +ansible/modules/network/f5/bigip_monitor_https.pyc,, +ansible/modules/network/f5/bigip_monitor_snmp_dca.py,sha256=NqDWB-i7xO4TC2TfZoNZXaFH8rIxi27Dd0xHmPd15H8,23334 +ansible/modules/network/f5/bigip_monitor_snmp_dca.pyc,, +ansible/modules/network/f5/bigip_monitor_tcp.py,sha256=GVqTRvf3WMouqSgzg2kjoRVo-MiHJEjQEaO7iwFXoPM,19852 +ansible/modules/network/f5/bigip_monitor_tcp.pyc,, +ansible/modules/network/f5/bigip_monitor_tcp_echo.py,sha256=FeCx130PGPZGwB58Y4g6UY6nVo-JDvN8B1g4TErLEz0,18107 +ansible/modules/network/f5/bigip_monitor_tcp_echo.pyc,, +ansible/modules/network/f5/bigip_monitor_tcp_half_open.py,sha256=rUC_aA_rvHKhsuBDPR2ZC467qpjvwlXwl3JGfUWgTSw,19787 +ansible/modules/network/f5/bigip_monitor_tcp_half_open.pyc,, +ansible/modules/network/f5/bigip_monitor_udp.py,sha256=DvkW7-hM-gRp-IRwGXjJKgGBrHp8rtmP5b3IK0Dmiu8,19752 +ansible/modules/network/f5/bigip_monitor_udp.pyc,, +ansible/modules/network/f5/bigip_node.py,sha256=i2BsR4daU7pVeb_nnMHwEaTjr6LW54djS_ZrTBJFsMQ,37524 +ansible/modules/network/f5/bigip_node.pyc,, +ansible/modules/network/f5/bigip_partition.py,sha256=cu5tsTgcj5Top7Y4W0ubDzOWlYLx1xM75b0MBIVvITQ,9992 +ansible/modules/network/f5/bigip_partition.pyc,, +ansible/modules/network/f5/bigip_policy.py,sha256=79fwxVgkvk-_wIdmE9DOn5HBizGZc292GsnJu-uf2ME,25335 +ansible/modules/network/f5/bigip_policy.pyc,, +ansible/modules/network/f5/bigip_policy_rule.py,sha256=BXMRTdGiUpCV1buQrM_SicpySDByNt8iY-IfgbuPhpo,27768 +ansible/modules/network/f5/bigip_policy_rule.pyc,, +ansible/modules/network/f5/bigip_pool.py,sha256=AXMMFk70LBjz8Nu4qAKdnlQKPottraB5te6IfGca7RY,29505 +ansible/modules/network/f5/bigip_pool.pyc,, +ansible/modules/network/f5/bigip_pool_member.py,sha256=ScJ5otky-XCzmVLebxYW1qmk0QxQIWFaZAsJ-7-wO0Y,26646 +ansible/modules/network/f5/bigip_pool_member.pyc,, +ansible/modules/network/f5/bigip_profile_client_ssl.py,sha256=9KXoj9D3ULo48P3nDRiVJ92DNe-fIPUCfCS_L_OtZfQ,22997 +ansible/modules/network/f5/bigip_profile_client_ssl.pyc,, +ansible/modules/network/f5/bigip_profile_dns.py,sha256=rqgQ0d1GJdxwqat6U5k3XrTdCkZy-lCXcW9UMsaHDPw,23317 +ansible/modules/network/f5/bigip_profile_dns.pyc,, +ansible/modules/network/f5/bigip_profile_http.py,sha256=aNZUbwwXyisElOd2_b1grT_RjXFo0jVPD9FCHJncTGU,21966 +ansible/modules/network/f5/bigip_profile_http.pyc,, +ansible/modules/network/f5/bigip_profile_http_compression.py,sha256=xd0iqpDqa9_tOIpHOydxp2pFd3DTFEHmzOdsQiRtWX4,16139 +ansible/modules/network/f5/bigip_profile_http_compression.pyc,, +ansible/modules/network/f5/bigip_profile_oneconnect.py,sha256=gY_qnMcaJpJU6LBsE_nIYHmKjQGnn5H0-ELKsvQvwtY,18524 +ansible/modules/network/f5/bigip_profile_oneconnect.pyc,, +ansible/modules/network/f5/bigip_profile_persistence_src_addr.py,sha256=yaGs8uQ3r3HgNwb23uBf0Li4xYF8ZPOmm0zHeMFqo0Y,18384 +ansible/modules/network/f5/bigip_profile_persistence_src_addr.pyc,, +ansible/modules/network/f5/bigip_profile_tcp.py,sha256=FoCmaEemkuqsnf3ZxKM0CipChT-QqXS_sqJPORA2xyA,13547 +ansible/modules/network/f5/bigip_profile_tcp.pyc,, +ansible/modules/network/f5/bigip_profile_udp.py,sha256=t37upM7UCupDsmIhYTVlYmiY-1tf4-jLKI315SxKTao,12817 +ansible/modules/network/f5/bigip_profile_udp.pyc,, +ansible/modules/network/f5/bigip_provision.py,sha256=FOwoKxGlH33Cv7wMXdv558s2M9uW1TbBLAaORFLzW0g,20218 +ansible/modules/network/f5/bigip_provision.pyc,, +ansible/modules/network/f5/bigip_qkview.py,sha256=1JJMywBRieQKzhczBe_4z5tg8Tyj9XDjnYD0xwosiLM,18597 +ansible/modules/network/f5/bigip_qkview.pyc,, +ansible/modules/network/f5/bigip_remote_role.py,sha256=j_z0fKdCdYvqMrA9cmiJGytsfCCkdBwZAKp_vh77aKo,18500 +ansible/modules/network/f5/bigip_remote_role.pyc,, +ansible/modules/network/f5/bigip_remote_syslog.py,sha256=XrmXgtBbX2kV-_EWFtHO5jUUcz29S4IZMQeQcYzzISU,14800 +ansible/modules/network/f5/bigip_remote_syslog.pyc,, +ansible/modules/network/f5/bigip_routedomain.py,sha256=RVn_An0N4p4CApmeA9e2uf2EI-w_2WAqBcPSQ-zwQJE,18355 +ansible/modules/network/f5/bigip_routedomain.pyc,, +ansible/modules/network/f5/bigip_selfip.py,sha256=df3jfDsErrKIVrYOckcSMzkIqNbJO9-LoHEqzxz4lLE,23297 +ansible/modules/network/f5/bigip_selfip.pyc,, +ansible/modules/network/f5/bigip_service_policy.py,sha256=UPWSkGFzXYjEINSbw2TXZAA15Vy5o9ilAIbO98viNHs,11898 +ansible/modules/network/f5/bigip_service_policy.pyc,, +ansible/modules/network/f5/bigip_smtp.py,sha256=6ntEggC7w6vRHYKwfcVsve47nqBUo3P0AazrzlMieKw,16396 +ansible/modules/network/f5/bigip_smtp.pyc,, +ansible/modules/network/f5/bigip_snat_pool.py,sha256=-9_xWvlQ6ldHedjGd64SFKMaT0YVrsIVfD_63LL2D2Q,11567 +ansible/modules/network/f5/bigip_snat_pool.pyc,, +ansible/modules/network/f5/bigip_snmp.py,sha256=UkOTdmqsdy0wJWZWWUXTrC2mO76YVcq2rSPxEQ3ji-o,12238 +ansible/modules/network/f5/bigip_snmp.pyc,, +ansible/modules/network/f5/bigip_snmp_community.py,sha256=j_BhVcO9Xe_Lxn3QVkWjPb399O_xrnFn49_wW4-eH2g,24929 +ansible/modules/network/f5/bigip_snmp_community.pyc,, +ansible/modules/network/f5/bigip_snmp_trap.py,sha256=HfwTtnbmC8xYHYtL_Si-JNkYBl4kHdT2E-XyQkZHKsw,17603 +ansible/modules/network/f5/bigip_snmp_trap.pyc,, +ansible/modules/network/f5/bigip_software_image.py,sha256=K9UH9dWtqcrTUc1LRXlBVsyb0tHqMybMvdRigKdGJjY,14441 +ansible/modules/network/f5/bigip_software_image.pyc,, +ansible/modules/network/f5/bigip_software_install.py,sha256=p_aexfFvzQgRkABGdWlx1MdlOtqOwFNcJ1fsfiwFDz4,15252 +ansible/modules/network/f5/bigip_software_install.pyc,, +ansible/modules/network/f5/bigip_software_update.py,sha256=Ufz_Us-T4Cme_5pMljtdWcZ2b-qDgIYQXvx2gtn2A-Q,9051 +ansible/modules/network/f5/bigip_software_update.pyc,, +ansible/modules/network/f5/bigip_ssl_certificate.py,sha256=zsbqolAjIEC7ouLUBMG7MT0LLyTXuK9fqM98PX5d1e0,14453 +ansible/modules/network/f5/bigip_ssl_certificate.pyc,, +ansible/modules/network/f5/bigip_ssl_key.py,sha256=hmwzKooxVN4k_aydahtrGrI_vhhw7wObw1b05aqMTMA,11899 +ansible/modules/network/f5/bigip_ssl_key.pyc,, +ansible/modules/network/f5/bigip_static_route.py,sha256=xeVBxsPWWVNrFxVXnQkF1ER74kD7-eEraFb15HpHucc,22130 +ansible/modules/network/f5/bigip_static_route.pyc,, +ansible/modules/network/f5/bigip_sys_db.py,sha256=urDX918hnMFqGdVcRgNUtmo1g2Qdq27j0zy6C5xADg8,8526 +ansible/modules/network/f5/bigip_sys_db.pyc,, +ansible/modules/network/f5/bigip_sys_global.py,sha256=8x0gZtrf0hmD5AK3hZ00Ahv9xo07LVhreOcEaX--4m8,12935 +ansible/modules/network/f5/bigip_sys_global.pyc,, +ansible/modules/network/f5/bigip_timer_policy.py,sha256=6tPmTUKMk78jner8sMPVl_Nl41dav36xEkE7rxhBPZg,18826 +ansible/modules/network/f5/bigip_timer_policy.pyc,, +ansible/modules/network/f5/bigip_traffic_group.py,sha256=ygJO0AVA3OILMxS0aAnCOLk6Hh0iBFVrhG5gCryY740,10595 +ansible/modules/network/f5/bigip_traffic_group.pyc,, +ansible/modules/network/f5/bigip_trunk.py,sha256=sh7K03jV0WVrLdNlo7KT5INh4akgYNUrjTHoZdbBT0Y,18842 +ansible/modules/network/f5/bigip_trunk.pyc,, +ansible/modules/network/f5/bigip_tunnel.py,sha256=qjrn4JKn6n7I4xIv0wuVIqx1Y2-vTxkUEMSPf8RJwC4,20377 +ansible/modules/network/f5/bigip_tunnel.pyc,, +ansible/modules/network/f5/bigip_ucs.py,sha256=4S6l_5adhAY5KSQnrwE7g2tdgIGbcsEnJGl5-W_BxGs,19948 +ansible/modules/network/f5/bigip_ucs.pyc,, +ansible/modules/network/f5/bigip_ucs_fetch.py,sha256=xC3X41caJ7FlLKUBiHXkUQgbW77HcQ70zU-zRqH9qfo,16013 +ansible/modules/network/f5/bigip_ucs_fetch.pyc,, +ansible/modules/network/f5/bigip_user.py,sha256=Bf-KARXP7BfueWSKeEim9nw-YmlpVe6AzktW1F0k8lc,22274 +ansible/modules/network/f5/bigip_user.pyc,, +ansible/modules/network/f5/bigip_vcmp_guest.py,sha256=cfHKBZclLdRhhLx5oS1goxTvNqqyKL6pYB7q56yl0xo,27144 +ansible/modules/network/f5/bigip_vcmp_guest.pyc,, +ansible/modules/network/f5/bigip_virtual_address.py,sha256=hb7umncfxo7mcJfxYwI0JWEAwrSM6Pm-wyCUvhI-8b4,29411 +ansible/modules/network/f5/bigip_virtual_address.pyc,, +ansible/modules/network/f5/bigip_virtual_server.py,sha256=BOHUo9bt5UgQaykMH-jAaQh_IAK2sPQTKxFiqL09Rv4,111367 +ansible/modules/network/f5/bigip_virtual_server.pyc,, +ansible/modules/network/f5/bigip_vlan.py,sha256=DQ8FJaJFiRyIiVW5nm9SWeNs_XGZITMXH2Pt1qr7rOo,19787 +ansible/modules/network/f5/bigip_vlan.pyc,, +ansible/modules/network/f5/bigip_wait.py,sha256=csbWA4b9Qqd5p1guyfslZOc_8Def7DEOvWb858r13mI,11339 +ansible/modules/network/f5/bigip_wait.pyc,, +ansible/modules/network/f5/bigiq_application_fasthttp.py,sha256=K1RR-EPjhEqUso0ic6CM7DspPYJppLqaXDND1uZzZGY,23439 +ansible/modules/network/f5/bigiq_application_fasthttp.pyc,, +ansible/modules/network/f5/bigiq_application_fastl4_tcp.py,sha256=pC2u3CmLR38PY4iU_TiWcByOalooxH1xa_7svJ-YzNM,21644 +ansible/modules/network/f5/bigiq_application_fastl4_tcp.pyc,, +ansible/modules/network/f5/bigiq_application_fastl4_udp.py,sha256=fBXil4fTlF73x0gQK39qmPAMuTNW8pciA43HgefN2gQ,21635 +ansible/modules/network/f5/bigiq_application_fastl4_udp.pyc,, +ansible/modules/network/f5/bigiq_application_http.py,sha256=hBjcyJxkIxH-VPudE7M_Mkhj7qjBfGVUKZT3PBKNd18,23340 +ansible/modules/network/f5/bigiq_application_http.pyc,, +ansible/modules/network/f5/bigiq_application_https_offload.py,sha256=5SeWStmK4ii8rI5ACmrzemO51CIwCGjGNu83w2WwJrQ,32220 +ansible/modules/network/f5/bigiq_application_https_offload.pyc,, +ansible/modules/network/f5/bigiq_application_https_waf.py,sha256=kkdYEENinB3ps2wSXh60zxp1I-GGzsTYLjCgcfNSJDw,33074 +ansible/modules/network/f5/bigiq_application_https_waf.pyc,, +ansible/modules/network/f5/bigiq_regkey_license.py,sha256=J7IlE19zmSbfPmBdz0WYMfnrvA2OrzfAFkL2S2DWS58,13079 +ansible/modules/network/f5/bigiq_regkey_license.pyc,, +ansible/modules/network/f5/bigiq_regkey_license_assignment.py,sha256=r_E-bqhW6-xEp3buA0Oe2cHkGmjABhmnL_XBPFJceME,20546 +ansible/modules/network/f5/bigiq_regkey_license_assignment.pyc,, +ansible/modules/network/f5/bigiq_regkey_pool.py,sha256=NqLLjrkdW4NBl3sa-XZh2qswZpU98VfaQSx18QaZ5x0,10461 +ansible/modules/network/f5/bigiq_regkey_pool.pyc,, +ansible/modules/network/f5/bigiq_utility_license.py,sha256=1TlyGHDzYB0IDlP5WOBeT35NofEER-g3_Y8dXcVZw9I,13930 +ansible/modules/network/f5/bigiq_utility_license.pyc,, +ansible/modules/network/f5/bigiq_utility_license_assignment.py,sha256=WHjJPyUZwwOUNS2qEB5ljBoDtubhkMXJvicH_6HO-_Q,20993 +ansible/modules/network/f5/bigiq_utility_license_assignment.pyc,, +ansible/modules/network/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/files/__init__.pyc,, +ansible/modules/network/files/net_get.py,sha256=c_iL6ILTtyNGpw7L-4ynfJGoV_Bzms4k8a67jUlcbmI,2116 +ansible/modules/network/files/net_get.pyc,, +ansible/modules/network/files/net_put.py,sha256=H9VgZzVROe3r6kdMihvHq5dPyq1Bod0w_hD9tSj-hxE,2437 +ansible/modules/network/files/net_put.pyc,, +ansible/modules/network/fortimanager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/fortimanager/__init__.pyc,, +ansible/modules/network/fortimanager/fmgr_provisioning.py,sha256=g4j5pIRXrReSkYrSEBZlM_SEu1ij6cDspVY2y2i9sTM,11699 +ansible/modules/network/fortimanager/fmgr_provisioning.pyc,, +ansible/modules/network/fortimanager/fmgr_script.py,sha256=vDEtRl4h3tn-mspYcyQ5btEnasUX3GaVmMdwcNpQbjA,8309 +ansible/modules/network/fortimanager/fmgr_script.pyc,, +ansible/modules/network/fortios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/fortios/__init__.pyc,, +ansible/modules/network/fortios/fortios_address.py,sha256=Eo-rJ-FRpdqO0GXEEPdWan_IriOz_tZn0Vy85FXZ2pc,10231 +ansible/modules/network/fortios/fortios_address.pyc,, +ansible/modules/network/fortios/fortios_config.py,sha256=PZCJimTBIyNffwCVYdvuwrWnhIFppXF-wbvHyXMa4v8,5103 +ansible/modules/network/fortios/fortios_config.pyc,, +ansible/modules/network/fortios/fortios_ipv4_policy.py,sha256=uDaobWQHuOXIs49k2kQB7IJgEQfk8ZvZg2pqxOk4rLw,10794 +ansible/modules/network/fortios/fortios_ipv4_policy.pyc,, +ansible/modules/network/fortios/fortios_webfilter.py,sha256=LTqlBBU8VeFOsSkCL89SG7jJAE5Lx32etgPBkVTJV58,18511 +ansible/modules/network/fortios/fortios_webfilter.pyc,, +ansible/modules/network/ftd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/ftd/__init__.pyc,, +ansible/modules/network/ftd/ftd_configuration.py,sha256=vWK1gm3Tq4xbjj70fkJXbbY0EQgyQHmKXdhcVklvMj4,5059 +ansible/modules/network/ftd/ftd_configuration.pyc,, +ansible/modules/network/ftd/ftd_file_download.py,sha256=sQJ76P-vhl9HC5kc9X5gWCnRVUiu63lFjMALY5CpPEg,4428 +ansible/modules/network/ftd/ftd_file_download.pyc,, +ansible/modules/network/ftd/ftd_file_upload.py,sha256=mPylAVPMSDPQC96l4dN0WuF22CKDrdxLmaXS7UKuIL0,3724 +ansible/modules/network/ftd/ftd_file_upload.pyc,, +ansible/modules/network/illumos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/illumos/__init__.pyc,, +ansible/modules/network/illumos/dladm_etherstub.py,sha256=fsIYe6gQU_szeV9GVJ1QIyJaSIr--s_jK0b8HB-Kb1c,4160 +ansible/modules/network/illumos/dladm_etherstub.pyc,, +ansible/modules/network/illumos/dladm_iptun.py,sha256=1RYKGvTZxGSelxPO_i8QEW1WTjOZvDFV5lpU-2rgKeE,7764 +ansible/modules/network/illumos/dladm_iptun.pyc,, +ansible/modules/network/illumos/dladm_linkprop.py,sha256=0-IQpz9JV60CkyjJ7wEqxChBmvIdt_LZ7uWX72x--Wc,7835 +ansible/modules/network/illumos/dladm_linkprop.pyc,, +ansible/modules/network/illumos/dladm_vlan.py,sha256=cBaaRs1ivfNt5i-W3wGBs-70KXiOQ5K7HQ008G1Zl3Q,5402 +ansible/modules/network/illumos/dladm_vlan.pyc,, +ansible/modules/network/illumos/dladm_vnic.py,sha256=7Xntz2Oj4GeuSPWFtX_0yJEJGoBBzI0apBi672Rbwy8,6588 +ansible/modules/network/illumos/dladm_vnic.pyc,, +ansible/modules/network/illumos/flowadm.py,sha256=2O3WRyXoLEKNyq53JgX1G_sq7PCmr5af32cDUrwhHjM,14799 +ansible/modules/network/illumos/flowadm.pyc,, +ansible/modules/network/illumos/ipadm_addr.py,sha256=fqWtF1fpFdP_dckmUWeOuIQykC8FF0xLejJk5s4Ac8g,11664 +ansible/modules/network/illumos/ipadm_addr.pyc,, +ansible/modules/network/illumos/ipadm_addrprop.py,sha256=B6URKJJlQGfHvOTeydy81CHZdSCl5qQAJjlNx26-8AU,7148 +ansible/modules/network/illumos/ipadm_addrprop.pyc,, +ansible/modules/network/illumos/ipadm_if.py,sha256=6en2zBoZLIgvrkZgA3JUGjJ3Yc4PbPH-mUJgV4g95Aw,5731 +ansible/modules/network/illumos/ipadm_if.pyc,, +ansible/modules/network/illumos/ipadm_ifprop.py,sha256=ZLDn5c2UbHI3cr__AzPEDQERxIouKUJKerArGiUp0Oc,8208 +ansible/modules/network/illumos/ipadm_ifprop.pyc,, +ansible/modules/network/illumos/ipadm_prop.py,sha256=n3G1hkAgrlz5ISP8f9obt7JVGhnbJYG9QrmVR8qB0qA,7056 +ansible/modules/network/illumos/ipadm_prop.pyc,, +ansible/modules/network/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/interface/__init__.pyc,, +ansible/modules/network/interface/net_interface.py,sha256=dlZks46DJVO-wi0aw8_XKSj9bjv9xeaLLcrpununEyI,3658 +ansible/modules/network/interface/net_interface.pyc,, +ansible/modules/network/interface/net_linkagg.py,sha256=2I0b7jGo2a-fQdMxraFpqD8ru3hQKWmK-0Xzsvu8spg,2696 +ansible/modules/network/interface/net_linkagg.pyc,, +ansible/modules/network/interface/net_lldp_interface.py,sha256=Xqv55CLFgSVnMcOfWQMhF_7_vpcTP3JPIEQuy2vpmDA,2126 +ansible/modules/network/interface/net_lldp_interface.pyc,, +ansible/modules/network/ios/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/ios/__init__.pyc,, +ansible/modules/network/ios/ios_banner.py,sha256=WXP5VwgRLPxe-8odVSDutMyzRLlm9gVhxjUFbYb7TWs,5437 +ansible/modules/network/ios/ios_banner.pyc,, +ansible/modules/network/ios/ios_command.py,sha256=mhjRIz_RKxWNQc-Bcx1kUWTtEwZOLvv84tOvHQbJqaU,8192 +ansible/modules/network/ios/ios_command.pyc,, +ansible/modules/network/ios/ios_config.py,sha256=_4L4ZaMNMYf8z9-c1KEttQfoXPRyHFYXd5ToUpwKiz4,20907 +ansible/modules/network/ios/ios_config.pyc,, +ansible/modules/network/ios/ios_facts.py,sha256=V4xSmfiJ9tHRu2Y_xq6HMj-FR03jUq0i-4DHeCmriIY,17003 +ansible/modules/network/ios/ios_facts.pyc,, +ansible/modules/network/ios/ios_interface.py,sha256=asoqMGZdGlQjzRWCZHmi2PfEnfxOZyOdKqSsp-ftA5k,15497 +ansible/modules/network/ios/ios_interface.pyc,, +ansible/modules/network/ios/ios_l2_interface.py,sha256=unzMIRTrRaZKuXZkIjTdFTRMd5qtZcl4tE5_VxuXyOI,16984 +ansible/modules/network/ios/ios_l2_interface.pyc,, +ansible/modules/network/ios/ios_l3_interface.py,sha256=LMIgeIobKSLMNIqfAUEXgcoXx3-qIR5xCFtXr9XuugQ,10217 +ansible/modules/network/ios/ios_l3_interface.pyc,, +ansible/modules/network/ios/ios_linkagg.py,sha256=XRwWfpPpxe1mukDFC9ophBQPJw8fV5dN4Wng6qLVqtg,9418 +ansible/modules/network/ios/ios_linkagg.pyc,, +ansible/modules/network/ios/ios_lldp.py,sha256=BWazbuoj-0QWMmKRPNfEjclqwgV83bhKLquFboVNmO0,2786 +ansible/modules/network/ios/ios_lldp.pyc,, +ansible/modules/network/ios/ios_logging.py,sha256=j2aQTs_Dyc6xRKVbsaIRFuy03fU9fuOHzbelzxMGPEI,12512 +ansible/modules/network/ios/ios_logging.pyc,, +ansible/modules/network/ios/ios_ping.py,sha256=aGC17hghxoi917vNT0Vq55XcgQf2vxIv13EcLCa_jHA,5865 +ansible/modules/network/ios/ios_ping.pyc,, +ansible/modules/network/ios/ios_static_route.py,sha256=_Ya2RlK2My8V7T0MbWtaMyd7vijhka0OQJ4c0cLb1O8,8881 +ansible/modules/network/ios/ios_static_route.pyc,, +ansible/modules/network/ios/ios_system.py,sha256=toQnzwVIxqo2NFmTveEabS7fTLUm-I2Ph7Me4XZ1ctc,12174 +ansible/modules/network/ios/ios_system.pyc,, +ansible/modules/network/ios/ios_user.py,sha256=NUZVZLKHqj1aKrGPtEpIHxE2HPdEkuRH0wi3SGY02Gs,14537 +ansible/modules/network/ios/ios_user.pyc,, +ansible/modules/network/ios/ios_vlan.py,sha256=dJp2qNG4CHw4tI4QkpTDIAXRFZsOxFWXS9k-NRXJC1o,10392 +ansible/modules/network/ios/ios_vlan.pyc,, +ansible/modules/network/ios/ios_vrf.py,sha256=Vz0FNzEY_kJBCz7H4HaJ80gag5y2n3fVc8qUJd4cIkg,25231 +ansible/modules/network/ios/ios_vrf.pyc,, +ansible/modules/network/iosxr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/iosxr/__init__.pyc,, +ansible/modules/network/iosxr/iosxr_banner.py,sha256=3ekVvQGEBQYR-sfcErQsuR6kNG3xfyNvEf6X9avele0,8270 +ansible/modules/network/iosxr/iosxr_banner.pyc,, +ansible/modules/network/iosxr/iosxr_command.py,sha256=Ly2nX9nwQfqIXGKN_DBDx2ogTw_daoxAJMxTeZqOU4o,6983 +ansible/modules/network/iosxr/iosxr_command.pyc,, +ansible/modules/network/iosxr/iosxr_config.py,sha256=uBvd24sGbm8tjsTIboNjtjINabKE-MXRdMMpZBWthso,13678 +ansible/modules/network/iosxr/iosxr_config.pyc,, +ansible/modules/network/iosxr/iosxr_facts.py,sha256=bQ0nK_NxEs_6iWvjginlp9kfiMsnAK7uPIglBNTnuVg,12867 +ansible/modules/network/iosxr/iosxr_facts.pyc,, +ansible/modules/network/iosxr/iosxr_interface.py,sha256=cmr9Hn-WrPhJw6lAhmcYD0un17zUpSOXDyvKTc59JrQ,26061 +ansible/modules/network/iosxr/iosxr_interface.pyc,, +ansible/modules/network/iosxr/iosxr_logging.py,sha256=kXqTaEpwBKjNw2FJeZ-lgKciQaEqPzN7LsRlGxVNxu4,30474 +ansible/modules/network/iosxr/iosxr_logging.pyc,, +ansible/modules/network/iosxr/iosxr_netconf.py,sha256=eyTZ0hMuCGW_PFKKd2YrKeq7K7gfJ0SBzOgsZ4c7pJk,6118 +ansible/modules/network/iosxr/iosxr_netconf.pyc,, +ansible/modules/network/iosxr/iosxr_system.py,sha256=3sQNZ6Z5DGUM1TqlXqKRJERmQlOItc-Mz8mNsZya2sk,24531 +ansible/modules/network/iosxr/iosxr_system.pyc,, +ansible/modules/network/iosxr/iosxr_user.py,sha256=bxAA8H4clEKu0MJk8AoGpOqrdxjwEghjWUZF9e6hTWA,28558 +ansible/modules/network/iosxr/iosxr_user.pyc,, +ansible/modules/network/ironware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/ironware/__init__.pyc,, +ansible/modules/network/ironware/ironware_command.py,sha256=47iB3w09JV2akyFxmUu1YshYzGCWcnyhN0yFrz0c0Gs,5154 +ansible/modules/network/ironware/ironware_command.pyc,, +ansible/modules/network/ironware/ironware_config.py,sha256=b9Py5wdw8kez7NKo1J7cMyQc4S5TUNGZEfJQHpFzY7k,10031 +ansible/modules/network/ironware/ironware_config.pyc,, +ansible/modules/network/ironware/ironware_facts.py,sha256=W_cNGvGQn9NIv5TMNTeJalqkJ_NFPaPGWvbB2HykHl4,20033 +ansible/modules/network/ironware/ironware_facts.pyc,, +ansible/modules/network/junos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/junos/__init__.pyc,, +ansible/modules/network/junos/junos_banner.py,sha256=WJjRMVnXKvXrvjUcCAIhtub62OWeXz3DQZwjbVl3fTg,5259 +ansible/modules/network/junos/junos_banner.pyc,, +ansible/modules/network/junos/junos_command.py,sha256=QuUcdxlQoXiCVQcfyKp7CBZusg0thR8zVZvv5IKvKi4,14612 +ansible/modules/network/junos/junos_command.pyc,, +ansible/modules/network/junos/junos_config.py,sha256=5lR2zItALAaC2LJiA0znZveb0-M8Mg79kyqLAox6OoQ,14324 +ansible/modules/network/junos/junos_config.pyc,, +ansible/modules/network/junos/junos_facts.py,sha256=V1yur45zYLUDmDzC5IRs4oZSN7mv6_0DSsPexF3xz9A,12725 +ansible/modules/network/junos/junos_facts.pyc,, +ansible/modules/network/junos/junos_interface.py,sha256=B7MWlGlLsyznqV3xYE0U89UUufZ8bvjP86VnRzanqYw,12307 +ansible/modules/network/junos/junos_interface.pyc,, +ansible/modules/network/junos/junos_l2_interface.py,sha256=UKLx7ujONq12A_XE-AZ1k6HE5ZgfJBV2KS38ptFbf48,8376 +ansible/modules/network/junos/junos_l2_interface.pyc,, +ansible/modules/network/junos/junos_l3_interface.py,sha256=EnaNu3iHiHI90KTaaplwcHCzHecD-G3UJ5oaFTkAnnU,6006 +ansible/modules/network/junos/junos_l3_interface.pyc,, +ansible/modules/network/junos/junos_linkagg.py,sha256=uya9mKpB7bA54BNRja6CiYuFn7EWuiab1mH9VCubQ2k,10729 +ansible/modules/network/junos/junos_linkagg.pyc,, +ansible/modules/network/junos/junos_lldp.py,sha256=Rvh5zEZ2V18paC1_Cu48dCb98skmO-0pX-Y6mHohkGU,6067 +ansible/modules/network/junos/junos_lldp.pyc,, +ansible/modules/network/junos/junos_lldp_interface.py,sha256=7YAkvLV6doVbpvCZdIECEVPDbxLAKXdJl1ub5GguuN4,4868 +ansible/modules/network/junos/junos_lldp_interface.pyc,, +ansible/modules/network/junos/junos_logging.py,sha256=WEeCl8gKuvRfkXF7x5Tc7PXpTWZk4IjPcRF_q-EIPKQ,8823 +ansible/modules/network/junos/junos_logging.pyc,, +ansible/modules/network/junos/junos_netconf.py,sha256=1fRMq9u2KKy8vcLd4G4dn0Tz9OLCu1z1vqDx0c0VPsA,6248 +ansible/modules/network/junos/junos_netconf.pyc,, +ansible/modules/network/junos/junos_package.py,sha256=FJg23CpJqCg0cPl5PVITH7k2svyiPgSzZOcWs-QmL-U,6541 +ansible/modules/network/junos/junos_package.pyc,, +ansible/modules/network/junos/junos_rpc.py,sha256=2qvJNDnsjFxy5DqdzCxtrtOWRqNICBmnSMLKEjZGKEs,5333 +ansible/modules/network/junos/junos_rpc.pyc,, +ansible/modules/network/junos/junos_scp.py,sha256=9eg911CBrtPoyPGCjdW2sI-agmwukQHjD0A6exdNvYI,5091 +ansible/modules/network/junos/junos_scp.pyc,, +ansible/modules/network/junos/junos_static_route.py,sha256=qcU92tWeceChCUymvuplaD48w_Aqp7t6DMpGgDXyqDo,7340 +ansible/modules/network/junos/junos_static_route.pyc,, +ansible/modules/network/junos/junos_system.py,sha256=RKfd7ln5ZgjS2BurUfbPuopK7rTmKuAKCmtXvQG5Y98,6189 +ansible/modules/network/junos/junos_system.pyc,, +ansible/modules/network/junos/junos_user.py,sha256=OdzJXK1Lyql8_Df6lH5hcYmxdROAZCJPIlRBwvmNzK0,11746 +ansible/modules/network/junos/junos_user.pyc,, +ansible/modules/network/junos/junos_vlan.py,sha256=RmtwKM3zQjCnn1UTUjStpEX29emp_EF1VETERXZQoH0,6684 +ansible/modules/network/junos/junos_vlan.pyc,, +ansible/modules/network/junos/junos_vrf.py,sha256=8FYpK1VJjr2H1x4v85DAcNeOCxpkE6f7iqfj1T2jG88,8481 +ansible/modules/network/junos/junos_vrf.pyc,, +ansible/modules/network/layer2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/layer2/__init__.pyc,, +ansible/modules/network/layer2/net_l2_interface.py,sha256=_1gE5gpeVzr497APCmwue6l9DVVm6_NoMFSw_-ouRLo,2049 +ansible/modules/network/layer2/net_l2_interface.pyc,, +ansible/modules/network/layer2/net_vlan.py,sha256=JPkUzm99mi6a7NCchK7WdPkNg7vjEqFYKjfR-awjd2w,1665 +ansible/modules/network/layer2/net_vlan.pyc,, +ansible/modules/network/layer3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/layer3/__init__.pyc,, +ansible/modules/network/layer3/net_l3_interface.py,sha256=h-wyzEZKqeaHXZWGInQnAq8g7svNzlFSkDPz8sdlMKU,2074 +ansible/modules/network/layer3/net_l3_interface.pyc,, +ansible/modules/network/layer3/net_vrf.py,sha256=nS7oE66qbGV-YIHuMkZrxUkG0J8aOSZ2FeWgi462W9w,1854 +ansible/modules/network/layer3/net_vrf.pyc,, +ansible/modules/network/meraki/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/meraki/__init__.pyc,, +ansible/modules/network/meraki/meraki_admin.py,sha256=X85IVMv6dwwEOTDbzIXgWjpqK5Rmvy1MUQEbYDb_Pl0,15944 +ansible/modules/network/meraki/meraki_admin.pyc,, +ansible/modules/network/meraki/meraki_config_template.py,sha256=VOS4QWt20Gr1ViDreldHKa6bD-Bdwd_xCj4GyeAzQDg,10493 +ansible/modules/network/meraki/meraki_config_template.pyc,, +ansible/modules/network/meraki/meraki_device.py,sha256=K1ryMDgQlVv4X-b1ED_PIfLOdvf3uusonkPgn_on6wQ,15823 +ansible/modules/network/meraki/meraki_device.pyc,, +ansible/modules/network/meraki/meraki_mr_l3_firewall.py,sha256=8zVGDrxCd6PjcUUlCkWoONlPgRou-hDZImyC670-5ck,9202 +ansible/modules/network/meraki/meraki_mr_l3_firewall.pyc,, +ansible/modules/network/meraki/meraki_mx_l3_firewall.py,sha256=-Y3TXP6yNDLRppDDC3Hw_3EqOLadT3AoMtE8CRRKzkU,11897 +ansible/modules/network/meraki/meraki_mx_l3_firewall.pyc,, +ansible/modules/network/meraki/meraki_network.py,sha256=tAVFGO17c0c8x6-Bucn4jOl3t2fokyh2yTvQe8DCvVk,10494 +ansible/modules/network/meraki/meraki_network.pyc,, +ansible/modules/network/meraki/meraki_organization.py,sha256=Z0p0J46wist_raZn-IW1GAjANk5HZvmQdvKvrETfI_Q,8344 +ansible/modules/network/meraki/meraki_organization.pyc,, +ansible/modules/network/meraki/meraki_snmp.py,sha256=nOBldp3Cucubzb0JMoaQ6F-DCmhVT_MKbGo8GJAWHlk,10148 +ansible/modules/network/meraki/meraki_snmp.pyc,, +ansible/modules/network/meraki/meraki_ssid.py,sha256=2xc_rDNKV9f_3p-5v9RtlOJfc6p9kdIMxmH2hw8Eqgs,21474 +ansible/modules/network/meraki/meraki_ssid.pyc,, +ansible/modules/network/meraki/meraki_switchport.py,sha256=AdGwnWa68YzQ1yFgeupe-BGp5GUSPS4hT_18fNB_OHk,14693 +ansible/modules/network/meraki/meraki_switchport.pyc,, +ansible/modules/network/meraki/meraki_vlan.py,sha256=qqKIt5JPMUb-vDuf1ViFQ7YK29WXHAYqT1_cLCmdqFE,14894 +ansible/modules/network/meraki/meraki_vlan.pyc,, +ansible/modules/network/netact/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/netact/__init__.pyc,, +ansible/modules/network/netact/netact_cm_command.py,sha256=tvdiAd8CiwmTYmWzo7B_r5T46kTBrS4pWNuElz_OSHU,12104 +ansible/modules/network/netact/netact_cm_command.pyc,, +ansible/modules/network/netconf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/netconf/__init__.pyc,, +ansible/modules/network/netconf/netconf_config.py,sha256=xRkk2eEOZtwdpLlzS4tvAvlx0cht9nx2KdwDv5VZjTI,17590 +ansible/modules/network/netconf/netconf_config.pyc,, +ansible/modules/network/netconf/netconf_get.py,sha256=fqOmc23g5keXgcBUYr7HSvdivz5uagXTblXLdHq87tM,9710 +ansible/modules/network/netconf/netconf_get.pyc,, +ansible/modules/network/netconf/netconf_rpc.py,sha256=FLe0fBwuRf_u5VyCIIQ1am6UhTMCpqb4lKJtlBgJaoI,8472 +ansible/modules/network/netconf/netconf_rpc.pyc,, +ansible/modules/network/netscaler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/netscaler/__init__.pyc,, +ansible/modules/network/netscaler/netscaler_cs_action.py,sha256=y-1PEiaX65838wJmap8w6Jw93AJwzUTJtxeIslvnoCk,9032 +ansible/modules/network/netscaler/netscaler_cs_action.pyc,, +ansible/modules/network/netscaler/netscaler_cs_policy.py,sha256=k0_K9XizYNCfSeiNdeK0BnRGD3X6LTDVUclDEZgOmuo,9505 +ansible/modules/network/netscaler/netscaler_cs_policy.pyc,, +ansible/modules/network/netscaler/netscaler_cs_vserver.py,sha256=FnAzTmBIWomftXgJQrN6CN3U1GSqzEOJNu26NP4CNF0,43973 +ansible/modules/network/netscaler/netscaler_cs_vserver.pyc,, +ansible/modules/network/netscaler/netscaler_gslb_service.py,sha256=9-7MRjPyKki9NenqgVcsKFBuF8YCAzcieunN2k67O40,24020 +ansible/modules/network/netscaler/netscaler_gslb_service.pyc,, +ansible/modules/network/netscaler/netscaler_gslb_site.py,sha256=pt8SErHsiWLKN_yN5q42m3-s3aq7U7nw_oLiKx846cY,14171 +ansible/modules/network/netscaler/netscaler_gslb_site.pyc,, +ansible/modules/network/netscaler/netscaler_gslb_vserver.py,sha256=hn2k5K9u39FJ1nrewlPPUTKyR770Mu5BV8am0zuPYg0,33875 +ansible/modules/network/netscaler/netscaler_gslb_vserver.pyc,, +ansible/modules/network/netscaler/netscaler_lb_monitor.py,sha256=hVyQQhWdD1gheCowNhEydTeN5jgsSLTzKEfhVrYlwXM,47437 +ansible/modules/network/netscaler/netscaler_lb_monitor.pyc,, +ansible/modules/network/netscaler/netscaler_lb_vserver.py,sha256=eMnntCUml3lsk83lLAkFNw5AbwkchraRRoV767cUcBU,72334 +ansible/modules/network/netscaler/netscaler_lb_vserver.pyc,, +ansible/modules/network/netscaler/netscaler_nitro_request.py,sha256=pv9Y729yr2TrkwM0hep_Sw-mzbeQIMNO-0VSBCZowsg,28632 +ansible/modules/network/netscaler/netscaler_nitro_request.pyc,, +ansible/modules/network/netscaler/netscaler_save_config.py,sha256=aZZDJLpBC1cFpPf-ggchtgiDAXMApNAPtdAwYlMydRs,4872 +ansible/modules/network/netscaler/netscaler_save_config.pyc,, +ansible/modules/network/netscaler/netscaler_server.py,sha256=W0ToLWkZUdK5KedQVd0OHTyQTmGol69l21CxdY8oLUM,13055 +ansible/modules/network/netscaler/netscaler_server.pyc,, +ansible/modules/network/netscaler/netscaler_service.py,sha256=5oa2exzKmdjf4wY0BN6iYSrG8cj-wqmo_gqzdP9ZROg,31451 +ansible/modules/network/netscaler/netscaler_service.pyc,, +ansible/modules/network/netscaler/netscaler_servicegroup.py,sha256=7X0nW2mon-LcsZut3C1xcRAmTEaqSmCyAu6lt-obKi0,35086 +ansible/modules/network/netscaler/netscaler_servicegroup.pyc,, +ansible/modules/network/netscaler/netscaler_ssl_certkey.py,sha256=uuhwEEy75IBVgXmoX2LwDIQgG_X_cDVJ9LszZee9wmg,11864 +ansible/modules/network/netscaler/netscaler_ssl_certkey.pyc,, +ansible/modules/network/netvisor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/netvisor/__init__.pyc,, +ansible/modules/network/netvisor/pn_cluster.py,sha256=wAYTZlJuwRTzlcw3jEgmSk9TMbgPp4Wo-ui9355yh3M,9502 +ansible/modules/network/netvisor/pn_cluster.pyc,, +ansible/modules/network/netvisor/pn_ospf.py,sha256=Whx1bmmavMMKoEqjOCaV4SdwKW6TPa3C7QY0EWQQ8wg,8858 +ansible/modules/network/netvisor/pn_ospf.pyc,, +ansible/modules/network/netvisor/pn_ospfarea.py,sha256=V3JGJa0KnvLfNGGaYrhBg3guYyFmdMgaiUGyg-Nbn8M,6376 +ansible/modules/network/netvisor/pn_ospfarea.pyc,, +ansible/modules/network/netvisor/pn_show.py,sha256=ECCYsoqpf4vc2v0urscebdfL_QnE3Acn8mFsAovVM1k,5461 +ansible/modules/network/netvisor/pn_show.pyc,, +ansible/modules/network/netvisor/pn_trunk.py,sha256=w6PPf3hIF1si5F2uQ-YRBOb74R9HKCrKkSP2jcyzcoQ,13980 +ansible/modules/network/netvisor/pn_trunk.pyc,, +ansible/modules/network/netvisor/pn_vlag.py,sha256=xr1XkKYE2y1gBiYestuuYlFUmfYIEsW0fLptVzG7piY,10755 +ansible/modules/network/netvisor/pn_vlag.pyc,, +ansible/modules/network/netvisor/pn_vlan.py,sha256=rFH2kgqKEDDK7-orJgQBLt7d5bi8JQi5Jawgp-3tBQ0,8968 +ansible/modules/network/netvisor/pn_vlan.pyc,, +ansible/modules/network/netvisor/pn_vrouter.py,sha256=pjt94dw1mefnP1udHC3mdaZW68lrhj27rsS5qKVzlmw,13368 +ansible/modules/network/netvisor/pn_vrouter.pyc,, +ansible/modules/network/netvisor/pn_vrouterbgp.py,sha256=iOm-uJFaGIZH7rP4TuyEUfEplTnERCje2tXe1v89Vh8,15107 +ansible/modules/network/netvisor/pn_vrouterbgp.pyc,, +ansible/modules/network/netvisor/pn_vrouterif.py,sha256=bHcGK6rr1Fx4q0VJ5CgiZEEETsJ7DmxuYze1hnXwZgQ,15342 +ansible/modules/network/netvisor/pn_vrouterif.pyc,, +ansible/modules/network/netvisor/pn_vrouterlbif.py,sha256=yq9TBfvqrDT3ywzx7nH7wGS4SytX74feMGaoU8quIvw,10151 +ansible/modules/network/netvisor/pn_vrouterlbif.pyc,, +ansible/modules/network/nos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/nos/__init__.pyc,, +ansible/modules/network/nos/nos_command.py,sha256=3ZgrtK-o5kVz87KIX2Yq7mWdKVVsyM_hDXP8A45sVtg,7910 +ansible/modules/network/nos/nos_command.pyc,, +ansible/modules/network/nos/nos_config.py,sha256=9MRAf0Pu8jeBXa86Dborq5T5U6KiIO9FSxvaxVchHMY,14203 +ansible/modules/network/nos/nos_config.pyc,, +ansible/modules/network/nos/nos_facts.py,sha256=YHJMDDGWfTeaA92ZLZaaHfNPVkIHv2WRUmDKJh7tMKU,13847 +ansible/modules/network/nos/nos_facts.pyc,, +ansible/modules/network/nso/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/nso/__init__.pyc,, +ansible/modules/network/nso/nso_action.py,sha256=3N3HYU14k7cbljf4VLJDlQTm3S3azimZdiqYq3anvUM,5780 +ansible/modules/network/nso/nso_action.pyc,, +ansible/modules/network/nso/nso_config.py,sha256=TkP-hvjKQkmPHsC9GTmH0DinMl2eTLvEvw5o9Qa8evw,9228 +ansible/modules/network/nso/nso_config.pyc,, +ansible/modules/network/nso/nso_query.py,sha256=Y7sSiXOGwE-97zoHQlWtLv54eEYtar5abWYHLt9AfzI,3295 +ansible/modules/network/nso/nso_query.pyc,, +ansible/modules/network/nso/nso_show.py,sha256=J2chVu8cP3nf2pNGYyUJFc8uibLphlFkqapYtS7qR2Y,3509 +ansible/modules/network/nso/nso_show.pyc,, +ansible/modules/network/nso/nso_verify.py,sha256=1IKEY84_gpdbJzNkNP02GPr5xQf0VazMiZ17cqaXtoo,6553 +ansible/modules/network/nso/nso_verify.pyc,, +ansible/modules/network/nuage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/nuage/__init__.pyc,, +ansible/modules/network/nuage/nuage_vspk.py,sha256=xZRu5uh3X9FcO1_Zr4FOc8mqpPWUOM0mLv9fQlejwCg,42235 +ansible/modules/network/nuage/nuage_vspk.pyc,, +ansible/modules/network/nxos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/nxos/__init__.pyc,, +ansible/modules/network/nxos/_nxos_ip_interface.py,sha256=Z0nSAIFuyn36jeT8N1FfUOgAf4mWG2Ic4nJByKf3_EQ,21746 +ansible/modules/network/nxos/_nxos_ip_interface.pyc,, +ansible/modules/network/nxos/_nxos_mtu.py,sha256=FL_B188yQMsaJaAgfECCggslyyaj2xak2Lm_ib7r89E,943 +ansible/modules/network/nxos/_nxos_mtu.pyc,, +ansible/modules/network/nxos/_nxos_portchannel.py,sha256=7FMvZoztcCZ0OH1xMGPgMashCRGdOiP4oGxru1p0vXU,15307 +ansible/modules/network/nxos/_nxos_portchannel.pyc,, +ansible/modules/network/nxos/_nxos_switchport.py,sha256=l2klOxb8p8QXjle5PFYFZjnhwxPWyZw27Q7Hj8_B_0E,18381 +ansible/modules/network/nxos/_nxos_switchport.pyc,, +ansible/modules/network/nxos/nxos_aaa_server.py,sha256=CXDY_30lTWkQrJ6_lb6d6pBbNTfRj2L58jPYgoGDhKY,10769 +ansible/modules/network/nxos/nxos_aaa_server.pyc,, +ansible/modules/network/nxos/nxos_aaa_server_host.py,sha256=3BpfqFg0BYPmemttGTtOUYW1uDR-2TbHj8iPFN5qgB0,11537 +ansible/modules/network/nxos/nxos_aaa_server_host.pyc,, +ansible/modules/network/nxos/nxos_acl.py,sha256=EH25p84O-sW3v5pfmuGYUfEs4C4FFWrgQEEZneUu5g8,17675 +ansible/modules/network/nxos/nxos_acl.pyc,, +ansible/modules/network/nxos/nxos_acl_interface.py,sha256=uZjteApMHUUQI5TBkRJ5-WiRO-aeFGPbiHdJ_haPBDI,5736 +ansible/modules/network/nxos/nxos_acl_interface.pyc,, +ansible/modules/network/nxos/nxos_banner.py,sha256=aG2vtxux0_v-VgqSHxWuUCAd_GpBOHCd8QKK_WSGBVk,6164 +ansible/modules/network/nxos/nxos_banner.pyc,, +ansible/modules/network/nxos/nxos_bgp.py,sha256=DlLk0Jq6iUbgBLWk48XhOwTfTaP1ocR3bS4yIGqLOls,25662 +ansible/modules/network/nxos/nxos_bgp.pyc,, +ansible/modules/network/nxos/nxos_bgp_af.py,sha256=Xqz-92agGStURL-nfWMjIWlSoI6iISWGC7eoSsm7Oyo,29362 +ansible/modules/network/nxos/nxos_bgp_af.pyc,, +ansible/modules/network/nxos/nxos_bgp_neighbor.py,sha256=_85RqvcdA8m0Mtr0MGRDRZaSs4qat0dDsVyXTZE_A3o,16827 +ansible/modules/network/nxos/nxos_bgp_neighbor.pyc,, +ansible/modules/network/nxos/nxos_bgp_neighbor_af.py,sha256=4HOsFfDbeQ8f5bn5nJyyrbxi1jNo3n5H-HtSLo3V4LE,26338 +ansible/modules/network/nxos/nxos_bgp_neighbor_af.pyc,, +ansible/modules/network/nxos/nxos_command.py,sha256=om4CUZo0sTToLMENlz4czi53_Qh7pYBo4kNnfWv6Os8,7560 +ansible/modules/network/nxos/nxos_command.pyc,, +ansible/modules/network/nxos/nxos_config.py,sha256=X8rfxN9g1wOK6cMFKg9GikScDS79y_nHrxN8ciCadJ0,20605 +ansible/modules/network/nxos/nxos_config.pyc,, +ansible/modules/network/nxos/nxos_evpn_global.py,sha256=Q6EEpWHYxcDuHwPT-nhWRY3_mO-Vf0GNwPhoeyjbBVs,2796 +ansible/modules/network/nxos/nxos_evpn_global.pyc,, +ansible/modules/network/nxos/nxos_evpn_vni.py,sha256=T23ObXLlTjafG9ntd0GMuQk-p1yBghehXit21oKB-9I,9712 +ansible/modules/network/nxos/nxos_evpn_vni.pyc,, +ansible/modules/network/nxos/nxos_facts.py,sha256=Ymniw_vi1B3nkv_BBBlfWQ6QAdAGtp0ALZbLaWP3oX8,32693 +ansible/modules/network/nxos/nxos_facts.pyc,, +ansible/modules/network/nxos/nxos_feature.py,sha256=HOxCA_-3uetvXmkBVm6sHC79SZ-dGNkaCThGK-vxpaY,8046 +ansible/modules/network/nxos/nxos_feature.pyc,, +ansible/modules/network/nxos/nxos_file_copy.py,sha256=vrjOTHyFYFX_VYRpl_JpWqs5NDej6s_s_AVTvbwEETE,16472 +ansible/modules/network/nxos/nxos_file_copy.pyc,, +ansible/modules/network/nxos/nxos_gir.py,sha256=uzBaT0ibSPSATEwnFkadmxBgNjszuZXuT40jWbyMdPc,12352 +ansible/modules/network/nxos/nxos_gir.pyc,, +ansible/modules/network/nxos/nxos_gir_profile_management.py,sha256=uToOZh-srWSukVMATzWkzmNfO2rpfWk7VLVYQhQJ9lM,6065 +ansible/modules/network/nxos/nxos_gir_profile_management.pyc,, +ansible/modules/network/nxos/nxos_hsrp.py,sha256=ToycG7IOROPlbifJNDKpVDuCHrXvVpazRS0ZXVzRCcI,15150 +ansible/modules/network/nxos/nxos_hsrp.pyc,, +ansible/modules/network/nxos/nxos_igmp.py,sha256=M4mxkT3QmA251EzRW0h1TinXDCZlP9bdtwpp-E00lVY,4827 +ansible/modules/network/nxos/nxos_igmp.pyc,, +ansible/modules/network/nxos/nxos_igmp_interface.py,sha256=8xCjoYTH3QjCRYI2CfruEx2mLwDO6P-DEaEaruXth4M,24430 +ansible/modules/network/nxos/nxos_igmp_interface.pyc,, +ansible/modules/network/nxos/nxos_igmp_snooping.py,sha256=5fqcuG8IRKYKo9OnBg9KYtWrh_hNldNwfcdnNw4zPNs,8914 +ansible/modules/network/nxos/nxos_igmp_snooping.pyc,, +ansible/modules/network/nxos/nxos_install_os.py,sha256=a5984QjDFK7a7zsHuYPWKna8j01n1U0tikbGCkpMuJE,21742 +ansible/modules/network/nxos/nxos_install_os.pyc,, +ansible/modules/network/nxos/nxos_interface.py,sha256=8I7a5775JWXWkKwB4BYWIz_HrZ825Pbf5CXa-AlZtrw,25933 +ansible/modules/network/nxos/nxos_interface.pyc,, +ansible/modules/network/nxos/nxos_interface_ospf.py,sha256=5AeuOl__RmgSdfdCDPeePmCFPLXGlB2f0tiIC6ECP2w,17076 +ansible/modules/network/nxos/nxos_interface_ospf.pyc,, +ansible/modules/network/nxos/nxos_l2_interface.py,sha256=_XffOoWKLUdfWSwwr3hwuoIPSDIgrD_uobXf_AnE7M4,19040 +ansible/modules/network/nxos/nxos_l2_interface.pyc,, +ansible/modules/network/nxos/nxos_l3_interface.py,sha256=bAmREdQs0w0czFPHxLS7tv8iJm9_ChTzPTDx5pBh7a8,7076 +ansible/modules/network/nxos/nxos_l3_interface.pyc,, +ansible/modules/network/nxos/nxos_linkagg.py,sha256=8Mgx4cZo3LI_vty5QnOZsBAKK3ZZYuTr9IjQ1xYJ53Q,13858 +ansible/modules/network/nxos/nxos_linkagg.pyc,, +ansible/modules/network/nxos/nxos_lldp.py,sha256=qRI5nANaVzVSGmdvcoXuy2qR3EQbKbeP0kHTdEKVl2k,2969 +ansible/modules/network/nxos/nxos_lldp.pyc,, +ansible/modules/network/nxos/nxos_logging.py,sha256=ee6Wku1YbnAbTJCL5M0_u5QqMgyVfVGmFyhk1NQhuJ0,15484 +ansible/modules/network/nxos/nxos_logging.pyc,, +ansible/modules/network/nxos/nxos_ntp.py,sha256=AzzqyWvo-5wYOmn1xCO1fpTvr1efqqvjiBCgkOFwdkk,13441 +ansible/modules/network/nxos/nxos_ntp.pyc,, +ansible/modules/network/nxos/nxos_ntp_auth.py,sha256=6Pw21r44IV2UzBUYOLmvYYNac7ULDjbfywbwk_M8ApU,9574 +ansible/modules/network/nxos/nxos_ntp_auth.pyc,, +ansible/modules/network/nxos/nxos_ntp_options.py,sha256=GDX9Od7mrMGEy7pYed9FMh_9SxZle12I8uhT-B9JpyU,4744 +ansible/modules/network/nxos/nxos_ntp_options.pyc,, +ansible/modules/network/nxos/nxos_nxapi.py,sha256=wK9Zjm1nwBGRuUbSdb15zEmJYZNM-JplluEjxPb5h5Y,14387 +ansible/modules/network/nxos/nxos_nxapi.pyc,, +ansible/modules/network/nxos/nxos_ospf.py,sha256=AusG-Mzxr0BZAg06hJZlD7GK45poIgIFSQ9VsMieKDs,4148 +ansible/modules/network/nxos/nxos_ospf.pyc,, +ansible/modules/network/nxos/nxos_ospf_vrf.py,sha256=uIaea8aIJEZSB4-9COQfyJUsdMrptd37Lbk_TQDKEhU,16445 +ansible/modules/network/nxos/nxos_ospf_vrf.pyc,, +ansible/modules/network/nxos/nxos_overlay_global.py,sha256=enwL01ZwXWZputL7-ZGju8j_G2ZS3HNqycVyLJWLgpI,5899 +ansible/modules/network/nxos/nxos_overlay_global.pyc,, +ansible/modules/network/nxos/nxos_pim.py,sha256=N2Wc93qNOrWnbfFbYI0e5LnyNdncdo3dS3Yzxo9buBM,5321 +ansible/modules/network/nxos/nxos_pim.pyc,, +ansible/modules/network/nxos/nxos_pim_interface.py,sha256=_ldSdGZ_nVnbfWk8hR1bSNkKiMq_jeWBpkJ_8Z65OYs,18460 +ansible/modules/network/nxos/nxos_pim_interface.pyc,, +ansible/modules/network/nxos/nxos_pim_rp_address.py,sha256=NJ8pKvAwPAuylOzS7sxvM9K6cV7hpB3FaxhDEn_Yyo8,8038 +ansible/modules/network/nxos/nxos_pim_rp_address.pyc,, +ansible/modules/network/nxos/nxos_ping.py,sha256=Q_aw-Ps9xLcgOi1E50pyeTb1jI6x3a8Xryl-aKrs2Yc,6630 +ansible/modules/network/nxos/nxos_ping.pyc,, +ansible/modules/network/nxos/nxos_reboot.py,sha256=ahZ9kdNCAW1kCW43mGIXMaq15utBY0R28o8xinC49Jk,2519 +ansible/modules/network/nxos/nxos_reboot.pyc,, +ansible/modules/network/nxos/nxos_rollback.py,sha256=Yg-4W3YjFr_9s3Yu-MRDntVNA5C_kTRrw0YQ33XTq-o,3790 +ansible/modules/network/nxos/nxos_rollback.pyc,, +ansible/modules/network/nxos/nxos_rpm.py,sha256=cXJACs4Oaovn9VljXIg2wxbO-DFzHF0K2J-VMU8q0wk,11698 +ansible/modules/network/nxos/nxos_rpm.pyc,, +ansible/modules/network/nxos/nxos_smu.py,sha256=BnlA2Jo_b4T_jTOMZLoAFMRlI6sLsHnkXA2TEtisrbg,4839 +ansible/modules/network/nxos/nxos_smu.pyc,, +ansible/modules/network/nxos/nxos_snapshot.py,sha256=Rtxit1A1aws3zuWq6rjkgl96PJ-eaEthmH7bWQL28ME,12858 +ansible/modules/network/nxos/nxos_snapshot.pyc,, +ansible/modules/network/nxos/nxos_snmp_community.py,sha256=Y_bwTz6dHqfZIw-MiDxwmM_3mJyUYJd7KfsquncEQYs,6703 +ansible/modules/network/nxos/nxos_snmp_community.pyc,, +ansible/modules/network/nxos/nxos_snmp_contact.py,sha256=uep72ep59JyAjzRZoaNbKwj0q0y7eFRsJ5vLUwUW5hs,3931 +ansible/modules/network/nxos/nxos_snmp_contact.pyc,, +ansible/modules/network/nxos/nxos_snmp_host.py,sha256=Pp24xWzHngwQGZ1AQ4qY6X3LziG5H8ihfWZyxwWYCz0,15264 +ansible/modules/network/nxos/nxos_snmp_host.pyc,, +ansible/modules/network/nxos/nxos_snmp_location.py,sha256=0HqhE2w1yo33SdJQ5t7sOt6xhxJDuJpZRJyfFC8recg,4000 +ansible/modules/network/nxos/nxos_snmp_location.pyc,, +ansible/modules/network/nxos/nxos_snmp_traps.py,sha256=ai09ll_6ktf0DMvlI2ksCrnflRKqQ7Pg0O2FoJlVlLU,7281 +ansible/modules/network/nxos/nxos_snmp_traps.pyc,, +ansible/modules/network/nxos/nxos_snmp_user.py,sha256=g8IfKcK-yOPQdPUxgi2m1wUfoNS7JV16vRA3hzV0ER4,10707 +ansible/modules/network/nxos/nxos_snmp_user.pyc,, +ansible/modules/network/nxos/nxos_static_route.py,sha256=zK0YhyQQDh7TH8sARlCRZV8MEErVF7m758RH1cuIuI4,9208 +ansible/modules/network/nxos/nxos_static_route.pyc,, +ansible/modules/network/nxos/nxos_system.py,sha256=P96YqXtsGOWGx9F6PyoKv2IQFV2sN6jF3KL5rydY5iA,13075 +ansible/modules/network/nxos/nxos_system.pyc,, +ansible/modules/network/nxos/nxos_udld.py,sha256=vCQNnDEeNuKhEwhB5BDee83NNQCvUml-9QAxB_enoGg,7487 +ansible/modules/network/nxos/nxos_udld.pyc,, +ansible/modules/network/nxos/nxos_udld_interface.py,sha256=jnRgbf5webwoSCcqg3PYRXm_A031PIC-drXiuVh1t5w,9001 +ansible/modules/network/nxos/nxos_udld_interface.pyc,, +ansible/modules/network/nxos/nxos_user.py,sha256=C_Gk1RkCev6ng5V7jGnSnBord2Pqd_DMsaZu7tRtt2o,12455 +ansible/modules/network/nxos/nxos_user.pyc,, +ansible/modules/network/nxos/nxos_vlan.py,sha256=yLsIqgn7WULafBHbKiTpF0_lJ7RBCeMHSb9Xl32ms-c,23488 +ansible/modules/network/nxos/nxos_vlan.pyc,, +ansible/modules/network/nxos/nxos_vpc.py,sha256=rvokEXZg1BUKmLJOmmWmLpYhvweFBDyZcpRksSqGufA,11940 +ansible/modules/network/nxos/nxos_vpc.pyc,, +ansible/modules/network/nxos/nxos_vpc_interface.py,sha256=znIWvHeOUtD6IQrbU91v3i6P_70X3TW5A4LSTdQUpsM,10361 +ansible/modules/network/nxos/nxos_vpc_interface.pyc,, +ansible/modules/network/nxos/nxos_vrf.py,sha256=fqULfrOlOSz87GgA3RbG62ewkN9QC5hFTUfO-FYu-hc,17144 +ansible/modules/network/nxos/nxos_vrf.pyc,, +ansible/modules/network/nxos/nxos_vrf_af.py,sha256=dgdF5Edxlop55hWUJ3CcYx8mJGcJN5F0RIaSmNhqB9k,4659 +ansible/modules/network/nxos/nxos_vrf_af.pyc,, +ansible/modules/network/nxos/nxos_vrf_interface.py,sha256=wtJv3D8kKJpJWJToybLzu8ewzGSRUDQ80tTaxc-1URM,7978 +ansible/modules/network/nxos/nxos_vrf_interface.pyc,, +ansible/modules/network/nxos/nxos_vrrp.py,sha256=Ouk8b8k5vAKGXdbotX1NaXgKFAp7gNfTk1BwsLWuWwI,12591 +ansible/modules/network/nxos/nxos_vrrp.pyc,, +ansible/modules/network/nxos/nxos_vtp_domain.py,sha256=Mulk1HIgFBhPyDRDSUOauGCBgb7Q8Hn2ZOC4IKhiBw8,5923 +ansible/modules/network/nxos/nxos_vtp_domain.pyc,, +ansible/modules/network/nxos/nxos_vtp_password.py,sha256=pTdKD4oSi4rHgwbfJO2Dcw6IU5eAcrQ9t6evC9U0Y24,8054 +ansible/modules/network/nxos/nxos_vtp_password.pyc,, +ansible/modules/network/nxos/nxos_vtp_version.py,sha256=gjrt9d9mkDaD5NYixWymCVZqT4UcZ6K0uEkzbd0Uq-c,5734 +ansible/modules/network/nxos/nxos_vtp_version.pyc,, +ansible/modules/network/nxos/nxos_vxlan_vtep.py,sha256=aU_NhcA_k3JUOqxYYjLC7TWX2usMteiGl5Mt8_Iw65s,10851 +ansible/modules/network/nxos/nxos_vxlan_vtep.pyc,, +ansible/modules/network/nxos/nxos_vxlan_vtep_vni.py,sha256=rTV4ZkwUH2RQ4UUWFqJRZ4N3Pa8wWguhpRm2QKPPD3I,13773 +ansible/modules/network/nxos/nxos_vxlan_vtep_vni.pyc,, +ansible/modules/network/onyx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/onyx/__init__.pyc,, +ansible/modules/network/onyx/onyx_bgp.py,sha256=ifW2TQcusERfi2oRf_C83HTztFzynsgS25JSQEHlYJo,8971 +ansible/modules/network/onyx/onyx_bgp.pyc,, +ansible/modules/network/onyx/onyx_command.py,sha256=mfI523bOkhI2--e_XC86e9RUr46jxA9E_aCQpwWrw_0,6715 +ansible/modules/network/onyx/onyx_command.pyc,, +ansible/modules/network/onyx/onyx_config.py,sha256=LTl_IkffWEhnDzId_o8EiffEpzphcXs-fc8NvcBfaKs,8174 +ansible/modules/network/onyx/onyx_config.pyc,, +ansible/modules/network/onyx/onyx_facts.py,sha256=eehjn-KO__QMnlqqOu0iT7DKh7kyt8bpo9BjjzqVjD4,6578 +ansible/modules/network/onyx/onyx_facts.pyc,, +ansible/modules/network/onyx/onyx_igmp.py,sha256=bSZsuokFcUrV2307ru7B_x0o7bG1b7GyQLwn3XuiBLA,7850 +ansible/modules/network/onyx/onyx_igmp.pyc,, +ansible/modules/network/onyx/onyx_interface.py,sha256=EoYn0kFWfqtS9ghpZEQG3bzaZa7Qr0-4i1FU-PTGRFw,16963 +ansible/modules/network/onyx/onyx_interface.pyc,, +ansible/modules/network/onyx/onyx_l2_interface.py,sha256=w9lQk-AZVlapQy4CFif1_h4InUh24kpZbU2Asgov2-U,10423 +ansible/modules/network/onyx/onyx_l2_interface.pyc,, +ansible/modules/network/onyx/onyx_l3_interface.py,sha256=7dQFuDtFoBsvackY3ejmTO-2RrS9yL-ZN7bfVMw5dt0,10109 +ansible/modules/network/onyx/onyx_l3_interface.pyc,, +ansible/modules/network/onyx/onyx_linkagg.py,sha256=eItlv6ozo_7I2UdwT9URM1OhOJMSLlwZ3Re2p-gZsXQ,12463 +ansible/modules/network/onyx/onyx_linkagg.pyc,, +ansible/modules/network/onyx/onyx_lldp.py,sha256=O5MY9svL2HmUooyb0qQRvpRWIRpBd3NynHqFZorNsb4,3101 +ansible/modules/network/onyx/onyx_lldp.pyc,, +ansible/modules/network/onyx/onyx_lldp_interface.py,sha256=4zgnW_3Fdx9QOKZJByQwu03838LLOI9JS2olStGLcBU,7407 +ansible/modules/network/onyx/onyx_lldp_interface.pyc,, +ansible/modules/network/onyx/onyx_magp.py,sha256=ZAeCN8MHnO4LLnHeMoCPqZ7cnkxyA0GDP82tnWRDYRU,7830 +ansible/modules/network/onyx/onyx_magp.pyc,, +ansible/modules/network/onyx/onyx_mlag_ipl.py,sha256=RA4a48nOdT4MiE3HmHE5gmWSOB5bt3FB3iBhIU0kFms,6779 +ansible/modules/network/onyx/onyx_mlag_ipl.pyc,, +ansible/modules/network/onyx/onyx_mlag_vip.py,sha256=9HOH2jNgEeg7ZDmCs6VzzwGem511HsrujOA0R275tQY,5498 +ansible/modules/network/onyx/onyx_mlag_vip.pyc,, +ansible/modules/network/onyx/onyx_ospf.py,sha256=6O3gXvr_S9qy_9nlNvEmwxJaWziTcj_KDI9x_gjv7jA,8188 +ansible/modules/network/onyx/onyx_ospf.pyc,, +ansible/modules/network/onyx/onyx_pfc_interface.py,sha256=dDzBbmKNyI59GiHG8RFliRf0IeCYcaSQU731pZbLVHc,7093 +ansible/modules/network/onyx/onyx_pfc_interface.pyc,, +ansible/modules/network/onyx/onyx_protocol.py,sha256=f430mm4slkRhXvqISDI-2bZCBd2a3Fa0Zp-K3pniIsU,6128 +ansible/modules/network/onyx/onyx_protocol.pyc,, +ansible/modules/network/onyx/onyx_vlan.py,sha256=12mAeZzZnV4IRensPwY11ubmzuKqAyDQ4QNGDqtPLwg,6451 +ansible/modules/network/onyx/onyx_vlan.pyc,, +ansible/modules/network/opx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/opx/__init__.pyc,, +ansible/modules/network/opx/opx_cps.py,sha256=t_lY-4LZFhItqXUmKeKZotQMQcFL-x47ZXUAb0_g_jI,12628 +ansible/modules/network/opx/opx_cps.pyc,, +ansible/modules/network/ordnance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/ordnance/__init__.pyc,, +ansible/modules/network/ordnance/ordnance_config.py,sha256=kFQNdQrcB28rm3SOwIJDs3zufQVnN_mH5yHTSjl-MdI,12274 +ansible/modules/network/ordnance/ordnance_config.pyc,, +ansible/modules/network/ordnance/ordnance_facts.py,sha256=Ak_xYSVyjL7-GiNqiyDyMSLrbT_oBarRxe4KoXzUzps,8506 +ansible/modules/network/ordnance/ordnance_facts.pyc,, +ansible/modules/network/ovs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/ovs/__init__.pyc,, +ansible/modules/network/ovs/openvswitch_bridge.py,sha256=1hXxDjh3Uhev6l1haKdTpSDepCDCPceupSerze1g7D0,8695 +ansible/modules/network/ovs/openvswitch_bridge.pyc,, +ansible/modules/network/ovs/openvswitch_db.py,sha256=sGLkY3IFrS9E2SuNu9tpGluuUGYtJgAp9pNNsfWWCEc,6636 +ansible/modules/network/ovs/openvswitch_db.pyc,, +ansible/modules/network/ovs/openvswitch_port.py,sha256=Fkh-HJOCU-YDvPOCt6v3cYJdcV2mWfqolr3hFEN3zHs,8041 +ansible/modules/network/ovs/openvswitch_port.pyc,, +ansible/modules/network/panos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/panos/__init__.pyc,, +ansible/modules/network/panos/_panos_nat_policy.py,sha256=-CDfrBF08iO2ltXBYGX-KTsyHgYAVaYQtXBb1I8rjKM,10437 +ansible/modules/network/panos/_panos_nat_policy.pyc,, +ansible/modules/network/panos/_panos_security_policy.py,sha256=VTlIWCB2ux7uahhnbPcEcs5EAKLFGLQU5QmXO1CWpTM,17366 +ansible/modules/network/panos/_panos_security_policy.pyc,, +ansible/modules/network/panos/panos_admin.py,sha256=IdMhjbK7P4mdromRFGtWW2DhOPvyj3gN0LdmRgc3LaE,5636 +ansible/modules/network/panos/panos_admin.pyc,, +ansible/modules/network/panos/panos_admpwd.py,sha256=E6LSLzOX5CiD1IOcqPKp2sFvo44mwvvQPAqTBBPlGgs,5985 +ansible/modules/network/panos/panos_admpwd.pyc,, +ansible/modules/network/panos/panos_cert_gen_ssh.py,sha256=1HNM2RolYyQdJGaL7WSEd5mzp-4wOmSYdcwaFfbz-EA,6225 +ansible/modules/network/panos/panos_cert_gen_ssh.pyc,, +ansible/modules/network/panos/panos_check.py,sha256=W6rEaYTVeyU9q37oWtFgPw84kl4eb2BpvXdWNXu50jo,3818 +ansible/modules/network/panos/panos_check.pyc,, +ansible/modules/network/panos/panos_commit.py,sha256=yyQ_sewhcqQWvhFkjaM3aL9QKwHsiAihovhkY17CbwQ,3272 +ansible/modules/network/panos/panos_commit.pyc,, +ansible/modules/network/panos/panos_dag.py,sha256=TdA7KaI2GaRrR7x3rrQ_O2VjIj9xfcSDBKXM_0vkbDs,3871 +ansible/modules/network/panos/panos_dag.pyc,, +ansible/modules/network/panos/panos_dag_tags.py,sha256=eO05296Ri9swc15XY_ZUW8Y99O3M6kQHphKmgw3RPmg,7386 +ansible/modules/network/panos/panos_dag_tags.pyc,, +ansible/modules/network/panos/panos_import.py,sha256=D9BVSs5KXxvBloPA7Q1RR9eLbS3g5B0AfyL2KOPzMu8,5247 +ansible/modules/network/panos/panos_import.pyc,, +ansible/modules/network/panos/panos_interface.py,sha256=QtM9RJHh5z-KhKlpBK7Ho9jNyL2v2VFFQYzX81dkTX8,5401 +ansible/modules/network/panos/panos_interface.pyc,, +ansible/modules/network/panos/panos_lic.py,sha256=-bwT8JPnoA0WLktsZcQ5KmgiqP7J6EbzaBd8XIKcvCs,4612 +ansible/modules/network/panos/panos_lic.pyc,, +ansible/modules/network/panos/panos_loadcfg.py,sha256=QVhboUm8Qybg-rSeT0BMyKhQP8hU8ZyP4bfW39tvujs,3208 +ansible/modules/network/panos/panos_loadcfg.pyc,, +ansible/modules/network/panos/panos_match_rule.py,sha256=-rP3MUgFL2d7dcWti8yOYfZmmflOqmlTOwF6i4Ponlw,12239 +ansible/modules/network/panos/panos_match_rule.pyc,, +ansible/modules/network/panos/panos_mgtconfig.py,sha256=yf9wcO15wlxg-nXhktQCr45kW-SIoIg04UqErgvZP8g,5610 +ansible/modules/network/panos/panos_mgtconfig.pyc,, +ansible/modules/network/panos/panos_nat_rule.py,sha256=22PGzg7vc0M4PI1UC5b_YP1R4t6UDnK3AvTcyj193Bo,15881 +ansible/modules/network/panos/panos_nat_rule.pyc,, +ansible/modules/network/panos/panos_object.py,sha256=hnEvOeSkkae9wZnY2_qvFPLgMDQrlNJKx4aS-z8IyLY,16514 +ansible/modules/network/panos/panos_object.pyc,, +ansible/modules/network/panos/panos_op.py,sha256=lwhJtgyTuYagda92rwy_3k59befWYjJsj7zeVvhvIBE,5012 +ansible/modules/network/panos/panos_op.pyc,, +ansible/modules/network/panos/panos_pg.py,sha256=s-nB_9VQO5VZaWOibBOOkpnEIWqghqS_dy4gWNDtBEU,5869 +ansible/modules/network/panos/panos_pg.pyc,, +ansible/modules/network/panos/panos_query_rules.py,sha256=TLKZeBX6I7FcPHnT0ufur01gbRM74VqopvgDs204ZZU,18383 +ansible/modules/network/panos/panos_query_rules.pyc,, +ansible/modules/network/panos/panos_restart.py,sha256=TQYSIctMFcM-UBeljeXfdwCxizzK_iSm7muKveQHcnY,2813 +ansible/modules/network/panos/panos_restart.pyc,, +ansible/modules/network/panos/panos_sag.py,sha256=z8yy2NhVjInjWM7-N0Z3Paoo0I-_FwrUmx78e2h8-CI,8274 +ansible/modules/network/panos/panos_sag.pyc,, +ansible/modules/network/panos/panos_security_rule.py,sha256=KHwIEwvvkunHFfSRUfPLpv3kUHnxT6yL02rPc5b55ks,19823 +ansible/modules/network/panos/panos_security_rule.pyc,, +ansible/modules/network/panos/panos_set.py,sha256=c8Cw1uXg045Vsv3rrEp2FowJ3WB20CmhqVQPpYvqrAw,5021 +ansible/modules/network/panos/panos_set.pyc,, +ansible/modules/network/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/protocol/__init__.pyc,, +ansible/modules/network/protocol/net_lldp.py,sha256=MVLnLMyASHC8mUgsE70NCe97mW1RV1lnagiRZh20OQY,1224 +ansible/modules/network/protocol/net_lldp.pyc,, +ansible/modules/network/radware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/radware/__init__.pyc,, +ansible/modules/network/radware/vdirect_commit.py,sha256=EGU429NHAQtSrlgvrS-SOstIBCeE5_UMxqDOZd1Nozo,12999 +ansible/modules/network/radware/vdirect_commit.pyc,, +ansible/modules/network/radware/vdirect_file.py,sha256=xY-KSaKwkXtyn-4zHnTqJIUAZHJOtC33XbbCkK_u0_k,9278 +ansible/modules/network/radware/vdirect_file.pyc,, +ansible/modules/network/radware/vdirect_runnable.py,sha256=j1qnD9dIRyZ-BvjPTP7GRWz7x0ugWEmEtlcTci_7mz0,12870 +ansible/modules/network/radware/vdirect_runnable.pyc,, +ansible/modules/network/routeros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/routeros/__init__.pyc,, +ansible/modules/network/routeros/routeros_command.py,sha256=dx0rVQtXU4ZEtTQcB4xrVVjz4ZZNQr27_Z00YNxIItc,6506 +ansible/modules/network/routeros/routeros_command.pyc,, +ansible/modules/network/routing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/routing/__init__.pyc,, +ansible/modules/network/routing/net_static_route.py,sha256=do3u5UHQcdYHpkA_jBSGCc-Yf2byghP8j4bV-r-LAFU,2324 +ansible/modules/network/routing/net_static_route.pyc,, +ansible/modules/network/slxos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/slxos/__init__.pyc,, +ansible/modules/network/slxos/slxos_command.py,sha256=TS1XrvyN2yTm0QKs7UwWW96Kdnv89CtgqActJJKSfMI,7951 +ansible/modules/network/slxos/slxos_command.pyc,, +ansible/modules/network/slxos/slxos_config.py,sha256=9d5OXE-ZV7VBaJNdVW0DR9PQ5Cl3FO4Z42a-V0BF0tk,17456 +ansible/modules/network/slxos/slxos_config.pyc,, +ansible/modules/network/slxos/slxos_facts.py,sha256=Moc9GvtllxAbkI9DIojQ7-PbMjEY4EIjA2FoX4g5RHU,13821 +ansible/modules/network/slxos/slxos_facts.pyc,, +ansible/modules/network/slxos/slxos_interface.py,sha256=EoCDKIAIvwbP4SLCg0uKGyxZrJWkYnNLYCgnI25lV9A,14500 +ansible/modules/network/slxos/slxos_interface.pyc,, +ansible/modules/network/slxos/slxos_l2_interface.py,sha256=7FmYql-m6m0qrxpcL_2JTGWhxvUrKT5NQAEtpBoYQkc,16987 +ansible/modules/network/slxos/slxos_l2_interface.pyc,, +ansible/modules/network/slxos/slxos_l3_interface.py,sha256=YHzT40hNAR2Ot2fN5Jsvhr6blOU2cvjyvL0mE7oN4cc,9575 +ansible/modules/network/slxos/slxos_l3_interface.pyc,, +ansible/modules/network/slxos/slxos_linkagg.py,sha256=TDw8YMYW1SnwDq8V_vdWA2MjxZFjKzlMoBLLKS3UyLg,9756 +ansible/modules/network/slxos/slxos_linkagg.pyc,, +ansible/modules/network/slxos/slxos_lldp.py,sha256=G3yyTlc3EY45gyL-Lb1gXzu_TbH0w6W3RXgLgBR-uLI,3475 +ansible/modules/network/slxos/slxos_lldp.pyc,, +ansible/modules/network/slxos/slxos_vlan.py,sha256=pC7aLwxX-lGbZDOY8J4obC_6nmfSXb1EDTsbsX_Ierk,9651 +ansible/modules/network/slxos/slxos_vlan.pyc,, +ansible/modules/network/sros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/sros/__init__.pyc,, +ansible/modules/network/sros/sros_command.py,sha256=Sb2Rcyj7l25m4kL8RSdLiZS3XsTlw9kW2EvaH3HIA-8,7119 +ansible/modules/network/sros/sros_command.pyc,, +ansible/modules/network/sros/sros_config.py,sha256=Q2GB3tdxw7CSOrBHSolMvi84lsucI3nFsqRUBu3Dn7E,10330 +ansible/modules/network/sros/sros_config.pyc,, +ansible/modules/network/sros/sros_rollback.py,sha256=161Z-Eutm1zYVXiZp5UT3XZ9WAwBEgtwlNWj3QX46-E,6734 +ansible/modules/network/sros/sros_rollback.pyc,, +ansible/modules/network/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/system/__init__.pyc,, +ansible/modules/network/system/net_banner.py,sha256=rcVYdPVwAG1KBcQN9yAnFz-bTnVSlaBAXjaj4A-FwaA,2076 +ansible/modules/network/system/net_banner.pyc,, +ansible/modules/network/system/net_logging.py,sha256=WInKZr3sA5YpUPm8vHs9klPNsu-3vHrIVgO4vhlsMM4,2345 +ansible/modules/network/system/net_logging.pyc,, +ansible/modules/network/system/net_ping.py,sha256=FQAh934DRMBEU7Tl3xd2A9eE-TIeHLYjw2asWNLMDr8,2494 +ansible/modules/network/system/net_ping.pyc,, +ansible/modules/network/system/net_system.py,sha256=2mSopfbJGn6lzLTQvXA5dXKBhCQsLCnrixzq3joe_fw,3068 +ansible/modules/network/system/net_system.pyc,, +ansible/modules/network/system/net_user.py,sha256=aKpNAdvgmWUOQXZ3ofuczQ082KyQ4n8uAOfCv_6uW0k,4501 +ansible/modules/network/system/net_user.pyc,, +ansible/modules/network/voss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/voss/__init__.pyc,, +ansible/modules/network/voss/voss_command.py,sha256=ddxOb6hr2DZlOQJw_ggLtQeOZBoWVov_29JGSjnPshI,7929 +ansible/modules/network/voss/voss_command.pyc,, +ansible/modules/network/voss/voss_facts.py,sha256=4dQkg61917RfjrzZGyJ2muBCe-XaVoT4I_84iR4KcAY,16239 +ansible/modules/network/voss/voss_facts.pyc,, +ansible/modules/network/vyos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/network/vyos/__init__.pyc,, +ansible/modules/network/vyos/vyos_banner.py,sha256=nxOqMqPWgfvbB1Qpixnm0n5yfe7iS6CFqhwguxsVXes,5151 +ansible/modules/network/vyos/vyos_banner.pyc,, +ansible/modules/network/vyos/vyos_command.py,sha256=I-AndPzVyGgQ8veWd2hwNzV6jVIA5vEjPctDKRWzK3E,7698 +ansible/modules/network/vyos/vyos_command.pyc,, +ansible/modules/network/vyos/vyos_config.py,sha256=tKYD-QtjwpmhVcot-14wtFmmSs7pDtgn1-GamP0OJLg,9180 +ansible/modules/network/vyos/vyos_config.pyc,, +ansible/modules/network/vyos/vyos_facts.py,sha256=XezN6SBOi_VBlwtEnUb7lQV9TjGMCTBN-oNV0qu_KS8,8854 +ansible/modules/network/vyos/vyos_facts.pyc,, +ansible/modules/network/vyos/vyos_interface.py,sha256=Y0lK0e3magTRlTw3O7sZvL3M0SfCr6inVOikGbBJrRw,13740 +ansible/modules/network/vyos/vyos_interface.pyc,, +ansible/modules/network/vyos/vyos_l3_interface.py,sha256=ADyrnN0IA07CyYxU3rtT7_vaKCFjfpnX4rDMrG1fEjs,8511 +ansible/modules/network/vyos/vyos_l3_interface.pyc,, +ansible/modules/network/vyos/vyos_linkagg.py,sha256=0LpsSHsg1eViy3NSvd79BUW8_5oruGNGeqItxKFfnUA,7811 +ansible/modules/network/vyos/vyos_linkagg.pyc,, +ansible/modules/network/vyos/vyos_lldp.py,sha256=PPQHLoQIvZ_SY5Za8Q6U8wacukFRaf7cy_GBz-PbAyQ,3217 +ansible/modules/network/vyos/vyos_lldp.pyc,, +ansible/modules/network/vyos/vyos_lldp_interface.py,sha256=K_zLAFF_xuAUsjcOSQNvfj-QGwKLv8etUtnrjx2Lbto,6413 +ansible/modules/network/vyos/vyos_lldp_interface.pyc,, +ansible/modules/network/vyos/vyos_logging.py,sha256=1Q7D0rWkKbmnN2JMAZ9mfqv0A9b1Snjk7GuH1EL6_y0,7852 +ansible/modules/network/vyos/vyos_logging.pyc,, +ansible/modules/network/vyos/vyos_static_route.py,sha256=gTgySSJSo1REH4K4pObO_2yGB3rq4-IwFIYCxSmNJVk,8147 +ansible/modules/network/vyos/vyos_static_route.pyc,, +ansible/modules/network/vyos/vyos_system.py,sha256=6iPZmyjuXI5uMkVYtWoRxJ3_olrHnjreFyxvNeWTLaM,6307 +ansible/modules/network/vyos/vyos_system.pyc,, +ansible/modules/network/vyos/vyos_user.py,sha256=b1wJbin9hBxeJDdZvWDO2QmPm1wE7BjhVhgeU0msRlI,10850 +ansible/modules/network/vyos/vyos_user.pyc,, +ansible/modules/network/vyos/vyos_vlan.py,sha256=-d_6GT2HwUtiCNUqnY9fZB81lkFuUFP67SxlgpCOHtI,9311 +ansible/modules/network/vyos/vyos_vlan.pyc,, +ansible/modules/notification/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/notification/__init__.pyc,, +ansible/modules/notification/_osx_say.py,sha256=61PhSzAXkGL6Bo2nQieTPx6_5q5ytHD0LqcE2KUlSUQ,2413 +ansible/modules/notification/_osx_say.pyc,, +ansible/modules/notification/bearychat.py,sha256=_3rd9CBdlXtVJ0esxt1B7A4K-oM0LcjQ2kvgFEi1Fe0,5901 +ansible/modules/notification/bearychat.pyc,, +ansible/modules/notification/campfire.py,sha256=pp4zfzln2dBMOfRi7U9ZWjhjMSFq2CWz1v528Jo-hMU,4894 +ansible/modules/notification/campfire.pyc,, +ansible/modules/notification/catapult.py,sha256=EYbGkQeIGadQbrQ7JfbH8tmgkIs7OxRzLtRsuIsQmho,4254 +ansible/modules/notification/catapult.pyc,, +ansible/modules/notification/cisco_spark.py,sha256=qp8YYNgpc42JlQ7AbJR7Dz9ovXcKRqtC6J0zF33VujM,5644 +ansible/modules/notification/cisco_spark.pyc,, +ansible/modules/notification/flowdock.py,sha256=ZyrL5rmRxr4LoDJiQ_niT58TkEqRFpvbUll3Pk5VUoM,5701 +ansible/modules/notification/flowdock.pyc,, +ansible/modules/notification/grove.py,sha256=RKyyRo2wvsm0w-BGtMuHJIwGCjNUVNl2lYwqaq-ajDQ,3191 +ansible/modules/notification/grove.pyc,, +ansible/modules/notification/hall.py,sha256=RWfUWOz-ZNEKqXcf-pAi_LjWlM7wCEA2HwkhUEe-9ZM,3365 +ansible/modules/notification/hall.pyc,, +ansible/modules/notification/hipchat.py,sha256=pJFnjyJLRC0D7Jbt8IGFsNOctlhkMDNgnFbOjK3rXKg,6205 +ansible/modules/notification/hipchat.pyc,, +ansible/modules/notification/irc.py,sha256=Nl1quuXOR2U5TYzn2dqYzt-H7FKEwCihgh0Wv6Q1rXI,9142 +ansible/modules/notification/irc.pyc,, +ansible/modules/notification/jabber.py,sha256=kiGxmcmj5TDTMZS6cR91MdiLhrsmi4on0hDBFuBtz-4,4265 +ansible/modules/notification/jabber.pyc,, +ansible/modules/notification/logentries_msg.py,sha256=0XoCzq8FR73XYyPLhxDAYvJrIGrJXBiXkPAczORsv1g,2254 +ansible/modules/notification/logentries_msg.pyc,, +ansible/modules/notification/mail.py,sha256=ziec1DXc-VRHuK91PSf8ffRcVaZSURGPNXkANECYCEE,13805 +ansible/modules/notification/mail.pyc,, +ansible/modules/notification/mattermost.py,sha256=FAm85PDI_RmZuLQLCRZLEfNl5eWAhPQVv7jru4QMulI,4764 +ansible/modules/notification/mattermost.pyc,, +ansible/modules/notification/mqtt.py,sha256=GZsWumY2tApohvLrVGoHtG95n8fgpdUGHbC9HLFAAYE,6079 +ansible/modules/notification/mqtt.pyc,, +ansible/modules/notification/nexmo.py,sha256=l0KzWs8ia3VwagKlN70gSIRaxGtZnqptBCf7XzAyt7Q,3584 +ansible/modules/notification/nexmo.pyc,, +ansible/modules/notification/office_365_connector_card.py,sha256=LYkbOO4vi6QwCAiJKjCKQBVh50FxfIdTd9VA_MFEq5w,9473 +ansible/modules/notification/office_365_connector_card.pyc,, +ansible/modules/notification/pushbullet.py,sha256=ZlShZwFdtQqyaUHZEjqoJFP_l0ZNGAgOZvm92T5LeIc,5514 +ansible/modules/notification/pushbullet.pyc,, +ansible/modules/notification/pushover.py,sha256=ZFD5YZQuNmaRU8LX6rqyjrR-NJer4kubnRBkUmzZd20,3231 +ansible/modules/notification/pushover.pyc,, +ansible/modules/notification/rocketchat.py,sha256=SVYzV2ebr2gYlR9Q9t6fUdDhVitUmvQwkYsY15mHFuw,7788 +ansible/modules/notification/rocketchat.pyc,, +ansible/modules/notification/say.py,sha256=61PhSzAXkGL6Bo2nQieTPx6_5q5ytHD0LqcE2KUlSUQ,2413 +ansible/modules/notification/say.pyc,, +ansible/modules/notification/sendgrid.py,sha256=BChNvllNeu3yy8OQsQyNC-NDoXRST0ZypVkIRD4U_F8,8456 +ansible/modules/notification/sendgrid.pyc,, +ansible/modules/notification/slack.py,sha256=D5y1_2uDDExhTa8Tidbps7o8H0Ek2nIXo6g4sxyseGo,10377 +ansible/modules/notification/slack.pyc,, +ansible/modules/notification/snow_record.py,sha256=kCn7rrQSVx45IVOsgO3U748vME9Xvjj20-iao3pnDE8,10243 +ansible/modules/notification/snow_record.pyc,, +ansible/modules/notification/syslogger.py,sha256=GKRP2bUsOD2jO-CR2AE673JYY1xW_IOGuclwejzUdwg,4826 +ansible/modules/notification/syslogger.pyc,, +ansible/modules/notification/telegram.py,sha256=G71df1lLHW6zo2u-85g8jDZxNZi-dziT1JBL9tQZK0A,3268 +ansible/modules/notification/telegram.pyc,, +ansible/modules/notification/twilio.py,sha256=VsqHHX8CJxCv5fyV-w55X77XHXmfLWe7Bb4fmI0Y4CI,5594 +ansible/modules/notification/twilio.pyc,, +ansible/modules/notification/typetalk.py,sha256=Y51eLxNIEg9IHUGZkHML5te635WgUwG67dTU7dRXL68,3392 +ansible/modules/notification/typetalk.pyc,, +ansible/modules/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/packaging/__init__.pyc,, +ansible/modules/packaging/language/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/packaging/language/__init__.pyc,, +ansible/modules/packaging/language/bower.py,sha256=6JnUqATLv97F8uo_uVaXHUPsR16KVBGp5N0kWUrJ_gE,6764 +ansible/modules/packaging/language/bower.pyc,, +ansible/modules/packaging/language/bundler.py,sha256=1ZRwSdJ6UeKCrAvy2IwovmjfKmIAJAlP8R2teM9gOog,6730 +ansible/modules/packaging/language/bundler.pyc,, +ansible/modules/packaging/language/composer.py,sha256=XKllXaMrM0wiNMzfTXtfo3UArDkS0Qg-7ygODtVtwDI,9536 +ansible/modules/packaging/language/composer.pyc,, +ansible/modules/packaging/language/cpanm.py,sha256=OGJoYy2fiJXdD7vGNd4iSdAUzo6YmpZ4AqJU5yXeTGM,6320 +ansible/modules/packaging/language/cpanm.pyc,, +ansible/modules/packaging/language/easy_install.py,sha256=SA0zTKWqwqzL2pIq4wpI7BB6oXRzD9lRaNGlwDV5Jvs,6683 +ansible/modules/packaging/language/easy_install.pyc,, +ansible/modules/packaging/language/gem.py,sha256=GfGwLJ78hIXjRYR8O6PCSogNMJwcgGRTxvCMA7jFrP0,9019 +ansible/modules/packaging/language/gem.pyc,, +ansible/modules/packaging/language/maven_artifact.py,sha256=rHAI2wqAIZUui_-EDEQh8-Rb3NLEYMEEqkw2OveqEZo,22470 +ansible/modules/packaging/language/maven_artifact.pyc,, +ansible/modules/packaging/language/npm.py,sha256=IlQguFskX8LnqvjtSCHVHDeJ7v97yYLYKVJp7PcTQjQ,8412 +ansible/modules/packaging/language/npm.pyc,, +ansible/modules/packaging/language/pear.py,sha256=JdNsBBuZRWpccN0MW9zNEWNnmxwa4aUzRfOEPQbMtTk,6982 +ansible/modules/packaging/language/pear.pyc,, +ansible/modules/packaging/language/pip.py,sha256=HT-_aa--KuN-SXLjo5DhYvQnlFwlh-iD5pPgIoqAO7k,27122 +ansible/modules/packaging/language/pip.pyc,, +ansible/modules/packaging/language/yarn.py,sha256=FNKvibSnZsKPWbnyz0CPE3TKDsblZ9pQGiGy4TrGrJQ,11752 +ansible/modules/packaging/language/yarn.pyc,, +ansible/modules/packaging/os/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/packaging/os/__init__.pyc,, +ansible/modules/packaging/os/apk.py,sha256=DBb7l2riFvHg26k05RemLsqA_hwSssCezz6Si4URwS0,11119 +ansible/modules/packaging/os/apk.pyc,, +ansible/modules/packaging/os/apt.py,sha256=z2s57WG3sZIAW1Q1hY06-yA9D29PZWajNZOt2XbMwK8,41758 +ansible/modules/packaging/os/apt.pyc,, +ansible/modules/packaging/os/apt_key.py,sha256=vZRl50UCAG-fSl8HyKh68BPg_s66zhmoVmx7f43p-XE,12333 +ansible/modules/packaging/os/apt_key.pyc,, +ansible/modules/packaging/os/apt_repository.py,sha256=V7be2KBkLMuFVtKyZTsLbMHc_ie3U93Fz2aVixhNBss,19294 +ansible/modules/packaging/os/apt_repository.pyc,, +ansible/modules/packaging/os/apt_rpm.py,sha256=8xUd2KO4pzoqPwriLsgnr71or-1W510-slNvEUOhwJI,4726 +ansible/modules/packaging/os/apt_rpm.pyc,, +ansible/modules/packaging/os/dnf.py,sha256=fPX7HKjrVFw4wsteyuBhSmMt6nvJN-R4zzyBd3tU_6c,46914 +ansible/modules/packaging/os/dnf.pyc,, +ansible/modules/packaging/os/dpkg_selections.py,sha256=N68mqJox6NgG_88dQeOP2fsEntjiS6KPz_dI7rIZ6To,2173 +ansible/modules/packaging/os/dpkg_selections.pyc,, +ansible/modules/packaging/os/flatpak.py,sha256=zBwkQUFv4MytknaZrf77qdsFl3MuRGUzf9GHJPHjeWA,9562 +ansible/modules/packaging/os/flatpak.pyc,, +ansible/modules/packaging/os/flatpak_remote.py,sha256=1HsaL1UgERYZ39oXdukVtzsZ2ncmc6HGxsCYTdsFsFw,8293 +ansible/modules/packaging/os/flatpak_remote.pyc,, +ansible/modules/packaging/os/homebrew.py,sha256=uvBXs4J__L0QuC3IzBUEIjwYvdgg0mJ3-0_1CTw4K7g,27763 +ansible/modules/packaging/os/homebrew.pyc,, +ansible/modules/packaging/os/homebrew_cask.py,sha256=YoFcLE3U-f9IV_YhsiSDupKKNDWV6TrfFYaryPmct5w,23459 +ansible/modules/packaging/os/homebrew_cask.pyc,, +ansible/modules/packaging/os/homebrew_tap.py,sha256=qKLcr78mgr-aOdUcYmL12ItTMSsQnWebvyty03hn4pI,6806 +ansible/modules/packaging/os/homebrew_tap.pyc,, +ansible/modules/packaging/os/layman.py,sha256=DiJevYRoiFY1nrOeJ5wJMQi8b6nWRMSdt2j77HtIK0E,7531 +ansible/modules/packaging/os/layman.pyc,, +ansible/modules/packaging/os/macports.py,sha256=hJSTp148-E334_EchPEFnIs3ZYyGqzOWIuGnGF6SYHg,7016 +ansible/modules/packaging/os/macports.pyc,, +ansible/modules/packaging/os/openbsd_pkg.py,sha256=4SaoCq7p0NJa5V9mzftN_n-Q-Mye4lmIFikFRMt4x3o,25947 +ansible/modules/packaging/os/openbsd_pkg.pyc,, +ansible/modules/packaging/os/opkg.py,sha256=dSm_fcFJ73_b8JTi17vAyn_YqjtCPb0zqNdAfBZQ8Kk,5138 +ansible/modules/packaging/os/opkg.pyc,, +ansible/modules/packaging/os/package.py,sha256=dMIj2BdeBzJvx-0ZBe8RhEIW4PHG5eYnpsaQaYLoYxo,1929 +ansible/modules/packaging/os/package.pyc,, +ansible/modules/packaging/os/package_facts.py,sha256=F7kZ6OrBXPvyUcD2Zw4lV-LbAFOlUR_bg96MPi8TxI0,7148 +ansible/modules/packaging/os/package_facts.pyc,, +ansible/modules/packaging/os/pacman.py,sha256=_HIsHq3-a4xX4FlQlF3esXABVZgowT4jL7puLXYEfrA,14590 +ansible/modules/packaging/os/pacman.pyc,, +ansible/modules/packaging/os/pkg5.py,sha256=9pYS1LgyHYh_CLdd7aNCQTQ7SXuZgWVZIkFwvSRBMHc,4486 +ansible/modules/packaging/os/pkg5.pyc,, +ansible/modules/packaging/os/pkg5_publisher.py,sha256=Wku9bRl3sPFoiEpaqrCPm05CMqUjygovVw4Qr72zXms,5402 +ansible/modules/packaging/os/pkg5_publisher.pyc,, +ansible/modules/packaging/os/pkgin.py,sha256=gU-N6Zzlh3NJMQwBnWqyx5kpUM1zqKBv64FYLM6H1oc,10995 +ansible/modules/packaging/os/pkgin.pyc,, +ansible/modules/packaging/os/pkgng.py,sha256=rGc0MNGNsvJb9ZnbNZ7dLvk3GyzxjuEFxxAQekqnWlM,13946 +ansible/modules/packaging/os/pkgng.pyc,, +ansible/modules/packaging/os/pkgutil.py,sha256=wQRdVx9VQ9yW76MB4bClon119qbCEy4ngzlWqDlssHc,6757 +ansible/modules/packaging/os/pkgutil.pyc,, +ansible/modules/packaging/os/portage.py,sha256=6J4iqNu4nIefkP1aG4pTdoybYqgvvslcqE1LRO-GbAY,14682 +ansible/modules/packaging/os/portage.pyc,, +ansible/modules/packaging/os/portinstall.py,sha256=eF7qGznLuIaToI7fvPXG5Lqs3Wl2ydWVHgyx4sXuAW4,6749 +ansible/modules/packaging/os/portinstall.pyc,, +ansible/modules/packaging/os/pulp_repo.py,sha256=WRZYxOV1fmOqS9Fjwtq3Oy--Q5P7d8RqCGF983rFWqk,22855 +ansible/modules/packaging/os/pulp_repo.pyc,, +ansible/modules/packaging/os/redhat_subscription.py,sha256=upDj_c7bcfqnbdFasCdRSH2mvbcvf1d8-mq6T1t0AbE,28630 +ansible/modules/packaging/os/redhat_subscription.pyc,, +ansible/modules/packaging/os/rhn_channel.py,sha256=8JbkSLiWhGrdT2LbcebaxPhL3UP8Znv1Wy5uywxWHss,4494 +ansible/modules/packaging/os/rhn_channel.pyc,, +ansible/modules/packaging/os/rhn_register.py,sha256=n4DZ0InPyyqKMRU0VRlWEwmrvC8YNnVmgRm2Jb1nmSU,14400 +ansible/modules/packaging/os/rhn_register.pyc,, +ansible/modules/packaging/os/rhsm_repository.py,sha256=Tz9zod_-aQI9zNuBdJnY_L5AMpED1-M77eSGf5sGI3w,7996 +ansible/modules/packaging/os/rhsm_repository.pyc,, +ansible/modules/packaging/os/rpm_key.py,sha256=3l1jFIyYSbagUqbe7N_NHbdg2Bjy35s_QdVqh9vMGUk,6840 +ansible/modules/packaging/os/rpm_key.pyc,, +ansible/modules/packaging/os/slackpkg.py,sha256=msNKg7Bj1-DZfT1mFhDkGN7PBAXyk-Xm5blh4og0p4w,6148 +ansible/modules/packaging/os/slackpkg.pyc,, +ansible/modules/packaging/os/sorcery.py,sha256=01vZA9CwUUrllaxlUy5u7n9wXKTF0qPBFC85jeJExWY,20187 +ansible/modules/packaging/os/sorcery.pyc,, +ansible/modules/packaging/os/svr4pkg.py,sha256=puz6GvATOTnCziyhgo_uLL_-WdZNcELk-3pI6JpTCVA,7684 +ansible/modules/packaging/os/svr4pkg.pyc,, +ansible/modules/packaging/os/swdepot.py,sha256=qpEqMFSYv2dAQtQodadp6hoR92ryWLpXt3NESdJ4c7U,5991 +ansible/modules/packaging/os/swdepot.pyc,, +ansible/modules/packaging/os/swupd.py,sha256=k7r_6Irv73BJnlLaP0Mrn2i2lqG8FBxMDBT7rpjbS6o,8830 +ansible/modules/packaging/os/swupd.pyc,, +ansible/modules/packaging/os/urpmi.py,sha256=83uxm7b2u0Jsgv0qlbqIj0eQou9GIU5-e9dUrdvyEBU,6462 +ansible/modules/packaging/os/urpmi.pyc,, +ansible/modules/packaging/os/xbps.py,sha256=z59iDZfen7OzhnYwyNAtHKJgmvG6O7vzVrcUcJp8XhE,9606 +ansible/modules/packaging/os/xbps.pyc,, +ansible/modules/packaging/os/yum.py,sha256=IQ_NSpQqFaygue7jlr9q4x9v_fFHrKLhmAwErp1N47k,63316 +ansible/modules/packaging/os/yum.pyc,, +ansible/modules/packaging/os/yum_repository.py,sha256=2V-RnrU-ckZlukITl0C4LSULAGVhG8JQLn2qmLDX04g,24040 +ansible/modules/packaging/os/yum_repository.pyc,, +ansible/modules/packaging/os/zypper.py,sha256=WpnAUEC9m-6SGKgyyWe_xYu0hLNEdZKVqDde-hPt0HY,17960 +ansible/modules/packaging/os/zypper.pyc,, +ansible/modules/packaging/os/zypper_repository.py,sha256=HQwux1VPRBgJPvPix1OTEPiftHpV49TQTPLOTAWOJe0,13626 +ansible/modules/packaging/os/zypper_repository.pyc,, +ansible/modules/remote_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/__init__.pyc,, +ansible/modules/remote_management/cobbler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/cobbler/__init__.pyc,, +ansible/modules/remote_management/cobbler/cobbler_sync.py,sha256=qYu3zOfLVowszgVd8q94ukK-7w5ZktWidgrcN0FsKAQ,4403 +ansible/modules/remote_management/cobbler/cobbler_sync.pyc,, +ansible/modules/remote_management/cobbler/cobbler_system.py,sha256=d4e6Sy1F4EXJDjGqo-VrAtSEq3FTgvEjzI_8NyqvpSA,10729 +ansible/modules/remote_management/cobbler/cobbler_system.pyc,, +ansible/modules/remote_management/cpm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/cpm/__init__.pyc,, +ansible/modules/remote_management/cpm/cpm_user.py,sha256=zABWOaDZWFSxy2x60pIMR9w0pMZ3541Aqr5c-5mgW4o,12523 +ansible/modules/remote_management/cpm/cpm_user.pyc,, +ansible/modules/remote_management/foreman/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/foreman/__init__.pyc,, +ansible/modules/remote_management/foreman/foreman.py,sha256=3ObM8WvTUNhakNN4AcIvM_anT_F1b9vrhbnHckQA34Y,4415 +ansible/modules/remote_management/foreman/foreman.pyc,, +ansible/modules/remote_management/foreman/katello.py,sha256=zHH_IHl4dHPkT_z99TScwMQR1CdOgyMg90Bz9Wd1NtA,20533 +ansible/modules/remote_management/foreman/katello.pyc,, +ansible/modules/remote_management/hpilo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/hpilo/__init__.pyc,, +ansible/modules/remote_management/hpilo/hpilo_boot.py,sha256=vNN5Qg0IR3pUCkGy0z1IX16nX4EzlAI-rgDJiNfW8l0,6630 +ansible/modules/remote_management/hpilo/hpilo_boot.pyc,, +ansible/modules/remote_management/hpilo/hpilo_facts.py,sha256=WEqIRP0sk0Yy64LxrLsTsC5Jpem4G8demwV5A_kN9_E,7754 +ansible/modules/remote_management/hpilo/hpilo_facts.pyc,, +ansible/modules/remote_management/hpilo/hponcfg.py,sha256=SRrqiYgnjmkh3OAnOwxiFioDHdXycPCD-3toCFdNiQo,2984 +ansible/modules/remote_management/hpilo/hponcfg.pyc,, +ansible/modules/remote_management/imc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/imc/__init__.pyc,, +ansible/modules/remote_management/imc/imc_rest.py,sha256=WimJL89WeJ_9OdBCS2eEQoO9s02JsJLmP5deMVOYZ-k,14815 +ansible/modules/remote_management/imc/imc_rest.pyc,, +ansible/modules/remote_management/ipmi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/ipmi/__init__.pyc,, +ansible/modules/remote_management/ipmi/ipmi_boot.py,sha256=UB4q9JM24Wey6b7yUo16kksibeqSCtYumqPfXtQWuE0,5577 +ansible/modules/remote_management/ipmi/ipmi_boot.pyc,, +ansible/modules/remote_management/ipmi/ipmi_power.py,sha256=KU9U4zW-MarfTzOKXeJkie9KlxY_NEJbtmddY5vmTBc,3462 +ansible/modules/remote_management/ipmi/ipmi_power.pyc,, +ansible/modules/remote_management/manageiq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/manageiq/__init__.pyc,, +ansible/modules/remote_management/manageiq/manageiq_alert_profiles.py,sha256=tpe-bOxjGpu46OvNuBaE46qALuV4RTEN5rxVR0d0SQM,11282 +ansible/modules/remote_management/manageiq/manageiq_alert_profiles.pyc,, +ansible/modules/remote_management/manageiq/manageiq_alerts.py,sha256=9YCSbEchbfYKKu-MeU60stsH0UxNNBxwTiqewGsO-2E,12954 +ansible/modules/remote_management/manageiq/manageiq_alerts.pyc,, +ansible/modules/remote_management/manageiq/manageiq_policies.py,sha256=Oeqi-9Ns_03fcmrs7osnYdmZtBVvxQAaaFrMArmVids,11828 +ansible/modules/remote_management/manageiq/manageiq_policies.pyc,, +ansible/modules/remote_management/manageiq/manageiq_provider.py,sha256=L8tAHKObDAtB-xPeQtiyqseeEQvtHxYFKi0uimXdjPk,35689 +ansible/modules/remote_management/manageiq/manageiq_provider.pyc,, +ansible/modules/remote_management/manageiq/manageiq_tags.py,sha256=LukDDlCBOjPdq20xoh4rnmvtmvNMQxnNKpbkIhpzVuA,9225 +ansible/modules/remote_management/manageiq/manageiq_tags.pyc,, +ansible/modules/remote_management/manageiq/manageiq_user.py,sha256=2QvJW9NkujNbU3Qt8BVGgknf7ungQ7q0668DtyiddT0,10097 +ansible/modules/remote_management/manageiq/manageiq_user.pyc,, +ansible/modules/remote_management/oneview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/oneview/__init__.pyc,, +ansible/modules/remote_management/oneview/oneview_datacenter_facts.py,sha256=v-s1FFSyR1Jxq_uqbzaaAxFFAG154LCg7vpE1BZz_q4,3758 +ansible/modules/remote_management/oneview/oneview_datacenter_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_enclosure_facts.py,sha256=G17B21azLgjkJZJOQdFTQ0HqMszYET9Q6dTZWv7SpPA,6416 +ansible/modules/remote_management/oneview/oneview_enclosure_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_ethernet_network.py,sha256=2jpH4d3g3vVMV5f4jwff3NdO62G_Pw-xPPmywXN7k4g,8911 +ansible/modules/remote_management/oneview/oneview_ethernet_network.pyc,, +ansible/modules/remote_management/oneview/oneview_ethernet_network_facts.py,sha256=UaQUR2Exx3SjPz2od9DBF2HShIbtR4OndbiCl7a24gM,4863 +ansible/modules/remote_management/oneview/oneview_ethernet_network_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_fc_network.py,sha256=DZ_PfmpacBmYVEZ3J3OoXUEgDLlI79YTW7ALckvKd8M,3885 +ansible/modules/remote_management/oneview/oneview_fc_network.pyc,, +ansible/modules/remote_management/oneview/oneview_fc_network_facts.py,sha256=Zk8W-6P2NFXCWfEW9_21RmeLDy6Q0R8s6ACKID8opaQ,2677 +ansible/modules/remote_management/oneview/oneview_fc_network_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_fcoe_network.py,sha256=ZtFr9qX7ur5_unMPKj2hAUnRGEvs-G0bzCBa3X1aQgE,3724 +ansible/modules/remote_management/oneview/oneview_fcoe_network.pyc,, +ansible/modules/remote_management/oneview/oneview_fcoe_network_facts.py,sha256=lIhtgRFnTxQjV2BKQeLDjunQUoTXvQP4PRehVtSsBTw,2632 +ansible/modules/remote_management/oneview/oneview_fcoe_network_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_logical_interconnect_group.py,sha256=TIA4rFOeJvGO37bI4bRvYzZs8J5541pNNzVMwmueey0,5922 +ansible/modules/remote_management/oneview/oneview_logical_interconnect_group.pyc,, +ansible/modules/remote_management/oneview/oneview_logical_interconnect_group_facts.py,sha256=NwvNcsr70pzwb3Lg2ZnyIpN-FgSOhQkvR7EwXt3OCaw,3101 +ansible/modules/remote_management/oneview/oneview_logical_interconnect_group_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_network_set.py,sha256=IEsEI843pyT2UTkCHZ2yIL0T13lmDDdjsGAlUspmuZQ,5167 +ansible/modules/remote_management/oneview/oneview_network_set.pyc,, +ansible/modules/remote_management/oneview/oneview_network_set_facts.py,sha256=FEteAXPjajTLkOl8yzl4lAttO_cxq022yuUv5EUJLbo,3966 +ansible/modules/remote_management/oneview/oneview_network_set_facts.pyc,, +ansible/modules/remote_management/oneview/oneview_san_manager.py,sha256=wKJR0yz151E_DjkwS45SWgcbT6gWP2rxuQDR5L8X6FE,7717 +ansible/modules/remote_management/oneview/oneview_san_manager.pyc,, +ansible/modules/remote_management/oneview/oneview_san_manager_facts.py,sha256=r8A1rl93To7k2txWW64ZCEm71UIy7Tkb8V6yH0-XuUE,3321 +ansible/modules/remote_management/oneview/oneview_san_manager_facts.pyc,, +ansible/modules/remote_management/redfish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/redfish/__init__.pyc,, +ansible/modules/remote_management/redfish/redfish_command.py,sha256=rEb8OxlBKxpLc3aSl8w7WPC3F-UWIID0KTz_oD_CfBc,8111 +ansible/modules/remote_management/redfish/redfish_command.pyc,, +ansible/modules/remote_management/redfish/redfish_config.py,sha256=NvukV0CJfiDwAhOWGAZtHkDu_x9NoyJTsnSeBAioUM8,7546 +ansible/modules/remote_management/redfish/redfish_config.pyc,, +ansible/modules/remote_management/redfish/redfish_facts.py,sha256=tsjM2nj9UZGd75SFaqMO0xc1QefXqzNZzAcD7lKJqRQ,9430 +ansible/modules/remote_management/redfish/redfish_facts.pyc,, +ansible/modules/remote_management/stacki/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/stacki/__init__.pyc,, +ansible/modules/remote_management/stacki/stacki_host.py,sha256=Lcz0X7_akTbR9yk6sC57zAX7BlTjiKh2D5Z5RRlQq0U,9508 +ansible/modules/remote_management/stacki/stacki_host.pyc,, +ansible/modules/remote_management/ucs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/remote_management/ucs/__init__.pyc,, +ansible/modules/remote_management/ucs/ucs_ip_pool.py,sha256=6ieZshFew0mrexDU0weSmRBWrABmIWmXKxP6WUYBbKI,11474 +ansible/modules/remote_management/ucs/ucs_ip_pool.pyc,, +ansible/modules/remote_management/ucs/ucs_lan_connectivity.py,sha256=oBMj2HeABoH97pNjPQCB0uz40ODDSylWKX4iHwpcvbg,7508 +ansible/modules/remote_management/ucs/ucs_lan_connectivity.pyc,, +ansible/modules/remote_management/ucs/ucs_mac_pool.py,sha256=GL1yzLTsPl2w23wkh1k9EIKoEnrwnDHjHgqcJB2W08U,6484 +ansible/modules/remote_management/ucs/ucs_mac_pool.pyc,, +ansible/modules/remote_management/ucs/ucs_ntp_server.py,sha256=W-E3F1F0FRSgl4kEr_rR5lZhHv_Qd88aO5-Pt2RL7zg,4688 +ansible/modules/remote_management/ucs/ucs_ntp_server.pyc,, +ansible/modules/remote_management/ucs/ucs_san_connectivity.py,sha256=sWyyh2CnwknctasrPtzZ0jSfifK1WLJ8ihyPMoCZuY8,9965 +ansible/modules/remote_management/ucs/ucs_san_connectivity.pyc,, +ansible/modules/remote_management/ucs/ucs_storage_profile.py,sha256=ovytT5BBTaNvC77pxJ2lnN_hBeSV-RawFzvcZlPzdew,9409 +ansible/modules/remote_management/ucs/ucs_storage_profile.pyc,, +ansible/modules/remote_management/ucs/ucs_timezone.py,sha256=3J493g5fvKios2CcvpZPxB4hXJsNfzbSwca5ch7w014,4938 +ansible/modules/remote_management/ucs/ucs_timezone.pyc,, +ansible/modules/remote_management/ucs/ucs_uuid_pool.py,sha256=X-aHR9iX7AVJjslrgIQB7CGuNs-sgptbZxNl4vBiJes,7272 +ansible/modules/remote_management/ucs/ucs_uuid_pool.pyc,, +ansible/modules/remote_management/ucs/ucs_vhba_template.py,sha256=XFtkHYDS4T-lOHyK-GVyqqbSlAxCjpl7_WJUMVBEY1M,11155 +ansible/modules/remote_management/ucs/ucs_vhba_template.pyc,, +ansible/modules/remote_management/ucs/ucs_vlans.py,sha256=NbBDkkPcEFAVq_TYlkcgDO_Z5P8naEXZdkKDCm9v6eQ,6941 +ansible/modules/remote_management/ucs/ucs_vlans.pyc,, +ansible/modules/remote_management/ucs/ucs_vnic_template.py,sha256=bsoy7D3MDvw5MwPfrpWDDeUbTdoj5iWlI6-_X6FTCNI,16297 +ansible/modules/remote_management/ucs/ucs_vnic_template.pyc,, +ansible/modules/remote_management/ucs/ucs_vsans.py,sha256=YcL5O_hJ2YHPztc_yx4wEGl5GwGu_2QiEDlWmH_KScc,7479 +ansible/modules/remote_management/ucs/ucs_vsans.pyc,, +ansible/modules/remote_management/ucs/ucs_wwn_pool.py,sha256=XbJBRHOX6eVLnbONKYBvx6uPDpZcONiUSTt4EP4rb6U,8651 +ansible/modules/remote_management/ucs/ucs_wwn_pool.pyc,, +ansible/modules/remote_management/wakeonlan.py,sha256=DhzH_9eV6Z9JXULcj3BwKCfZfcrZ6ikyay3bro9Q-gA,3629 +ansible/modules/remote_management/wakeonlan.pyc,, +ansible/modules/source_control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/source_control/__init__.pyc,, +ansible/modules/source_control/bzr.py,sha256=q6ambAhqPUWm3aBGL-d7mLutE4N5FnnwY5hUyvZSlRo,6088 +ansible/modules/source_control/bzr.pyc,, +ansible/modules/source_control/git.py,sha256=0hjz4KIyV6-Vxw726UYd2l3YZUSUUVLHXSiiWzEGEqI,48003 +ansible/modules/source_control/git.pyc,, +ansible/modules/source_control/git_config.py,sha256=gKQJq7zKoqJwcg_QS9FZmPg-y4QxpKffs3Tj8dXnxvg,6941 +ansible/modules/source_control/git_config.pyc,, +ansible/modules/source_control/github_deploy_key.py,sha256=QvoQ1VyzO7v75kY6qtYP5eqWTJqTDnFwOvejzw6Xwt8,10752 +ansible/modules/source_control/github_deploy_key.pyc,, +ansible/modules/source_control/github_hooks.py,sha256=HOgBclPoGsVtYXVlBOEJzT8qh0p90EO7fO7jeWIjtZs,5874 +ansible/modules/source_control/github_hooks.pyc,, +ansible/modules/source_control/github_issue.py,sha256=S8pPgTtomCnrDi6RpcvcndxtlXooGPrcWA5WpUkq1lA,3009 +ansible/modules/source_control/github_issue.pyc,, +ansible/modules/source_control/github_key.py,sha256=m3JyK-yLl6xLYzKKJxBzcln2_v5__S7DmdpVm4Fxu5A,7544 +ansible/modules/source_control/github_key.pyc,, +ansible/modules/source_control/github_release.py,sha256=SR7ZelsQKT_FfgMsPGlxJPAkgtUmUV7tpTi50qte-dc,6155 +ansible/modules/source_control/github_release.pyc,, +ansible/modules/source_control/gitlab_deploy_key.py,sha256=gmkRV_kZVsp-xmCmo8qrBe1E_SDZ9LizFfNN5gHyz-U,7171 +ansible/modules/source_control/gitlab_deploy_key.pyc,, +ansible/modules/source_control/gitlab_group.py,sha256=9Z7xnLnivg7a1CwPWNr0cIYEYrz-Sn8-0g52GvkPOC8,7742 +ansible/modules/source_control/gitlab_group.pyc,, +ansible/modules/source_control/gitlab_hooks.py,sha256=Kc8yslfCY75irKWCNstH5hvkPtj5eEygnrmqtD9aMiw,9398 +ansible/modules/source_control/gitlab_hooks.pyc,, +ansible/modules/source_control/gitlab_project.py,sha256=TRVkp0nXM4dyOYeUEHNSuPDNBqvbRu6dP5NBf1-9700,14738 +ansible/modules/source_control/gitlab_project.pyc,, +ansible/modules/source_control/gitlab_user.py,sha256=seUEzHo7kHadEFMvjVnMfypQZpcydxJmqit6Acyhpy4,12638 +ansible/modules/source_control/gitlab_user.pyc,, +ansible/modules/source_control/hg.py,sha256=xfnsLy_kteq7OS_gwpO_nUp3MECdV40r-85rIMyD4g0,9928 +ansible/modules/source_control/hg.pyc,, +ansible/modules/source_control/subversion.py,sha256=mvUvs3uNuqnAK1lKRc2MG0W_4bqadQYayOMGw8fjCX0,10466 +ansible/modules/source_control/subversion.pyc,, +ansible/modules/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/__init__.pyc,, +ansible/modules/storage/emc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/emc/__init__.pyc,, +ansible/modules/storage/emc/emc_vnx_sg_member.py,sha256=a6PnVCgiiYkZ7XtFcqWNckSC25zsMHhAXC2FtgjUPTQ,4976 +ansible/modules/storage/emc/emc_vnx_sg_member.pyc,, +ansible/modules/storage/glusterfs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/glusterfs/__init__.pyc,, +ansible/modules/storage/glusterfs/gluster_peer.py,sha256=rOvqjNWmycXlmLsEEVYm17bsPIc_I4SoYz5UlvNhBnY,5811 +ansible/modules/storage/glusterfs/gluster_peer.pyc,, +ansible/modules/storage/glusterfs/gluster_volume.py,sha256=0m1VaH6vbNj_FcF4suvp5s3JUl6qJalZNhLvbdOAdx8,15711 +ansible/modules/storage/glusterfs/gluster_volume.pyc,, +ansible/modules/storage/ibm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/ibm/__init__.pyc,, +ansible/modules/storage/ibm/ibm_sa_host.py,sha256=EhMKvUuFDhTzQaByoWSm0knKt4w6PSXpqOO1vdsE9ws,3260 +ansible/modules/storage/ibm/ibm_sa_host.pyc,, +ansible/modules/storage/ibm/ibm_sa_pool.py,sha256=agmhHrWThPMvLKu3vBxrZBaqaJ1HtTF4x3E65FuGEIk,2954 +ansible/modules/storage/ibm/ibm_sa_pool.pyc,, +ansible/modules/storage/ibm/ibm_sa_vol.py,sha256=r7i8veRQmo4sxcZfgCbMUBJdwxmRoVpB7kLmFIMYjDg,2711 +ansible/modules/storage/ibm/ibm_sa_vol.pyc,, +ansible/modules/storage/infinidat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/infinidat/__init__.pyc,, +ansible/modules/storage/infinidat/infini_export.py,sha256=l1P5d2vhMWElqFv1AOX13Zp8V_RKo-bACw3Mgs5-Tvw,5122 +ansible/modules/storage/infinidat/infini_export.pyc,, +ansible/modules/storage/infinidat/infini_export_client.py,sha256=V7WJB5jo3hi6cSPSN9_lVJztRFn3Qtt6tSG_5LZtGXg,5489 +ansible/modules/storage/infinidat/infini_export_client.pyc,, +ansible/modules/storage/infinidat/infini_fs.py,sha256=gxXlwpnHqYHUTbuWUQCasBfkm6VC1IXBEwb5NmCJMJA,4473 +ansible/modules/storage/infinidat/infini_fs.pyc,, +ansible/modules/storage/infinidat/infini_host.py,sha256=pqgxkKDyQqkbW999XKYk0GBgzve7JWwiTGnRKcEjLqM,3806 +ansible/modules/storage/infinidat/infini_host.pyc,, +ansible/modules/storage/infinidat/infini_pool.py,sha256=iiYIJOc6cCyFTQWfzjLKNcESTtKNwaCmoIIye2GigeE,6070 +ansible/modules/storage/infinidat/infini_pool.pyc,, +ansible/modules/storage/infinidat/infini_vol.py,sha256=FX7hYp0KuZRoaiD6pbliIqLE_SGJJof170NVfyDyX3k,4218 +ansible/modules/storage/infinidat/infini_vol.pyc,, +ansible/modules/storage/netapp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/netapp/__init__.pyc,, +ansible/modules/storage/netapp/_na_cdot_aggregate.py,sha256=lpDAqNrDXkPjMmB-H_wnq_Hsmz4V-XUnrnrbfb66I0g,7277 +ansible/modules/storage/netapp/_na_cdot_aggregate.pyc,, +ansible/modules/storage/netapp/_na_cdot_license.py,sha256=fyy0CxPILNxG_Nl14wjW-ufWBROv3bAqzub2ORImn1E,9290 +ansible/modules/storage/netapp/_na_cdot_license.pyc,, +ansible/modules/storage/netapp/_na_cdot_lun.py,sha256=5MptzKYQgKwbcWxvufGTLS8W5tagkW6ctnpzNUIQouU,12268 +ansible/modules/storage/netapp/_na_cdot_lun.pyc,, +ansible/modules/storage/netapp/_na_cdot_qtree.py,sha256=87BqxcdnB3rpzISeXxRT7o7FY5_fekZgnUhioQl2w8E,7122 +ansible/modules/storage/netapp/_na_cdot_qtree.pyc,, +ansible/modules/storage/netapp/_na_cdot_svm.py,sha256=sqLpZJIrBneInVfCaDSz4prBJQMrX1nuJyj1pNZ_5nA,8401 +ansible/modules/storage/netapp/_na_cdot_svm.pyc,, +ansible/modules/storage/netapp/_na_cdot_user.py,sha256=5H_0zCGcj-NJsRYXrNaay5-RaoEL96NPRn4wxM0o79k,10369 +ansible/modules/storage/netapp/_na_cdot_user.pyc,, +ansible/modules/storage/netapp/_na_cdot_user_role.py,sha256=N7PUyFZdjZCAy_-JlHu3Ber1riygEZVXZIK-87bk17c,7132 +ansible/modules/storage/netapp/_na_cdot_user_role.pyc,, +ansible/modules/storage/netapp/_na_cdot_volume.py,sha256=06vVHFWh2m7BK47w-xYM4sHX2_74-CCQVNJpWpe-DDc,15175 +ansible/modules/storage/netapp/_na_cdot_volume.pyc,, +ansible/modules/storage/netapp/_sf_account_manager.py,sha256=zPurBnTWaIgjpXO7Qj5C0r-iET2NyXgveTOmcKuTdqQ,8690 +ansible/modules/storage/netapp/_sf_account_manager.pyc,, +ansible/modules/storage/netapp/_sf_check_connections.py,sha256=c6Y9i1nWI4qyisoes3GSCU9F48cBUBNjU6uxolGKDRI,5290 +ansible/modules/storage/netapp/_sf_check_connections.pyc,, +ansible/modules/storage/netapp/_sf_snapshot_schedule_manager.py,sha256=ksJ8PNmZf-LXkXhzKlCXkTcmteKo4UxDb0gNxo-F-Es,13136 +ansible/modules/storage/netapp/_sf_snapshot_schedule_manager.pyc,, +ansible/modules/storage/netapp/_sf_volume_access_group_manager.py,sha256=Sl6tqxqVa9i5C3RdrQC6S47-ikw-vNzu1gj-Fo8vOSc,8944 +ansible/modules/storage/netapp/_sf_volume_access_group_manager.pyc,, +ansible/modules/storage/netapp/_sf_volume_manager.py,sha256=NUaWNqqU_JzcrffXlo7dd-iFoLOIXjZx9XGaWd0T6Y4,10898 +ansible/modules/storage/netapp/_sf_volume_manager.pyc,, +ansible/modules/storage/netapp/na_elementsw_access_group.py,sha256=BUavjVbfNF5RvFxCcLiFPa1dVj13dcOP2jzV9AEbEbo,10795 +ansible/modules/storage/netapp/na_elementsw_access_group.pyc,, +ansible/modules/storage/netapp/na_elementsw_account.py,sha256=UchIRR2vAp3350OF2KfWjlZdhmMIVU47XC3RD7k5-2o,9838 +ansible/modules/storage/netapp/na_elementsw_account.pyc,, +ansible/modules/storage/netapp/na_elementsw_admin_users.py,sha256=E7MaTBGHHOUZgAnl01ifHvaW1t5EGBzN1DnuOhBSmqQ,7069 +ansible/modules/storage/netapp/na_elementsw_admin_users.pyc,, +ansible/modules/storage/netapp/na_elementsw_backup.py,sha256=qgjOMaWTfvAJ5zxIsqAfrk-XbQQOdxK0Qj7FJtXxJjM,9111 +ansible/modules/storage/netapp/na_elementsw_backup.pyc,, +ansible/modules/storage/netapp/na_elementsw_check_connections.py,sha256=nTTxX3qW-8Hke0bvCHbRQkwaukheQhnC0w3l6rYMJfM,4503 +ansible/modules/storage/netapp/na_elementsw_check_connections.pyc,, +ansible/modules/storage/netapp/na_elementsw_cluster.py,sha256=cba-K39kUYu5a7hmACGs_xnpBkIeRxwn4w76MXCowCc,7411 +ansible/modules/storage/netapp/na_elementsw_cluster.pyc,, +ansible/modules/storage/netapp/na_elementsw_cluster_pair.py,sha256=P84Y57i8Mdq1FfIVA5Yi5LKsmSRRcR_-azuNPU5AK3o,6362 +ansible/modules/storage/netapp/na_elementsw_cluster_pair.pyc,, +ansible/modules/storage/netapp/na_elementsw_drive.py,sha256=_wOEsccifOom9c0VbE_ZZnYX_HcHBRhwwJ5E6LrPeYA,11033 +ansible/modules/storage/netapp/na_elementsw_drive.pyc,, +ansible/modules/storage/netapp/na_elementsw_ldap.py,sha256=2Ew3ceozy63OKIE1NGHWDaSUXS7K80mKKdrLffNViBk,8686 +ansible/modules/storage/netapp/na_elementsw_ldap.pyc,, +ansible/modules/storage/netapp/na_elementsw_network_interfaces.py,sha256=roap0Emlt5NB78bYQATtSdF6_PRdpwk9Ik71D5w1KcM,10960 +ansible/modules/storage/netapp/na_elementsw_network_interfaces.pyc,, +ansible/modules/storage/netapp/na_elementsw_node.py,sha256=jqPzY59P5mfEhUho2GD3392-maU-h1-G2GUQmOwwK0s,8381 +ansible/modules/storage/netapp/na_elementsw_node.pyc,, +ansible/modules/storage/netapp/na_elementsw_snapshot.py,sha256=1hSl7WKYxtDXWwFpsuY8rfApSoAUp63fT3eyLWiLrd0,13110 +ansible/modules/storage/netapp/na_elementsw_snapshot.pyc,, +ansible/modules/storage/netapp/na_elementsw_snapshot_restore.py,sha256=GifMLzE_REvteVI_ZCckLgLS6nHPZSmON-DoeVFYnMI,6133 +ansible/modules/storage/netapp/na_elementsw_snapshot_restore.pyc,, +ansible/modules/storage/netapp/na_elementsw_snapshot_schedule.py,sha256=d1k06a3uNoYBvOBFiLaW-qb_0la5_LwVVfxkaoiP6WU,22400 +ansible/modules/storage/netapp/na_elementsw_snapshot_schedule.pyc,, +ansible/modules/storage/netapp/na_elementsw_vlan.py,sha256=RuhZbXIZmpckKxACSXwRFZ2cyKCEo-BfkmXLu2QeIO8,8506 +ansible/modules/storage/netapp/na_elementsw_vlan.pyc,, +ansible/modules/storage/netapp/na_elementsw_volume.py,sha256=ZIaYhBUU-2DvFVXTVkLe5F4qQbraQpX47yopG0pir2E,13485 +ansible/modules/storage/netapp/na_elementsw_volume.pyc,, +ansible/modules/storage/netapp/na_elementsw_volume_clone.py,sha256=sOH9UjPgxpiM5MpbFSr2zw8blBpsggQov41IVlI8ZkU,8961 +ansible/modules/storage/netapp/na_elementsw_volume_clone.pyc,, +ansible/modules/storage/netapp/na_elementsw_volume_pair.py,sha256=kHkHj3DgRmsNWmnrOiKOyBcOvtLTXv1px3-OfrT-URk,10231 +ansible/modules/storage/netapp/na_elementsw_volume_pair.pyc,, +ansible/modules/storage/netapp/na_ontap_aggregate.py,sha256=BtcaGAiFjJvxouoDj28mejRGz_gBinmFqrwD-4Pgr4s,14457 +ansible/modules/storage/netapp/na_ontap_aggregate.pyc,, +ansible/modules/storage/netapp/na_ontap_autosupport.py,sha256=3-6MNmY7L-Nd3qgr4IkZvJnHmftGOhfHzabhsFoTTws,8730 +ansible/modules/storage/netapp/na_ontap_autosupport.pyc,, +ansible/modules/storage/netapp/na_ontap_broadcast_domain.py,sha256=5ihUEVRp8XBdsnhFkXZTfd3olOJPnsOmqnXU5xmJelg,9431 +ansible/modules/storage/netapp/na_ontap_broadcast_domain.pyc,, +ansible/modules/storage/netapp/na_ontap_broadcast_domain_ports.py,sha256=uzf6yjAJxhgB1J2N_rfG2Uld77WVcLA0EswNz5soUHI,8223 +ansible/modules/storage/netapp/na_ontap_broadcast_domain_ports.pyc,, +ansible/modules/storage/netapp/na_ontap_cg_snapshot.py,sha256=aa7bJ-qS5_J97v_wIERZn0vGki0_O7w8mN4cERfI2Lo,7951 +ansible/modules/storage/netapp/na_ontap_cg_snapshot.pyc,, +ansible/modules/storage/netapp/na_ontap_cifs.py,sha256=_YUHBOWi65NeVnoBJNxZiDqgjQ0O4NKF4u36B__Wln4,8372 +ansible/modules/storage/netapp/na_ontap_cifs.pyc,, +ansible/modules/storage/netapp/na_ontap_cifs_acl.py,sha256=hvsPU5bGJTQmzNUoPMdl9dL-Vj7DdD3DaGLmtU0OXPs,8958 +ansible/modules/storage/netapp/na_ontap_cifs_acl.pyc,, +ansible/modules/storage/netapp/na_ontap_cifs_server.py,sha256=u8laE_ZOXEgejrprilWde3tXxHAbEj2he2CN4BbqWsw,11290 +ansible/modules/storage/netapp/na_ontap_cifs_server.pyc,, +ansible/modules/storage/netapp/na_ontap_cluster.py,sha256=w6xJdmaZTEVuRULfqJ4Y3oyFmHrn-Y52hDa6cbA7HHI,8200 +ansible/modules/storage/netapp/na_ontap_cluster.pyc,, +ansible/modules/storage/netapp/na_ontap_cluster_ha.py,sha256=xSGnq_VT7Vyr9tBXRV-3Q0iz8SF-mt7W93xBwVHT4Xo,4439 +ansible/modules/storage/netapp/na_ontap_cluster_ha.pyc,, +ansible/modules/storage/netapp/na_ontap_cluster_peer.py,sha256=6xwSTfch7L6VFrvAKA7ugDWjLumEA5yJQbtNSWpkHow,11296 +ansible/modules/storage/netapp/na_ontap_cluster_peer.pyc,, +ansible/modules/storage/netapp/na_ontap_command.py,sha256=JMiJeRpoooFXAYJk-QhKvlRTZLsBeq9mE1uOE_YPubQ,3127 +ansible/modules/storage/netapp/na_ontap_command.pyc,, +ansible/modules/storage/netapp/na_ontap_disks.py,sha256=bXijpLSS9Lkr0YJX0-eSox1HG4Y9LSbvLX2wlIHunG8,4335 +ansible/modules/storage/netapp/na_ontap_disks.pyc,, +ansible/modules/storage/netapp/na_ontap_dns.py,sha256=lNsoylJXSlH3nOP60jF29Mhty85eu4jrpIReJFrmHVE,7241 +ansible/modules/storage/netapp/na_ontap_dns.pyc,, +ansible/modules/storage/netapp/na_ontap_export_policy.py,sha256=9NfzHdlc1JDnnv5ENWsOTFyb7jzgqP91kikeFyMlpQc,8299 +ansible/modules/storage/netapp/na_ontap_export_policy.pyc,, +ansible/modules/storage/netapp/na_ontap_export_policy_rule.py,sha256=D88WcJQD7VNl60_JwP7XcKDwntvkTAEII3p5Vok4sNM,22256 +ansible/modules/storage/netapp/na_ontap_export_policy_rule.pyc,, +ansible/modules/storage/netapp/na_ontap_fcp.py,sha256=9qznNxfWUtf-TP5dcA995xBtcxikmq3RDaW2OmC6xsU,6561 +ansible/modules/storage/netapp/na_ontap_fcp.pyc,, +ansible/modules/storage/netapp/na_ontap_firewall_policy.py,sha256=aFKFE3-dJGmQ51XTV_1JTnyR5ntb7hattaPWVe_sDD4,12439 +ansible/modules/storage/netapp/na_ontap_firewall_policy.pyc,, +ansible/modules/storage/netapp/na_ontap_gather_facts.py,sha256=z9VyEcV8gpE4urlKXew1AT3OVQHOEPJiMKZG4ACDRyw,9247 +ansible/modules/storage/netapp/na_ontap_gather_facts.pyc,, +ansible/modules/storage/netapp/na_ontap_igroup.py,sha256=4GVlZN1enO4hFM0RUfzC8ycKUrxAURllNPa2HKxH8xU,12088 +ansible/modules/storage/netapp/na_ontap_igroup.pyc,, +ansible/modules/storage/netapp/na_ontap_interface.py,sha256=w5z4QgIrmDJzokywcf-yMtSqJ-kRcu2N4dF9TmciYgQ,13378 +ansible/modules/storage/netapp/na_ontap_interface.pyc,, +ansible/modules/storage/netapp/na_ontap_iscsi.py,sha256=718dNet8G708c7EySH_QwuT6vU94KsMJRZCAyxE2S-w,8326 +ansible/modules/storage/netapp/na_ontap_iscsi.pyc,, +ansible/modules/storage/netapp/na_ontap_job_schedule.py,sha256=IGGqd2gI6DlkB1_yYMuWeEHC1LvKdj7cmR3t9zaSTak,8224 +ansible/modules/storage/netapp/na_ontap_job_schedule.pyc,, +ansible/modules/storage/netapp/na_ontap_license.py,sha256=vxHjPtcT6byFVazYu9sZcR9SBNNuPTUKWY7G_n9VUs4,10435 +ansible/modules/storage/netapp/na_ontap_license.pyc,, +ansible/modules/storage/netapp/na_ontap_lun.py,sha256=ZP0TkeC3V5YcwGt0LcHIZ2-czcnrEBm2zGlZGpXPha4,13347 +ansible/modules/storage/netapp/na_ontap_lun.pyc,, +ansible/modules/storage/netapp/na_ontap_lun_map.py,sha256=VkiQL_qdMre6bNt_rNee3_DD22v-2paTTPueE4k49OQ,8496 +ansible/modules/storage/netapp/na_ontap_lun_map.pyc,, +ansible/modules/storage/netapp/na_ontap_motd.py,sha256=jx3HalC5IRsid9tx5fOFkSpBTcBYlXXWU_x-VNgXldw,4900 +ansible/modules/storage/netapp/na_ontap_motd.pyc,, +ansible/modules/storage/netapp/na_ontap_net_ifgrp.py,sha256=CmrYkMTPdG6M9C-VnRj2-K0biYv29OV3eUDJplV72pQ,11332 +ansible/modules/storage/netapp/na_ontap_net_ifgrp.pyc,, +ansible/modules/storage/netapp/na_ontap_net_port.py,sha256=5ah1FS2B2fY8eV4ekqm13J_DvGbYomzobG6-1_toR58,8175 +ansible/modules/storage/netapp/na_ontap_net_port.pyc,, +ansible/modules/storage/netapp/na_ontap_net_routes.py,sha256=iin5zHQljTx1WMOg5_Uc-9TqTSDB30-fBSG8bBY6fks,11272 +ansible/modules/storage/netapp/na_ontap_net_routes.pyc,, +ansible/modules/storage/netapp/na_ontap_net_vlan.py,sha256=wUCjoLA5IU9DyaLXJKwmhgS50wmpYhAFCJb9uOu-NKs,5676 +ansible/modules/storage/netapp/na_ontap_net_vlan.pyc,, +ansible/modules/storage/netapp/na_ontap_nfs.py,sha256=mrfaGTU4DQ28WnDQTdRO-Pzb4NJ7qUDzO_--rMna1Zc,21875 +ansible/modules/storage/netapp/na_ontap_nfs.pyc,, +ansible/modules/storage/netapp/na_ontap_node.py,sha256=iyqru4DUcaM8B3wpUyfV2gNFVdZ-0pOZUASV9Horj48,4276 +ansible/modules/storage/netapp/na_ontap_node.pyc,, +ansible/modules/storage/netapp/na_ontap_ntp.py,sha256=IJ2PGQBZv7Mq2C8D29POdM8OD_qL9t3q6fu31VAWyNk,7648 +ansible/modules/storage/netapp/na_ontap_ntp.pyc,, +ansible/modules/storage/netapp/na_ontap_qtree.py,sha256=wyJQ21QFL7si50_W-Gvubd8901ASrADjK3Ov_3v6tfk,7359 +ansible/modules/storage/netapp/na_ontap_qtree.pyc,, +ansible/modules/storage/netapp/na_ontap_service_processor_network.py,sha256=jre-2QsEe_bUWIO48HKBjylHHil6llfzDWCjA7ZJQPY,9677 +ansible/modules/storage/netapp/na_ontap_service_processor_network.pyc,, +ansible/modules/storage/netapp/na_ontap_snapmirror.py,sha256=pJprhF9bcT_2PilOZb2A8T8nOKmnXeSDD3zzINT08DI,19948 +ansible/modules/storage/netapp/na_ontap_snapmirror.pyc,, +ansible/modules/storage/netapp/na_ontap_snapshot.py,sha256=QkmbmAmWe5NcloSh_8u0UFUrN6R4KvpWfZLzzEtQCpw,11423 +ansible/modules/storage/netapp/na_ontap_snapshot.pyc,, +ansible/modules/storage/netapp/na_ontap_snmp.py,sha256=i5yOomZKdReM_IhBnkVC4ibArmNzdqpMkFbetiCA_Qw,4739 +ansible/modules/storage/netapp/na_ontap_snmp.pyc,, +ansible/modules/storage/netapp/na_ontap_software_update.py,sha256=tIWZ4B5SA8wbwUfvTY31_GHas-pp-du1M_sd-tzDqIk,9513 +ansible/modules/storage/netapp/na_ontap_software_update.pyc,, +ansible/modules/storage/netapp/na_ontap_svm.py,sha256=kjfPtK5hnuRAspu9GUiNqiHpZYC2KU8abM0LYrZtTCU,18691 +ansible/modules/storage/netapp/na_ontap_svm.pyc,, +ansible/modules/storage/netapp/na_ontap_svm_options.py,sha256=vIXDiyZDI8G5e3GrrDXcFy3Ln8apKeP240MV_IA4DUE,5187 +ansible/modules/storage/netapp/na_ontap_svm_options.pyc,, +ansible/modules/storage/netapp/na_ontap_ucadapter.py,sha256=9zYuDTkHpb8yV8MP5paY9XHFZtxLFymAISvlImzxm9k,7429 +ansible/modules/storage/netapp/na_ontap_ucadapter.pyc,, +ansible/modules/storage/netapp/na_ontap_user.py,sha256=5hzG0uvKOIaNY2dii6Oj-6lOmRSdIEt4GBTZiGGDuWo,14895 +ansible/modules/storage/netapp/na_ontap_user.pyc,, +ansible/modules/storage/netapp/na_ontap_user_role.py,sha256=6suJ266VQh_HxrqjiHfnsdsRGvW8dFsbeHRG2U1HvDQ,7289 +ansible/modules/storage/netapp/na_ontap_user_role.pyc,, +ansible/modules/storage/netapp/na_ontap_volume.py,sha256=bu9Noo0NaWkDvmNA1P2MlB8uLvq-_93J8MAfVBpUASg,22006 +ansible/modules/storage/netapp/na_ontap_volume.pyc,, +ansible/modules/storage/netapp/na_ontap_volume_clone.py,sha256=K9FKKYferxfF4Q3EQjfsVJs2WhZiW_-fqQ8v0p-s0Z8,6400 +ansible/modules/storage/netapp/na_ontap_volume_clone.pyc,, +ansible/modules/storage/netapp/na_ontap_vserver_peer.py,sha256=ZAlRg1tVaZHQvlGkHRZpYCyy-7zWuvQVF4utB1zL8j0,10944 +ansible/modules/storage/netapp/na_ontap_vserver_peer.pyc,, +ansible/modules/storage/netapp/netapp_e_alerts.py,sha256=RdA1infrp7k-E3Hmj0yDYOAVitTcGTEwL-scTuO-yGU,10359 +ansible/modules/storage/netapp/netapp_e_alerts.pyc,, +ansible/modules/storage/netapp/netapp_e_amg.py,sha256=4_Hd4pMW5jXLa-hsiXnixBAKa0y0JnZsWK5SNUh-87E,10293 +ansible/modules/storage/netapp/netapp_e_amg.pyc,, +ansible/modules/storage/netapp/netapp_e_amg_role.py,sha256=TmARK-I5_USN5lf_TL87StZKyVmBhfLS9llk0NxIls0,7854 +ansible/modules/storage/netapp/netapp_e_amg_role.pyc,, +ansible/modules/storage/netapp/netapp_e_amg_sync.py,sha256=4hE0RO8ZJZr6zf8GvzjQyr-eXPdbOs9Jy0nw0yLZsok,10104 +ansible/modules/storage/netapp/netapp_e_amg_sync.pyc,, +ansible/modules/storage/netapp/netapp_e_asup.py,sha256=5VpA1orgoUW6xK1orsq7t3PP3i7o0996UQKKPrHITDA,11223 +ansible/modules/storage/netapp/netapp_e_asup.pyc,, +ansible/modules/storage/netapp/netapp_e_auditlog.py,sha256=JJUF0kNEYebufB92gPUVxxfnK9x09qaVs4vZY5i574M,11343 +ansible/modules/storage/netapp/netapp_e_auditlog.pyc,, +ansible/modules/storage/netapp/netapp_e_auth.py,sha256=UFdPFb-sYMbLNmR163FL9KtQ3aGnSYdRB2YwBDVlcxs,10069 +ansible/modules/storage/netapp/netapp_e_auth.pyc,, +ansible/modules/storage/netapp/netapp_e_facts.py,sha256=JdiNOjuALrbxRrDjhxyrIRgIT6BvOsl1bN2n-lXHp24,6312 +ansible/modules/storage/netapp/netapp_e_facts.pyc,, +ansible/modules/storage/netapp/netapp_e_flashcache.py,sha256=cyILqX-_xuzxdYfyyWwe5e9kKgWHdD6IANFiBZVg5JQ,15757 +ansible/modules/storage/netapp/netapp_e_flashcache.pyc,, +ansible/modules/storage/netapp/netapp_e_global.py,sha256=N4DZavtDElcAs1GwqMEfk-9d87zdoQ93EUw97h5pqm4,4995 +ansible/modules/storage/netapp/netapp_e_global.pyc,, +ansible/modules/storage/netapp/netapp_e_host.py,sha256=_GTFAck6ZaFCLYu0sqZVM22Stv00SGsy3I1LGFqY6-A,23563 +ansible/modules/storage/netapp/netapp_e_host.pyc,, +ansible/modules/storage/netapp/netapp_e_hostgroup.py,sha256=UBctsUk6pOVy-ynyDSvdXelv-Gi9jhFC8U0jkedVaCw,13965 +ansible/modules/storage/netapp/netapp_e_hostgroup.pyc,, +ansible/modules/storage/netapp/netapp_e_iscsi_interface.py,sha256=mLYeoSe-yMAfOKxZLeKcWWCIGDf781fQi0UxsIfDBr8,16166 +ansible/modules/storage/netapp/netapp_e_iscsi_interface.pyc,, +ansible/modules/storage/netapp/netapp_e_iscsi_target.py,sha256=F92JWPXpwFXgB8wwDpyP4iaDVcuuvfcpBfZe07Igr3Y,10721 +ansible/modules/storage/netapp/netapp_e_iscsi_target.pyc,, +ansible/modules/storage/netapp/netapp_e_ldap.py,sha256=fqUsRGP8zeTT0wZotmQupgv9hXEJSLpcAhoQUtgjYNI,15917 +ansible/modules/storage/netapp/netapp_e_ldap.pyc,, +ansible/modules/storage/netapp/netapp_e_lun_mapping.py,sha256=O7iJYTPV-JC6dJ03ZEXd89-bMT9_ZSy2j6f-PD-lOR4,11981 +ansible/modules/storage/netapp/netapp_e_lun_mapping.pyc,, +ansible/modules/storage/netapp/netapp_e_mgmt_interface.py,sha256=4_f4ERitSWBIMz23vq5Ke91TCcoVMoomJG9IDhkt6X0,29414 +ansible/modules/storage/netapp/netapp_e_mgmt_interface.pyc,, +ansible/modules/storage/netapp/netapp_e_snapshot_group.py,sha256=ed8ByUstUo0R9nxEzlRhq0wqz3Fsxu7mFObfchDeD20,14599 +ansible/modules/storage/netapp/netapp_e_snapshot_group.pyc,, +ansible/modules/storage/netapp/netapp_e_snapshot_images.py,sha256=tqJJfr5KwMQu8QnxGdqIAHsxSbKMMgWWQwhqJ8dKoSI,8772 +ansible/modules/storage/netapp/netapp_e_snapshot_images.pyc,, +ansible/modules/storage/netapp/netapp_e_snapshot_volume.py,sha256=_iPlCv6-hf55Uyx6QT4KfLeEq8rxuNnwmnFVBEqOY3A,9915 +ansible/modules/storage/netapp/netapp_e_snapshot_volume.pyc,, +ansible/modules/storage/netapp/netapp_e_storage_system.py,sha256=SEsGIbJwwsp6XVtYylT5HyFp3laCADQ0DLN_z0LGZu0,10967 +ansible/modules/storage/netapp/netapp_e_storage_system.pyc,, +ansible/modules/storage/netapp/netapp_e_storagepool.py,sha256=AjItNxlE5dhAhNfx6hdlAK34_H8j7bfupMbL0Rq7OU0,36876 +ansible/modules/storage/netapp/netapp_e_storagepool.pyc,, +ansible/modules/storage/netapp/netapp_e_syslog.py,sha256=SOsUHpsNuOp6gI5vohe7jRQxiZ7VtQEB26vTRRfX-UQ,10538 +ansible/modules/storage/netapp/netapp_e_syslog.pyc,, +ansible/modules/storage/netapp/netapp_e_volume.py,sha256=-x3Q0QXA58Np9Ol0hg9n7EEv4sqUzGSi_RUqyvfDwfc,22952 +ansible/modules/storage/netapp/netapp_e_volume.pyc,, +ansible/modules/storage/netapp/netapp_e_volume_copy.py,sha256=kgjDxDgrsFj2hm_tjXvSXs1I5gmyUo6yhp-c5g7Vq00,16476 +ansible/modules/storage/netapp/netapp_e_volume_copy.pyc,, +ansible/modules/storage/purestorage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/purestorage/__init__.pyc,, +ansible/modules/storage/purestorage/purefa_ds.py,sha256=eV-Y4EZ5d6yMHbeGKqH2dr0sbQaCxE2NPUan8OhH-nE,9621 +ansible/modules/storage/purestorage/purefa_ds.pyc,, +ansible/modules/storage/purestorage/purefa_facts.py,sha256=GGzkjQCWxzbEwWOkWkjwZ1DjJUhcumkkpEPlA4mZ63E,20232 +ansible/modules/storage/purestorage/purefa_facts.pyc,, +ansible/modules/storage/purestorage/purefa_hg.py,sha256=PxezwcZdzXTxr7RN2IkKfYYhLhGgUBNpW_bFVKukeWo,7569 +ansible/modules/storage/purestorage/purefa_hg.pyc,, +ansible/modules/storage/purestorage/purefa_host.py,sha256=4TRVTueWUAuT5_cceAy39sbBMUlFRvPJUvbwATOPI3g,6690 +ansible/modules/storage/purestorage/purefa_host.pyc,, +ansible/modules/storage/purestorage/purefa_pg.py,sha256=Nl25YNE7qnyN4LCGtCjCCk07A95pQSVerO--wYk5Q-Q,5569 +ansible/modules/storage/purestorage/purefa_pg.pyc,, +ansible/modules/storage/purestorage/purefa_pgsnap.py,sha256=8tYUwNChibNjibWDX9enYyXAUz-mq7Myhl6mCxUgPd4,6597 +ansible/modules/storage/purestorage/purefa_pgsnap.pyc,, +ansible/modules/storage/purestorage/purefa_snap.py,sha256=tAcXPlqlTQeXr7ZMOhZXvj1kCBuAIpW0mRHxJrFiu2w,6610 +ansible/modules/storage/purestorage/purefa_snap.pyc,, +ansible/modules/storage/purestorage/purefa_volume.py,sha256=9bm2vE6oXhEjNQa7FJr8E3wvjI6AajZvwD4NYY1oJgM,6827 +ansible/modules/storage/purestorage/purefa_volume.pyc,, +ansible/modules/storage/purestorage/purefb_facts.py,sha256=XcelF8QSd_h3P0Khx0XB-EmkOInsuNuYnnh_JPcf-FA,23979 +ansible/modules/storage/purestorage/purefb_facts.pyc,, +ansible/modules/storage/purestorage/purefb_fs.py,sha256=tpnga8dNtOZfAjKtYwVmHhx7oXQX2UO1ya_6ePGeP5g,9813 +ansible/modules/storage/purestorage/purefb_fs.pyc,, +ansible/modules/storage/purestorage/purefb_snap.py,sha256=asXV_HrohQst33DzSkdAVFOV3E0dOIvlt6YZtQU2S7U,6617 +ansible/modules/storage/purestorage/purefb_snap.pyc,, +ansible/modules/storage/zfs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/storage/zfs/__init__.pyc,, +ansible/modules/storage/zfs/zfs.py,sha256=d0GncRTRpNRDgj2wliY3SdDOp7ERzJF9xQzppGxTaWo,9554 +ansible/modules/storage/zfs/zfs.pyc,, +ansible/modules/storage/zfs/zfs_facts.py,sha256=zLL1IHcOEMmlbiHZFO6WiN46QSM58mgv8ZUkOBODCcU,8007 +ansible/modules/storage/zfs/zfs_facts.pyc,, +ansible/modules/storage/zfs/zpool_facts.py,sha256=SG1jNhE6DPOd7-XGCUw9h_ZVecOwfiV7bGgPXFMzDkk,6554 +ansible/modules/storage/zfs/zpool_facts.pyc,, +ansible/modules/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/system/__init__.pyc,, +ansible/modules/system/aix_inittab.py,sha256=rBNItgN0cLM1KS-IhiVfPOhGjxbH4B6cjEksUXWyMHQ,7275 +ansible/modules/system/aix_inittab.pyc,, +ansible/modules/system/aix_lvol.py,sha256=FzcOHXo7u9W6PcUqaJMxWrAzQs9eHC5InX32ut6JwyE,10444 +ansible/modules/system/aix_lvol.pyc,, +ansible/modules/system/alternatives.py,sha256=zU6grns4ECg6doPzq0O8ZGkwWqdPebi703_tBjcGGws,5286 +ansible/modules/system/alternatives.pyc,, +ansible/modules/system/at.py,sha256=ow3OGpQVXpDX_YbLPfp31X7xd0r5v2ZCGNXuBopWeCg,5647 +ansible/modules/system/at.pyc,, +ansible/modules/system/authorized_key.py,sha256=b5N2MU-jO_FQ5qAFjC1SGe3SeVGAAkQtS2ZySy_eeFs,22215 +ansible/modules/system/authorized_key.pyc,, +ansible/modules/system/awall.py,sha256=WLHkQHD6VyeTJVt2EQXKf-xcMlJtw47-R7_U3e84M9U,4439 +ansible/modules/system/awall.pyc,, +ansible/modules/system/beadm.py,sha256=JZca_IHIwVpbPDQc_gUOkFqelXEtM5t96oOvna4be7g,11639 +ansible/modules/system/beadm.pyc,, +ansible/modules/system/capabilities.py,sha256=fD3fqMbrWTTfUQ_ZkToiHntuO2a7cI7YSAgoRrpoLsg,6520 +ansible/modules/system/capabilities.pyc,, +ansible/modules/system/cron.py,sha256=Aj2hnXEUlp8k5j4uEVP5ey-ckxLNJriaC3R1f1ckh1U,24993 +ansible/modules/system/cron.pyc,, +ansible/modules/system/cronvar.py,sha256=aPQZaXvVwmseIcYUqM-Xso3PlWFMNz7Kec6m-kt6huE,13521 +ansible/modules/system/cronvar.pyc,, +ansible/modules/system/crypttab.py,sha256=teH8XNHVewSaqHc6jLNve-SRIos7U-m_Gf6g-SU4Ql8,11050 +ansible/modules/system/crypttab.pyc,, +ansible/modules/system/dconf.py,sha256=d8Db13Z5JG8qaBunUMdfxMm7WfHPHz15YA3wWrnhrWM,13115 +ansible/modules/system/dconf.pyc,, +ansible/modules/system/debconf.py,sha256=3RVivl54EFscXnYHrLWK7WdJR_BV_S1PaVjqnRYcb6U,5176 +ansible/modules/system/debconf.pyc,, +ansible/modules/system/facter.py,sha256=u6JaZVUPqUdWvLrTAt4cQbJYIniZfuH0rQwQ8jOgr64,1321 +ansible/modules/system/facter.pyc,, +ansible/modules/system/filesystem.py,sha256=KzGe-VyE-_I7atgmhldwLCHo2bfspHsGvhMwRWJlwTc,13511 +ansible/modules/system/filesystem.pyc,, +ansible/modules/system/firewalld.py,sha256=gZUouA2h7voF1uFlou4Gbfz287WjEPM-glbmbZv1gbU,25034 +ansible/modules/system/firewalld.pyc,, +ansible/modules/system/gconftool2.py,sha256=R6eIh7Bo7QFx7uORhDQLahPgBNnLBOks7RYC_Sv-z9g,8247 +ansible/modules/system/gconftool2.pyc,, +ansible/modules/system/getent.py,sha256=6MRiF6BBB49CxGkXJZsI-o_cEwlXmDl0uTkuKQOFcRU,3914 +ansible/modules/system/getent.pyc,, +ansible/modules/system/group.py,sha256=Zlel6EMUWV05Pq79tAbsSX2fZeinJiemqcgVHrqF0ZY,14820 +ansible/modules/system/group.pyc,, +ansible/modules/system/hostname.py,sha256=gL6LEiqqhMpO9bMnzsg-s-piuJVnEXbO7_lTWAPzXPo,24853 +ansible/modules/system/hostname.pyc,, +ansible/modules/system/interfaces_file.py,sha256=Ah08frmFzoa1XEomClPCTIudw4LeHoetIjXg3imY470,14061 +ansible/modules/system/interfaces_file.pyc,, +ansible/modules/system/iptables.py,sha256=I805HCrHg3Fxr32g_orwFcbUG0_Pr8st6YUHTCUjXek,23260 +ansible/modules/system/iptables.pyc,, +ansible/modules/system/java_cert.py,sha256=S3zqXh8BmKos4wwz0PdClT7TV3ccCIqPEZF2GJCvStk,12948 +ansible/modules/system/java_cert.pyc,, +ansible/modules/system/java_keystore.py,sha256=zqYThQLJYcXU-I2kN4jigoWmjbUjey7YVIFD9hKoC5M,10876 +ansible/modules/system/java_keystore.pyc,, +ansible/modules/system/kernel_blacklist.py,sha256=fXDh-DEMw1M2ky-eMJc3hCquX8JkpQG_M1woXxgStuw,4009 +ansible/modules/system/kernel_blacklist.pyc,, +ansible/modules/system/known_hosts.py,sha256=0puSvGvklK8ztAEaqhA9kfdbGFR3SU2D6dbtLGBNktk,12519 +ansible/modules/system/known_hosts.pyc,, +ansible/modules/system/locale_gen.py,sha256=H5LSUZDI0lG6_aYQYZ5Joqoi-UOmzPJl9IfwTB8Lc2c,7255 +ansible/modules/system/locale_gen.pyc,, +ansible/modules/system/lvg.py,sha256=SAAx80kjWn7m8BUUumacnp2oBm9-a5lUzwToRokLpgY,10156 +ansible/modules/system/lvg.pyc,, +ansible/modules/system/lvol.py,sha256=rosFN_H0vd3gVmK0nglciptLTVe1UFEVi3jYiCJt5M8,19622 +ansible/modules/system/lvol.pyc,, +ansible/modules/system/make.py,sha256=bsRzWV8JiM65w8QWv6k__wOdTG08JT0MoBGoklMof04,4659 +ansible/modules/system/make.pyc,, +ansible/modules/system/mksysb.py,sha256=3q9b1OVGCgwu0hfXl9ClNcUXwHHRvNquW_6CmmhYPPw,5416 +ansible/modules/system/mksysb.pyc,, +ansible/modules/system/modprobe.py,sha256=oK6Tk8inr1UVJqd50N2uwuQPvk5CyLpUBgWSza1-Xgw,3271 +ansible/modules/system/modprobe.pyc,, +ansible/modules/system/mount.py,sha256=w_Y_gnmYCo4RAOmOgbvpE05qLvXpuo3hwM8Soo1KOZ0,21257 +ansible/modules/system/mount.pyc,, +ansible/modules/system/nosh.py,sha256=KIMEWbFCE-IMQ1bnL-tTuw2SWHHo1gLMj0QJ-NKXAEc,13974 +ansible/modules/system/nosh.pyc,, +ansible/modules/system/ohai.py,sha256=buIHf-EM9N3WZ1uNZrzd5xP7XJHnZFimChVKaJsBwAw,1375 +ansible/modules/system/ohai.pyc,, +ansible/modules/system/open_iscsi.py,sha256=vGnpq4Jw8ZDiCNiWpugatgIWsVB89-yXJogSKTfGO98,11466 +ansible/modules/system/open_iscsi.pyc,, +ansible/modules/system/openwrt_init.py,sha256=KHM3FdulwDyyBQEDNzWdBKvabinNw8FpdC--YFW_i48,6310 +ansible/modules/system/openwrt_init.pyc,, +ansible/modules/system/osx_defaults.py,sha256=YYpZEpFxNsG0qTo46LmqnF6J8J6drjf2Sx5-GZ7ijIc,13858 +ansible/modules/system/osx_defaults.pyc,, +ansible/modules/system/pam_limits.py,sha256=P6g8V0wvxPEeo5PNZs6LLMO6jSvSmDiH8KZ72zHPG8Y,9365 +ansible/modules/system/pam_limits.pyc,, +ansible/modules/system/pamd.py,sha256=8DKbBDsdpAsZK2kkx0VMnx0ouFKO2mY3DQUL1xtjOV8,31585 +ansible/modules/system/pamd.pyc,, +ansible/modules/system/parted.py,sha256=zAqjNLk3UAaVj48BXT2oTe82sWxrXzQbhF_ujbFyx6E,22317 +ansible/modules/system/parted.pyc,, +ansible/modules/system/ping.py,sha256=2dTzL7ETZOEmQxgzCnQK0_KGGg-Lvj_i9ukUoVlqhhI,2294 +ansible/modules/system/ping.pyc,, +ansible/modules/system/puppet.py,sha256=RfopNb0mRp02_UssQmlZxzKE2ojmUdafdBZERMHTB1o,9362 +ansible/modules/system/puppet.pyc,, +ansible/modules/system/python_requirements_facts.py,sha256=zuVOMwGzrZrPqwwgEHZOeFwE3UZauJqNO4ARhrwzrrA,4920 +ansible/modules/system/python_requirements_facts.pyc,, +ansible/modules/system/reboot.py,sha256=vrGmjBh_J5rJEF1uTlqqz_C6dPEvx61nsX1L3M2SCkc,2676 +ansible/modules/system/reboot.pyc,, +ansible/modules/system/runit.py,sha256=I_UKxCUPsWweoLpgQl8JKJq-7-OSbnHmfpHNxkxEWZg,8646 +ansible/modules/system/runit.pyc,, +ansible/modules/system/seboolean.py,sha256=3QbxjYrS8bYuNB7i34qx-3yoSNuJzl9q6Ow0l96axzc,6879 +ansible/modules/system/seboolean.pyc,, +ansible/modules/system/sefcontext.py,sha256=X98V-L1_NgQwB17L2gRkSFYkFOukapHJ2P2XzmkovpM,9068 +ansible/modules/system/sefcontext.pyc,, +ansible/modules/system/selinux.py,sha256=D2bVBl4bcq75I5Q0LaGJJkBoREz-l6Cqjj2svp-cOF4,8183 +ansible/modules/system/selinux.pyc,, +ansible/modules/system/selinux_permissive.py,sha256=0CHNZyJP0G4XCfc6qe6d4jsbfV6KtS8W0rX_7Guecs0,3865 +ansible/modules/system/selinux_permissive.pyc,, +ansible/modules/system/seport.py,sha256=7D_Iess-lyLIZscOvRbz0JFMrp_oXIpyUBxZxYKoUY0,7811 +ansible/modules/system/seport.pyc,, +ansible/modules/system/service.py,sha256=VOQmMEn2MJlA9fZYJQwtYAN2Dc8Pqpmw25JPJjNcRAk,61239 +ansible/modules/system/service.pyc,, +ansible/modules/system/service_facts.py,sha256=Emm-aac5K3yAP4dXRQaL3wTgY3MKA6wI-3iZyONGRhk,9313 +ansible/modules/system/service_facts.pyc,, +ansible/modules/system/setup.py,sha256=LVYCOY5my3BsufhVfZTV0CkFl_FipIzY7aps9lZsv2c,7876 +ansible/modules/system/setup.pyc,, +ansible/modules/system/solaris_zone.py,sha256=WrV7QpswYxs07c7lmvnTG_drH5uDrZFhoOnIlTnQtFA,16319 +ansible/modules/system/solaris_zone.pyc,, +ansible/modules/system/svc.py,sha256=7rQJIbs3FzusGHUKVpXYP97HCbHyFUufq5oKd3y40xQ,9262 +ansible/modules/system/svc.pyc,, +ansible/modules/system/sysctl.py,sha256=NlERaayKlcb_LAuXIUUzcjbVogqMo3yG3a9jZ0ic2p8,13700 +ansible/modules/system/sysctl.pyc,, +ansible/modules/system/systemd.py,sha256=y-OF37dK_nsG7DEJpEqwjez1wxbSlkGWiOCE-quIB_E,20177 +ansible/modules/system/systemd.pyc,, +ansible/modules/system/sysvinit.py,sha256=hUCxyyd-9rmy4o9a3WCKz82zAwohDY2Exk7ALCNbTBI,13409 +ansible/modules/system/sysvinit.pyc,, +ansible/modules/system/timezone.py,sha256=GiPfvgUlRvEzxEXik33nqgYe03Xu95emRPAWyqdIZXU,32161 +ansible/modules/system/timezone.pyc,, +ansible/modules/system/ufw.py,sha256=_L-Dh5OZ_y_BW52jn8pG1fKcet4K_I8rnyVzSJZ7arg,11656 +ansible/modules/system/ufw.pyc,, +ansible/modules/system/user.py,sha256=Tpb6X3GEWPElyOfNB13w1WYVDzpSxDVJXv56utAf06c,92526 +ansible/modules/system/user.pyc,, +ansible/modules/system/vdo.py,sha256=-gtdLsrTiytp7GKogtITRnWSI0bIUP5lKnBHNhX0J4Q,36732 +ansible/modules/system/vdo.pyc,, +ansible/modules/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/utilities/__init__.pyc,, +ansible/modules/utilities/helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/utilities/helper/__init__.pyc,, +ansible/modules/utilities/helper/_accelerate.py,sha256=YtqWrA_rhesrl4pnjGr11h9U__T6SLpAMLMuxUrghmc,548 +ansible/modules/utilities/helper/_accelerate.pyc,, +ansible/modules/utilities/helper/meta.py,sha256=D0Y5H0ySKVMaA4tRuA9gfASklIAj_CImRziiLA8iwos,3825 +ansible/modules/utilities/helper/meta.pyc,, +ansible/modules/utilities/logic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/utilities/logic/__init__.pyc,, +ansible/modules/utilities/logic/assert.py,sha256=olbwRPUybsAxI5NYkqrwbrHsxeNhr3QosdWAdaZCHNw,2015 +ansible/modules/utilities/logic/assert.pyc,, +ansible/modules/utilities/logic/async_status.py,sha256=j682hUGJ9HfCfvstSG3jWsVo2-ya8qxWxXOvFmvvIxY,3006 +ansible/modules/utilities/logic/async_status.pyc,, +ansible/modules/utilities/logic/async_wrapper.py,sha256=otBn_zKWlQBNZ6Vd8S3-c5RsvfhEVdY7QyeUW7_C65I,10223 +ansible/modules/utilities/logic/async_wrapper.pyc,, +ansible/modules/utilities/logic/debug.py,sha256=PLj_BKxX4_hn5XfGhd5m6YecW-Xp-gxkbPAHknCiuBA,1962 +ansible/modules/utilities/logic/debug.pyc,, +ansible/modules/utilities/logic/fail.py,sha256=PNgHzbTcCJrtE1DhE5P5r7hCXR6wkHjKSU6Nq7MV36Y,1256 +ansible/modules/utilities/logic/fail.pyc,, +ansible/modules/utilities/logic/import_playbook.py,sha256=J1Gs-ReJj3vWYeqP2AGRxrqSnYI7NjNH1Q70w-fRlu0,1345 +ansible/modules/utilities/logic/import_playbook.pyc,, +ansible/modules/utilities/logic/import_role.py,sha256=dizoGi4OUPq_wIS8_HKnWIXDXhMvl0PdZtCFfAsoTrc,2749 +ansible/modules/utilities/logic/import_role.pyc,, +ansible/modules/utilities/logic/import_tasks.py,sha256=rWQyg-eLoOiqAoyfqi1h_aNzqI4b3yookzGEGlBDD28,1471 +ansible/modules/utilities/logic/import_tasks.pyc,, +ansible/modules/utilities/logic/include.py,sha256=ofQGM7KHlratBoNDa-m8zUhbWerY5VljSQBWfkhfKfE,2647 +ansible/modules/utilities/logic/include.pyc,, +ansible/modules/utilities/logic/include_role.py,sha256=Nw2PgsU5P47E1d63MD-a_LBDkXXLskhCAsSWiJQKUgY,3620 +ansible/modules/utilities/logic/include_role.pyc,, +ansible/modules/utilities/logic/include_tasks.py,sha256=9Me3sMwwzSyW_rYhS8YVKf6r_h-leirX4AYgi042lac,2208 +ansible/modules/utilities/logic/include_tasks.pyc,, +ansible/modules/utilities/logic/include_vars.py,sha256=WCrk1ekxx6EAGxcdoUoIBi5pezdJKD5D419UWeWzLzk,4432 +ansible/modules/utilities/logic/include_vars.pyc,, +ansible/modules/utilities/logic/pause.py,sha256=0eeVoOp2FenNBeI1omuhU1sOFNR3TBiQNK_WRGWcB9Y,3168 +ansible/modules/utilities/logic/pause.pyc,, +ansible/modules/utilities/logic/set_fact.py,sha256=s3iLwgcvDumNop0VnE8_52QLEk1TDXA_liNNm8Er5wc,2898 +ansible/modules/utilities/logic/set_fact.pyc,, +ansible/modules/utilities/logic/set_stats.py,sha256=-JLZdnJno8NVWvwIc0SFE5_HZmraUUdor2aNJBbUfII,1935 +ansible/modules/utilities/logic/set_stats.pyc,, +ansible/modules/utilities/logic/wait_for.py,sha256=maimiuPrmnjvOtPB3FOJLgwvKhK1HEAwu9n7RwpWOpQ,24271 +ansible/modules/utilities/logic/wait_for.pyc,, +ansible/modules/utilities/logic/wait_for_connection.py,sha256=juQEazQiaTCFLhI0CusCpcD8MxxPjZeKJIdo9g2Jvmw,2953 +ansible/modules/utilities/logic/wait_for_connection.pyc,, +ansible/modules/web_infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/web_infrastructure/__init__.pyc,, +ansible/modules/web_infrastructure/ansible_tower/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/web_infrastructure/ansible_tower/__init__.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_credential.py,sha256=taFZ5ZoPzZCRlUUzbppc3yGJ7KPz8AxGXQdsf2NMDH8,10239 +ansible/modules/web_infrastructure/ansible_tower/tower_credential.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_credential_type.py,sha256=4Go8_TX8zWCYiZMACrhy8VkhLtG_pgK3LBBoZx7QEoc,4819 +ansible/modules/web_infrastructure/ansible_tower/tower_credential_type.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_group.py,sha256=a4IhO9a1DOruCLAE_wrwFgP5D3_8X-DyqObevrzbN4Q,5624 +ansible/modules/web_infrastructure/ansible_tower/tower_group.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_host.py,sha256=91Jm0ZN6JOzq0Hr7d1eHS1fEOKfCemY1f4JKozv1QyA,3855 +ansible/modules/web_infrastructure/ansible_tower/tower_host.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_inventory.py,sha256=YZK3yNIpE5IbeZCRIDvWG_9Hl-u2dcjWCu51LIRegxk,4053 +ansible/modules/web_infrastructure/ansible_tower/tower_inventory.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_inventory_source.py,sha256=o4bSM8wZXUurP2Bboyg365ehW5Y-6uwhnqQHWifADxo,11637 +ansible/modules/web_infrastructure/ansible_tower/tower_inventory_source.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_job_cancel.py,sha256=caiFdwS1V4U2LLJ15UKCkmLgnLrZGitR5wOwmuXsB2Q,2499 +ansible/modules/web_infrastructure/ansible_tower/tower_job_cancel.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_job_launch.py,sha256=5ZF4NKXOW0iJmkxKE_JJAHgFNhekusSOvM6Say4YSE0,4034 +ansible/modules/web_infrastructure/ansible_tower/tower_job_launch.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_job_list.py,sha256=-Iwvew21okf5y3pNPEkCiUsToucxyfHHdH2WNr1oTk0,3736 +ansible/modules/web_infrastructure/ansible_tower/tower_job_list.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_job_template.py,sha256=-j7owIUfmR34Rh_LCEunV2ZlKACJm3DXx7ISV7nXfQY,10172 +ansible/modules/web_infrastructure/ansible_tower/tower_job_template.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_job_wait.py,sha256=yswiox2LgEorejZD_7X2-lABAY1DuSDV00ZCM9nT1co,4078 +ansible/modules/web_infrastructure/ansible_tower/tower_job_wait.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_label.py,sha256=nDS2-yA-gxaVHxDCOAVGkoiK6yfylQDak_3PIi2Hdak,3033 +ansible/modules/web_infrastructure/ansible_tower/tower_label.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_organization.py,sha256=2qZuzuNSYWwuwzGKgG-Iuu66y5WClq6E8WZHYgHsqR0,2759 +ansible/modules/web_infrastructure/ansible_tower/tower_organization.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_project.py,sha256=tWHQd4vxE41uPu0DWvBJemHPlcL7b-1aXShYX46oYyg,5886 +ansible/modules/web_infrastructure/ansible_tower/tower_project.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_role.py,sha256=u95sc-MJ-wddpNHHt-rXU9ajAwFLM41l9XJcrf45bso,4458 +ansible/modules/web_infrastructure/ansible_tower/tower_role.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_settings.py,sha256=2KXHRxIdEUi0tlDTTLFCYi0Yiq3o8UReJM16kF3vlPM,2598 +ansible/modules/web_infrastructure/ansible_tower/tower_settings.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_team.py,sha256=F23D1rac0gnDvVbHkR3by-FHADhTs83r9yNU10lU_Oc,3178 +ansible/modules/web_infrastructure/ansible_tower/tower_team.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_user.py,sha256=v0bfYwlRn1mGapg5ilSC5PoSGdOvVQ-YqTYn_QhYh3E,3766 +ansible/modules/web_infrastructure/ansible_tower/tower_user.pyc,, +ansible/modules/web_infrastructure/ansible_tower/tower_workflow_template.py,sha256=V2m5gYyAwFTw6SjvtwUdiw_k7Ughre8asDztYO268cM,5679 +ansible/modules/web_infrastructure/ansible_tower/tower_workflow_template.pyc,, +ansible/modules/web_infrastructure/apache2_mod_proxy.py,sha256=CGsZpFFmcsST0IKZH2hN5RINUws56tSKfeT-mTNTiwM,16769 +ansible/modules/web_infrastructure/apache2_mod_proxy.pyc,, +ansible/modules/web_infrastructure/apache2_module.py,sha256=u4DdQgVnbXeCxKNtCkIcH6ozXr94EmiExwXJaNLLgtI,8137 +ansible/modules/web_infrastructure/apache2_module.pyc,, +ansible/modules/web_infrastructure/deploy_helper.py,sha256=pXnfNZROT7fCV5uUpWpUkr0CQ2eDbuvIQziIMyqj0rg,19571 +ansible/modules/web_infrastructure/deploy_helper.pyc,, +ansible/modules/web_infrastructure/django_manage.py,sha256=X3FNXWmKYuEtsGSqIymFCbnJj2rNx91qWRfgYEoHcZA,11389 +ansible/modules/web_infrastructure/django_manage.pyc,, +ansible/modules/web_infrastructure/ejabberd_user.py,sha256=fGLLQHaOeIH8pkReEfMKc_miGft3uTqgHdHqCKOlLrI,6918 +ansible/modules/web_infrastructure/ejabberd_user.pyc,, +ansible/modules/web_infrastructure/gunicorn.py,sha256=nNlE9PL7cUGwNxgEHzEMrVqhTqMw_4vLjdZiea_UNpI,6924 +ansible/modules/web_infrastructure/gunicorn.pyc,, +ansible/modules/web_infrastructure/htpasswd.py,sha256=PtWCcdQPVUa6sAXBQ_PBwVwDgZrzgAIBppk6z6LjBMw,8684 +ansible/modules/web_infrastructure/htpasswd.pyc,, +ansible/modules/web_infrastructure/jboss.py,sha256=XGNRoWaX4phdfZT-t6lVZsckh39GCXE58OzN7jis8AA,4642 +ansible/modules/web_infrastructure/jboss.pyc,, +ansible/modules/web_infrastructure/jenkins_job.py,sha256=cgKPNVabuGzSdNkSgyOUemSP2ojAEeULvEbNo_PHeQ8,11190 +ansible/modules/web_infrastructure/jenkins_job.pyc,, +ansible/modules/web_infrastructure/jenkins_job_facts.py,sha256=sSXG0PLQbSfxt4Cuawp8jMVU62eQ5BA9X5rVnHVMbng,7061 +ansible/modules/web_infrastructure/jenkins_job_facts.pyc,, +ansible/modules/web_infrastructure/jenkins_plugin.py,sha256=7wGga-JF6lBpqcI2MiAanC_ynR4bD74XUMkVspbDuyQ,24734 +ansible/modules/web_infrastructure/jenkins_plugin.pyc,, +ansible/modules/web_infrastructure/jenkins_script.py,sha256=EgiKXA80GM9vvMv7Z5pPn5UC7thbAQTCbokwhbetqyc,6194 +ansible/modules/web_infrastructure/jenkins_script.pyc,, +ansible/modules/web_infrastructure/jira.py,sha256=1CTl7QJDeC35S_NkLsHcofza1jN-A0RKju-FXF5ZTXg,11743 +ansible/modules/web_infrastructure/jira.pyc,, +ansible/modules/web_infrastructure/nginx_status_facts.py,sha256=Eyj276zdIutwQJdUx_1ztsmJnXx3yjgMLwdOiMaR-3w,4927 +ansible/modules/web_infrastructure/nginx_status_facts.pyc,, +ansible/modules/web_infrastructure/rundeck_acl_policy.py,sha256=udeNOXBCPyR8CGCkU-ewQ3eNnjmCJmpsfjUu4eQh4j0,8355 +ansible/modules/web_infrastructure/rundeck_acl_policy.pyc,, +ansible/modules/web_infrastructure/rundeck_project.py,sha256=xFhEftwL8mJ1dP7TaRwxRv6nK84XNCMFaXgeR2HN4TE,6314 +ansible/modules/web_infrastructure/rundeck_project.pyc,, +ansible/modules/web_infrastructure/supervisorctl.py,sha256=FH3kt__LXVpS-s44pKpKZDLryFGqHaqBZFgl4M1HbIk,8582 +ansible/modules/web_infrastructure/supervisorctl.pyc,, +ansible/modules/web_infrastructure/taiga_issue.py,sha256=AHIivddP5lQciFreQc9DLYmEAyTqScX-u9q4kHJ7SRs,10818 +ansible/modules/web_infrastructure/taiga_issue.pyc,, +ansible/modules/windows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/modules/windows/__init__.pyc,, +ansible/modules/windows/_win_msi.ps1,sha256=lE33tAaAOQqYFS507a4AozjeS6jwP1ZF9WJ9mP8kQIc,1787 +ansible/modules/windows/_win_msi.py,sha256=29X1pIOgprpwklvkGDEHpvtVfi_kxMj0NBlipFDBa1w,2567 +ansible/modules/windows/_win_msi.pyc,, +ansible/modules/windows/async_status.ps1,sha256=6QtLmDz1SsBRdWFKKayW7pVBT2Ew2TylSmwpzewaoF8,1740 +ansible/modules/windows/setup.ps1,sha256=-QA87m21fTrqlc3AK4AEwcnQbBHqoF6BEVpSSZMRDJY,16464 +ansible/modules/windows/slurp.ps1,sha256=VrPHq7H6qvCvXZt5ioJtoUk4dD9ca-aFN1cHURL_Kic,737 +ansible/modules/windows/win_acl.ps1,sha256=IaCrd6-hiLZLgUBtZZccXL9uh14u452Aw7veDwILrAw,9316 +ansible/modules/windows/win_acl.py,sha256=Z3KgQT0S0wrZ2Zrqh9BWq1gyzUp1P7CAMYm5jEffdUg,3910 +ansible/modules/windows/win_acl.pyc,, +ansible/modules/windows/win_acl_inheritance.ps1,sha256=fGBgKajiZe_f_f_annzjeMj_ibhGBZrBIq0ClM5OQas,2871 +ansible/modules/windows/win_acl_inheritance.py,sha256=LicynHUY0ALppJAa-ClOvr3Y1AvfqrVqOsXTRoiwD8U,1879 +ansible/modules/windows/win_acl_inheritance.pyc,, +ansible/modules/windows/win_audit_policy_system.ps1,sha256=O_LlrrhexGQy2qjFUuHEW7oHhQXiFs5CPTAfCy2Hzdw,5246 +ansible/modules/windows/win_audit_policy_system.py,sha256=VwALFV4vn9e1F-XOlrUpeue4VLiK_-9QIDK7I2cfhbY,2187 +ansible/modules/windows/win_audit_policy_system.pyc,, +ansible/modules/windows/win_audit_rule.ps1,sha256=cCi-_JUSIAJwhX1RpnifhW5DVPWQtekbH-DNq7Ha3eo,6850 +ansible/modules/windows/win_audit_rule.py,sha256=vJsidcn2nByrLYPE4wRCRvUKiyIQlH1PkJmbcgtOnKs,4783 +ansible/modules/windows/win_audit_rule.pyc,, +ansible/modules/windows/win_certificate_store.ps1,sha256=CWQKcAVdzDlKQqx1aEJ5BspH5Q1av-yOP_TcPqnc4vw,11868 +ansible/modules/windows/win_certificate_store.py,sha256=tDrIW3SnTChz7n9_VFn6__MYeIqKmwmoEP52nnjg_5g,7508 +ansible/modules/windows/win_certificate_store.pyc,, +ansible/modules/windows/win_chocolatey.ps1,sha256=8ZCHcYGYXDB_ZAOne7KczL71mE9gJL9siE2xk-ezo1A,24357 +ansible/modules/windows/win_chocolatey.py,sha256=42faI4Pm7Mo-PQu34VPObB0gaAdnuRZ2Q_-MtHzfSQg,10625 +ansible/modules/windows/win_chocolatey.pyc,, +ansible/modules/windows/win_chocolatey_config.ps1,sha256=fMcFlgGn3sbQ_UP_d0RgSAbZiebhTVPNIQGAnI5Tmnw,4392 +ansible/modules/windows/win_chocolatey_config.py,sha256=59J3Sh_2gRMeN2LwKg-ccsRA3H_QwtmppsEeJNurS-s,1677 +ansible/modules/windows/win_chocolatey_config.pyc,, +ansible/modules/windows/win_chocolatey_feature.ps1,sha256=1ekyE1l5NkaA-WyJH3CUoNcpxFzMKLjQqq5lAWGxqYQ,2428 +ansible/modules/windows/win_chocolatey_feature.py,sha256=V__ZSuhxkcGtpP76Du0-stpS6JjrOkm648y6S-44KXE,1215 +ansible/modules/windows/win_chocolatey_feature.pyc,, +ansible/modules/windows/win_chocolatey_source.ps1,sha256=TAA-j4nPPTXUi2pEH_mskTMofKy1Gyb5sdxbIzhy0Ho,11197 +ansible/modules/windows/win_chocolatey_source.py,sha256=Jd4yyWxyj2VFx5St5zWQiffHmURkISZZAHcvDCIMjJc,3556 +ansible/modules/windows/win_chocolatey_source.pyc,, +ansible/modules/windows/win_command.ps1,sha256=I3qYO-v2Az2TfhOmdSGcPSrex8yDjZ_10EvAlBP5bPc,2207 +ansible/modules/windows/win_command.py,sha256=DRWsl515m562S74tevG8D7DNdoJ1uz2KLlcXZBf8Yjc,3934 +ansible/modules/windows/win_command.pyc,, +ansible/modules/windows/win_copy.ps1,sha256=wntBURW0vJ6C8qWIIX5RZLrZyMS6Ltt9G7SdZjkRHzA,16810 +ansible/modules/windows/win_copy.py,sha256=cRdxw4bzWfSEI0P1Ic5Np5q_Q_SEdzYXWskjMY47dnQ,5478 +ansible/modules/windows/win_copy.pyc,, +ansible/modules/windows/win_defrag.ps1,sha256=u20sqC3PevDmj__vx7qBeHVHC7r51u0HaCRqqpI_O2w,2559 +ansible/modules/windows/win_defrag.py,sha256=bV2vL-f-YVT3_6MDcWGWJUDB113SKo0EGtzMQWq4uks,2682 +ansible/modules/windows/win_defrag.pyc,, +ansible/modules/windows/win_disk_facts.ps1,sha256=n0PTweOlDKqZq5oDI7sWKOUpWDF8VpxiCizqMVB1A3s,7962 +ansible/modules/windows/win_disk_facts.py,sha256=rsN1MGi2c_9OjS9j89LLCsf8q2vi4RlsIsh6c6ulqjA,29705 +ansible/modules/windows/win_disk_facts.pyc,, +ansible/modules/windows/win_disk_image.ps1,sha256=GPGGvmi5jS0U1_tMu1lTJgUmEY-kbmWwaI2dTLc58h4,2663 +ansible/modules/windows/win_disk_image.py,sha256=ywSldJ3ADckE6gS-04SELUaGmeJb5rEiTfMFH6A_m4c,2007 +ansible/modules/windows/win_disk_image.pyc,, +ansible/modules/windows/win_dns_client.ps1,sha256=yrAT6f8RlE8tHyegfSsBnTbUkxoNlJOTDLHVRZ89D5g,6961 +ansible/modules/windows/win_dns_client.py,sha256=REzpxvuZNIWhiBCsvdAMqaWEBIpwyCXUl_hFgyVxmpQ,2086 +ansible/modules/windows/win_dns_client.pyc,, +ansible/modules/windows/win_domain.ps1,sha256=WQ8l_HuCuHMal4U1pdSjOX9eHxHNhDVhtq08IwqxQ8w,4249 +ansible/modules/windows/win_domain.py,sha256=Hvdgj7OmcdUbYwmMe3oZAIzhCBhomszoycLxuaM_fT0,2200 +ansible/modules/windows/win_domain.pyc,, +ansible/modules/windows/win_domain_computer.ps1,sha256=blG7khYASFa0l-O6LRFcJ_zcUBDVZN-zxSUFfZM5oXg,6163 +ansible/modules/windows/win_domain_computer.py,sha256=0fcKLt3fA5Ai6JdF3jk5WU5WX-9PSiqr1GcqBMxGbVc,3356 +ansible/modules/windows/win_domain_computer.pyc,, +ansible/modules/windows/win_domain_controller.ps1,sha256=4gNjsFfBXMJvsZRp_DxJIsLe3iLTZt6fFcc_2HsnCos,10709 +ansible/modules/windows/win_domain_controller.py,sha256=QU1SlH4GkD2Er0kK_Jiah5uU7wzwkuqkzBIVQ-xYvZY,4039 +ansible/modules/windows/win_domain_controller.pyc,, +ansible/modules/windows/win_domain_group.ps1,sha256=UICAls3sw-l4tjY13YdfX8ZEw0sIqfhDX4vSv58mm0A,14834 +ansible/modules/windows/win_domain_group.py,sha256=7F2ygZnbnz3nNbohOwJNi8Nq50Dh2Kxuk0JbJwas0vo,6967 +ansible/modules/windows/win_domain_group.pyc,, +ansible/modules/windows/win_domain_membership.ps1,sha256=GD8Bsuo259q-9f8UTuqo_sb9pNFmpoNp3_IOScm_Hlk,9489 +ansible/modules/windows/win_domain_membership.py,sha256=8KXs-iU4l4hoxAaPeG9746ZSRqJDxWCcBPsWq8WpdQk,3115 +ansible/modules/windows/win_domain_membership.pyc,, +ansible/modules/windows/win_domain_user.ps1,sha256=BkEI46IAHryk-cWBrJd6DkXcrDP-SzCKxXqjr1dmuzc,14089 +ansible/modules/windows/win_domain_user.py,sha256=at8ugyXbtWu6K_d7qoFNeX1CxryIQPjGaWK0SvNLjlk,10508 +ansible/modules/windows/win_domain_user.pyc,, +ansible/modules/windows/win_dotnet_ngen.ps1,sha256=nrfkzFEWQ1zc9ZN5XhbRQ7y0RKPs6HVAcppDQakurMg,2091 +ansible/modules/windows/win_dotnet_ngen.py,sha256=StKIIpuCcnY9LNooH2ZX8Zc13p2sTlHDp4LlZZJvqXw,2940 +ansible/modules/windows/win_dotnet_ngen.pyc,, +ansible/modules/windows/win_dsc.ps1,sha256=0awDRRHCYJWcs4uWiAyGL-J3i-w1JXAwDNIXAHOfcKA,8569 +ansible/modules/windows/win_dsc.py,sha256=zpdlXTsUOj7dQBr8qVtkr2W9fSVzjTAoHQ4an1idBi8,5245 +ansible/modules/windows/win_dsc.pyc,, +ansible/modules/windows/win_environment.ps1,sha256=lu7XDHvza6ThfPYBsZQDqDp6E8Q4h0cUd86mIQN5UsQ,2383 +ansible/modules/windows/win_environment.py,sha256=hlevyAYG0_q4AU7CiWZkROL2znr4fy7HCInUCDU49Vo,2820 +ansible/modules/windows/win_environment.pyc,, +ansible/modules/windows/win_eventlog.ps1,sha256=Ml_l3IQV2t-S3YsPZISBmTxPCQ40Q_pyCH0kIiZ9z7Y,11062 +ansible/modules/windows/win_eventlog.py,sha256=BkYkPFkScXnZ3e4rY8knTCfqhkQOIpagLM2s7MueSLA,4997 +ansible/modules/windows/win_eventlog.pyc,, +ansible/modules/windows/win_eventlog_entry.ps1,sha256=WE7YTBDfRvWvkVSLDyOJ6XQWS_78vH3RUDbojlKdMX8,3027 +ansible/modules/windows/win_eventlog_entry.py,sha256=t1v0NuS-kWn1RKc8EyEjMsgTxHHRmYXA4V_H_Y9KixY,2142 +ansible/modules/windows/win_eventlog_entry.pyc,, +ansible/modules/windows/win_feature.ps1,sha256=XVxxgiGRWEeCmGzp4k535blknuQ28atKApVxGxtDT1A,4308 +ansible/modules/windows/win_feature.py,sha256=ztqEeLNXqY1HDMBgFxeaaUwgsLytM-KIvTNtOYxVKWU,4926 +ansible/modules/windows/win_feature.pyc,, +ansible/modules/windows/win_file.ps1,sha256=V3tGElSCo8id3qYp2wSb9E2L0l1LbjIG4qe2ktuYx5U,5476 +ansible/modules/windows/win_file.py,sha256=RSP3d0EfB0Opb9j-3diimph-HCae-pnnIsj8zlPvjKs,2209 +ansible/modules/windows/win_file.pyc,, +ansible/modules/windows/win_file_version.ps1,sha256=dVZTkCfFO0DWf9ylXdrYwf7yDAdzlhOqSeJqqvSVk3I,2136 +ansible/modules/windows/win_file_version.py,sha256=XnjlL-4fbJbZV4cswqc0d6r0sDL6424CIiIpFyh3rCQ,1753 +ansible/modules/windows/win_file_version.pyc,, +ansible/modules/windows/win_find.ps1,sha256=clj9b0T4QxLEeMGhNWRKiXw4NcF-kyV6ocxlUEV9zbA,13227 +ansible/modules/windows/win_find.py,sha256=y5wCP9makjt6-657Bn7hnZwxA1Lzo860IQe7RscTJDI,9562 +ansible/modules/windows/win_find.pyc,, +ansible/modules/windows/win_firewall.ps1,sha256=xdXb9IBrpLZcG5DKQSlGX9dxY7taou2x4NPLLc5e44Y,2004 +ansible/modules/windows/win_firewall.py,sha256=nduzuo3DzqcmyN3HO2v6badOenM8jp1G-VXKSR5BC-I,1758 +ansible/modules/windows/win_firewall.pyc,, +ansible/modules/windows/win_firewall_rule.ps1,sha256=EW_MuCRmvLan_kurdKDg612paGx0fJuj6oBHgGfod84,11673 +ansible/modules/windows/win_firewall_rule.py,sha256=_pJ-T9zyuW-d9_j9QdroHFEZegkgajfUrzaKqw2p2XE,2791 +ansible/modules/windows/win_firewall_rule.pyc,, +ansible/modules/windows/win_get_url.ps1,sha256=rXGH999PoO36NG65AmNtmdaBY2U6aA1L8SsxTkVAUKo,9750 +ansible/modules/windows/win_get_url.py,sha256=71v8IsoRNTP4en2IIx8g2wdTSNwxhbeuZrM1V5S_38k,4766 +ansible/modules/windows/win_get_url.pyc,, +ansible/modules/windows/win_group.ps1,sha256=7nOCYYYfCT4o2NCHOp4ZxkODbhbW7K89MKSuP39fpxo,1645 +ansible/modules/windows/win_group.py,sha256=H0RTq_sVf3Ac9OKEHfo3cabGVI0oIOZcWWSEn5sctUY,1257 +ansible/modules/windows/win_group.pyc,, +ansible/modules/windows/win_group_membership.ps1,sha256=ARjgjVMT4i4kFj5UZS2TIjebP_tUtiYzBiktMBCHLXA,4927 +ansible/modules/windows/win_group_membership.py,sha256=JLrBUbL1Cu8r2sYhEEjynEwnGYid5vwwjQN10oAsmiY,2633 +ansible/modules/windows/win_group_membership.pyc,, +ansible/modules/windows/win_hostname.ps1,sha256=z4njH0NyQSaqTgokQ7ZqY2Nk8qKMMBwrCt5D20GsvHE,948 +ansible/modules/windows/win_hostname.py,sha256=02YyGIgwUgEmWZ5x70xPQp32pGUAG6stnmYAcLkz2RI,1270 +ansible/modules/windows/win_hostname.pyc,, +ansible/modules/windows/win_hotfix.ps1,sha256=DVGWq76JspVjkNt2vxfSO8NtRFqCOh_7n9_HDD1gYKw,9169 +ansible/modules/windows/win_hotfix.py,sha256=Oq6nzXOD78OwOQWsZd8kDixpXlXEfku6AnrRBeHwqYI,4410 +ansible/modules/windows/win_hotfix.pyc,, +ansible/modules/windows/win_iis_virtualdirectory.ps1,sha256=F37ffLhnI4mPyK3i1gTBqrvUKtZk7lLYG97kRN9hH1o,2833 +ansible/modules/windows/win_iis_virtualdirectory.py,sha256=ua6wTBii7kB8sP937jtYYpdXgJ9xqAwzXbYFpxIyNwk,1836 +ansible/modules/windows/win_iis_virtualdirectory.pyc,, +ansible/modules/windows/win_iis_webapplication.ps1,sha256=n8Yjn-2qipntqbOEqOKfbMpwQHIFJaWwvbNfbf1b9LI,3241 +ansible/modules/windows/win_iis_webapplication.py,sha256=HUrAJ62nRSR4Hjt56Czbo1kpppK2teQlCuAGZ8zGwxg,1605 +ansible/modules/windows/win_iis_webapplication.pyc,, +ansible/modules/windows/win_iis_webapppool.ps1,sha256=U5HXiSxUVWSeZu5lDZJs-l6Xe7dBbXvV8O_hoOnLDvA,11604 +ansible/modules/windows/win_iis_webapppool.py,sha256=fXuJnYDPUXJBniN6HtGK-TAr6RwgS_5VUY3QEp2cNpU,7037 +ansible/modules/windows/win_iis_webapppool.pyc,, +ansible/modules/windows/win_iis_webbinding.ps1,sha256=FgYee7R9NoItM-vLz-fOftMGV5StbQMp4vBD6KF9U4o,13622 +ansible/modules/windows/win_iis_webbinding.py,sha256=txUEVqPvNDT5IMyPRlq_ctJc0FFJHMxUM76WD74cLc0,3847 +ansible/modules/windows/win_iis_webbinding.pyc,, +ansible/modules/windows/win_iis_website.ps1,sha256=0OxB1t6gohkOvJG3Y_cEeUZ3aUdOYfACf2rnKL-J4rI,5262 +ansible/modules/windows/win_iis_website.py,sha256=1ByR_ZlR5cQAF3WkPqpDdtGba6vnxVNXLIYf4ADMkEs,2966 +ansible/modules/windows/win_iis_website.pyc,, +ansible/modules/windows/win_lineinfile.ps1,sha256=41AL8SOutkk8CrPTXX51AO-Wlz9kbGHfGcr6Dsf0w3E,12084 +ansible/modules/windows/win_lineinfile.py,sha256=znDVS3qBZ03dm_KeI1R3xue6vhshc78bM5_dL4V65uQ,6655 +ansible/modules/windows/win_lineinfile.pyc,, +ansible/modules/windows/win_mapped_drive.ps1,sha256=jyWQM43acp_U4bIHvUtBnbdP2FtT1qDQCrqB8FxQWN4,4237 +ansible/modules/windows/win_mapped_drive.py,sha256=7mZZPCyLSMbI8Ev9uXez1rGFNvxEb_-gSEDF1_pqrcI,2814 +ansible/modules/windows/win_mapped_drive.pyc,, +ansible/modules/windows/win_msg.ps1,sha256=FyCMMpR_Ks4hZcXGvV4XBL6wUSrnfrHdeTEMdPTwjIo,1511 +ansible/modules/windows/win_msg.py,sha256=GtdtAUvcX8GeJvHmkS78KHJjNSP-b7w4nI-zaZgn0m4,3048 +ansible/modules/windows/win_msg.pyc,, +ansible/modules/windows/win_nssm.ps1,sha256=3pmRhnLjyqTR1ODuu1hXbhtNHk60KBf4vpJtD7P8Ces,18831 +ansible/modules/windows/win_nssm.py,sha256=pOqzqLZiMZPi_fZgWgNKEG6mGhiQzXx223qZ0sCsEMI,5137 +ansible/modules/windows/win_nssm.pyc,, +ansible/modules/windows/win_owner.ps1,sha256=mvRm8FKWpvrYHQjsWBXhKUO4RYYyu4J4fLdUBUjXcxk,2235 +ansible/modules/windows/win_owner.py,sha256=Hnc6htZosvRzkBTARhyMhlfUADN33bwFTi2hpK5xrqs,1088 +ansible/modules/windows/win_owner.pyc,, +ansible/modules/windows/win_package.ps1,sha256=FhjMA99zQ2ZmfZ4EceF9-cjARJaky5t5zZAma_5u9Pk,21052 +ansible/modules/windows/win_package.py,sha256=XhehokswLiTYXfOi7B4BJPyaiAgENIJsAxHYun_M-zo,9677 +ansible/modules/windows/win_package.pyc,, +ansible/modules/windows/win_pagefile.ps1,sha256=6FCdMTqEv4cgvNPVHeMAyUpLgvWKjnALWG2w-eegsuE,6428 +ansible/modules/windows/win_pagefile.py,sha256=KUlewE2DsBwx0kSaPBKgAfG2IwI-bafQD8W0s714F4Q,3980 +ansible/modules/windows/win_pagefile.pyc,, +ansible/modules/windows/win_path.ps1,sha256=ouR8UbJSiMXE_re89Dqez37JOjPQ6TkUl5hrnZoNtbE,4589 +ansible/modules/windows/win_path.py,sha256=X2rN5TnEYYxCyIa4E1NqfbXYV2y8hWb5Jv-1QkjPSow,3082 +ansible/modules/windows/win_path.pyc,, +ansible/modules/windows/win_pester.ps1,sha256=2MExAOA7XWxWTVfWSqkiKdkLCmZSPB9vMvFTeexn9IU,3399 +ansible/modules/windows/win_pester.py,sha256=Tz37gcYDUbZQsJKxL0ouMPMLLrb0F1nDDEJepBmeWCk,1850 +ansible/modules/windows/win_pester.pyc,, +ansible/modules/windows/win_ping.ps1,sha256=iTs5Gd75pQtluECL6PRqlQMqDAriyk3P6d2LdOtts0o,439 +ansible/modules/windows/win_ping.py,sha256=KN6sA0HA-8_fQ7O_dKA10iu06ovNApLQF0NgbvhNFgY,1531 +ansible/modules/windows/win_ping.pyc,, +ansible/modules/windows/win_power_plan.ps1,sha256=ZSFkITcZ0x7NFz8IxoRqRgbYRvVEPengiOmi1OFzZcQ,7162 +ansible/modules/windows/win_power_plan.py,sha256=BxOkKpQlUGNkc9IatSYaryO2B4v_Ar9f8Ailt29hb_g,1636 +ansible/modules/windows/win_power_plan.pyc,, +ansible/modules/windows/win_product_facts.ps1,sha256=OrmdCR9Nj0QYQfPJwDTXxIqQ-A29455I5eUsnqU0kik,1989 +ansible/modules/windows/win_product_facts.py,sha256=040pB-NlSTC-QBLWpis1HUHrn31e80geqM67wA_4R1U,912 +ansible/modules/windows/win_product_facts.pyc,, +ansible/modules/windows/win_psexec.ps1,sha256=3m6bjdUDl9aPPlsDkMgzkzw4-yX8QBupwHMWBJatQPQ,4184 +ansible/modules/windows/win_psexec.py,sha256=zyUJAWDPqJ78EipcpuqxJdETQ7ZAQoUh6MrwimIp_q4,4797 +ansible/modules/windows/win_psexec.pyc,, +ansible/modules/windows/win_psmodule.ps1,sha256=Hj3hpBMDYEG7tKtO9mD35mU1qrPI27_TpuJt58J8TnU,5725 +ansible/modules/windows/win_psmodule.py,sha256=plLEHXlqnLMy_9Up9ZkT1e0vPUJGxfioVUd3crinh9A,2540 +ansible/modules/windows/win_psmodule.pyc,, +ansible/modules/windows/win_rabbitmq_plugin.ps1,sha256=Ct6fLHZQojffnbjAiP-AA-Xmz14bIJa23EFKKhqgFXE,5041 +ansible/modules/windows/win_rabbitmq_plugin.py,sha256=tQO9T724G_HRgd5bTlZ-1P3OrUygV6p3G3pN6JlyZCw,1441 +ansible/modules/windows/win_rabbitmq_plugin.pyc,, +ansible/modules/windows/win_reboot.py,sha256=jKTPSfZ31PaORFs5NVm4n4Hdp5MQijZjna8RgDQH15U,3216 +ansible/modules/windows/win_reboot.pyc,, +ansible/modules/windows/win_reg_stat.ps1,sha256=Poi5DdwXviYx9EujHo10DPqQrAakDp2vDb9i0oEjKwY,4374 +ansible/modules/windows/win_reg_stat.py,sha256=PU_kZfqIBMvtVsjUQLA8XRqobkzZOLKVQ7UOSd-mhoQ,3157 +ansible/modules/windows/win_reg_stat.pyc,, +ansible/modules/windows/win_regedit.ps1,sha256=wiAADj84G1HXaHycYTyVeNjzCUXqVuF0mWYvc2GhKqo,18867 +ansible/modules/windows/win_regedit.py,sha256=LwgPvRub5m-6xTkHLVsvUe1CC7kCSwYWbOWomtqevdQ,6575 +ansible/modules/windows/win_regedit.pyc,, +ansible/modules/windows/win_region.ps1,sha256=8EYMFedvMRc8HDae69URvw0S-A4JRLA2v_0-UEU9yWo,13374 +ansible/modules/windows/win_region.py,sha256=XRXICEn3ONuSlAknBC8UrWtCOhJZSHEBOfbyLrExqI0,3103 +ansible/modules/windows/win_region.pyc,, +ansible/modules/windows/win_regmerge.ps1,sha256=UfYw4bCnYnMnk6UBy9Hi36hAxt1qe_BOQEir45hXT10,2589 +ansible/modules/windows/win_regmerge.py,sha256=1VV6R3O1tR4XKBhChXcZqkSoPQJwLdo6VrCip8ij9J0,3208 +ansible/modules/windows/win_regmerge.pyc,, +ansible/modules/windows/win_robocopy.ps1,sha256=gzxyk6fMKq-pWKo-efgVyxqeW0jD5Hbjqamr0XOfKU0,4184 +ansible/modules/windows/win_robocopy.py,sha256=arFatdlMqTkPnjmqhat8SPW3-RtlYQRMkKcmNdHFW-c,4107 +ansible/modules/windows/win_robocopy.pyc,, +ansible/modules/windows/win_route.ps1,sha256=UuXQu1S_rw24cVonFRl7UOz3Xcq7mS5XCgqls6aPSa4,2816 +ansible/modules/windows/win_route.py,sha256=TBQNv3xfm7o3Uu81smn7guMXOkiL6XnuztgtKp9ECc0,1660 +ansible/modules/windows/win_route.pyc,, +ansible/modules/windows/win_say.ps1,sha256=zuUkKSFbCCtq6HTTpQ67SReCTx0aZUulZ19hm91scKA,3201 +ansible/modules/windows/win_say.py,sha256=QN_QUszQ6Y6ismAu6R5OF6caAej3PALXIMBw6xZ8AAM,4090 +ansible/modules/windows/win_say.pyc,, +ansible/modules/windows/win_scheduled_task.ps1,sha256=_Cp5bxxFzjGMeSqJsDrVCM-u_2RETem2RI97wrybt38,51746 +ansible/modules/windows/win_scheduled_task.py,sha256=gr2cnoXX1sw0w0c58Puk1VUTkCREU9IsKR6P3DSakZ4,17525 +ansible/modules/windows/win_scheduled_task.pyc,, +ansible/modules/windows/win_scheduled_task_stat.ps1,sha256=Vdf3o3P9rgJRZfDpKC2Ts4-uxydN8n3cZ0jS85UUIdI,10888 +ansible/modules/windows/win_scheduled_task_stat.py,sha256=ikw60VckdheXOlL3C4KNxJp5hdu0hjPrmGMIvk_gaT4,10386 +ansible/modules/windows/win_scheduled_task_stat.pyc,, +ansible/modules/windows/win_security_policy.ps1,sha256=ngQH8BakrkexWmqXy-6Nc08ybkmWB9jJs-waMfec7zk,6180 +ansible/modules/windows/win_security_policy.py,sha256=ZCYFwWshmLK1p6ZSoHIEDKVzg0HR-ZrxdaJ0U_rSGUc,3784 +ansible/modules/windows/win_security_policy.pyc,, +ansible/modules/windows/win_service.ps1,sha256=WlcrRUfx8YNJtlT98YiQMMSU3l4_KQ26fyqALjsBKs8,19070 +ansible/modules/windows/win_service.py,sha256=QIUp-waNBW9QoLpJsE3IudX220r6l-Ncc-LEdD-LWjw,8121 +ansible/modules/windows/win_service.pyc,, +ansible/modules/windows/win_share.ps1,sha256=e8kQF0T4jUGY711BwPAGlNqd25zCKEuPFrveMCt-h2s,11172 +ansible/modules/windows/win_share.py,sha256=4q5nQ0-HdY_vTMzhx55u8eCiDbCpeetlcNoxGAea90I,3074 +ansible/modules/windows/win_share.pyc,, +ansible/modules/windows/win_shell.ps1,sha256=niaiMqixhRUro-mo9yDwCOw--l0lM9e_NHBMKSPYx_c,4486 +ansible/modules/windows/win_shell.py,sha256=usXUMD2Fp_onBAfUcwjgixmVLvdb_3otNLA5NIUrJlU,4846 +ansible/modules/windows/win_shell.pyc,, +ansible/modules/windows/win_shortcut.ps1,sha256=Y7ilQJWH680viBkXnTMSJuQh3M_5NOvcwuiHQ44RfDM,5218 +ansible/modules/windows/win_shortcut.py,sha256=w8j6149rh4iF1H_jV6_Mz0OMkne7DfDd33qa1pv6a4M,3609 +ansible/modules/windows/win_shortcut.pyc,, +ansible/modules/windows/win_stat.ps1,sha256=wkkH0GIwbqtJGfazTWNcrhZvSPC6rxlH2iFOOg0rc5Y,5916 +ansible/modules/windows/win_stat.py,sha256=UWWqI5jYngVKQcKuEjADBbD7h1PaQm6mc4HDlR05Cq4,8215 +ansible/modules/windows/win_stat.pyc,, +ansible/modules/windows/win_tempfile.ps1,sha256=XYifHHLCQPvTQCqikWFEfkY58FEah76QWXmtLIzAqcs,2336 +ansible/modules/windows/win_tempfile.py,sha256=FGNDNG0dF4fGGDAPqgLJp4a1rR1udh2QcF-6_s_WESo,1648 +ansible/modules/windows/win_tempfile.pyc,, +ansible/modules/windows/win_template.py,sha256=7Tn3dUa-xbFsZpLqArBCNY8otp8nTZGV8cD4xyXOszs,4306 +ansible/modules/windows/win_template.pyc,, +ansible/modules/windows/win_timezone.ps1,sha256=FOu0HSJa2Zsb0FCfcemercpN9jnzJ9J6rfAGusVz8j4,2419 +ansible/modules/windows/win_timezone.py,sha256=NRR-4b3aMJg0m1hhifpNdy49vSbg3-G5_bibbmbEuno,1808 +ansible/modules/windows/win_timezone.pyc,, +ansible/modules/windows/win_toast.ps1,sha256=FaembVFO10myBmvt8pknnUxRmFqpJzvEWDPjdjdqVKs,3449 +ansible/modules/windows/win_toast.py,sha256=PE9ThNjCAsSVEy7bNcyFSp6xXXaQSR-sRPKk_2W-ElU,3189 +ansible/modules/windows/win_toast.pyc,, +ansible/modules/windows/win_unzip.ps1,sha256=Vq1aO1Xmr30wF7ZfBrL7Qa3UZmm022i8dkBRTqMV04Y,6313 +ansible/modules/windows/win_unzip.py,sha256=Ey4DbSxSMBer00F3p6l5FtDMHDnpwlI1-sSI--wT2l8,3750 +ansible/modules/windows/win_unzip.pyc,, +ansible/modules/windows/win_updates.ps1,sha256=GUwrWmtZahbmYg1NKBPSgrWGCrXXtuLe3zaNz6OblxY,22852 +ansible/modules/windows/win_updates.py,sha256=KCeCmlBTXxFABrwnkOZX9AzYCRc39no7NP3uAtNi_K8,8017 +ansible/modules/windows/win_updates.pyc,, +ansible/modules/windows/win_uri.ps1,sha256=oAuemWKDETdHXTr4axJYW3VOZt0kf1uOl3-zHyxUAw0,11623 +ansible/modules/windows/win_uri.py,sha256=ZDc_WwgfeciLMWIW72Y62hZkLF_acezO3avPE5gpaxU,6667 +ansible/modules/windows/win_uri.pyc,, +ansible/modules/windows/win_user.ps1,sha256=7DhPilBqukqfgMBNCRe583XzBiHqTuWuqPngb02zlRE,11773 +ansible/modules/windows/win_user.py,sha256=nZdZT4gnHfx4c2SatkVITletvdMlemO3AUEjPtemYFk,5133 +ansible/modules/windows/win_user.pyc,, +ansible/modules/windows/win_user_right.ps1,sha256=W8mUhu9X2X8Q-uOr8Ownu8Rh-rhwoXw7pqB2NwQdn_s,11844 +ansible/modules/windows/win_user_right.py,sha256=qrM0TgPXtK8KDaEwmp4asox8eqNn1dTDixbkyh2dWZk,2856 +ansible/modules/windows/win_user_right.pyc,, +ansible/modules/windows/win_wait_for.ps1,sha256=iZIFfRRubzojpEEH9MqtCcBL56eihBuJuvdq6e89QrA,9747 +ansible/modules/windows/win_wait_for.py,sha256=qPsAHOhSJXLp4Ol5ZQqbovzSYpzDzmlefXZH3-GPjkM,4505 +ansible/modules/windows/win_wait_for.pyc,, +ansible/modules/windows/win_wait_for_process.ps1,sha256=90uPTXb6iBBPIGDlbkQsRhQu8rFkMv-mrkNmKpuTY74,6433 +ansible/modules/windows/win_wait_for_process.py,sha256=-aaUNCmOmI-9v7eXR-04p-TDAYaRiMnF2rS3puGgDlw,3965 +ansible/modules/windows/win_wait_for_process.pyc,, +ansible/modules/windows/win_wakeonlan.ps1,sha256=nja88Ecb7Wmg83eGpqfm35WE0HZ8GjPTUe2B7CAXYz8,1481 +ansible/modules/windows/win_wakeonlan.py,sha256=jV8ASqxGHCBct4p1Jax9s7m1oyC2ecjYRgTVLLy7BSY,1646 +ansible/modules/windows/win_wakeonlan.pyc,, +ansible/modules/windows/win_webpicmd.ps1,sha256=hIgG0nDozKy_OBh9z-Amlz26Drk-ihY4WusaUTEwSLU,2439 +ansible/modules/windows/win_webpicmd.py,sha256=oeH69G_GY_hCPoFnrwUw1GhRoiorWcXJIwJ9vAnpwZQ,1349 +ansible/modules/windows/win_webpicmd.pyc,, +ansible/modules/windows/win_whoami.ps1,sha256=xmzNyU2Wd5aXPhOJEYiiTVeUTOqievByF7GTm9L955M,31749 +ansible/modules/windows/win_whoami.py,sha256=XCYW3Jih45yZkyT0i8dnuCRrsWfXgCXaMhdF4cky5sA,5530 +ansible/modules/windows/win_whoami.pyc,, +ansible/modules/windows/win_xml.ps1,sha256=_PRHw3477GizpldBiaTpJODqZbXtw8p0g-2xtZjuMD8,8593 +ansible/modules/windows/win_xml.py,sha256=4pbqHslILwy4DfyAqtvRZbYmf7Q0a_IE4KbdmIhuqnU,2512 +ansible/modules/windows/win_xml.pyc,, +ansible/parsing/__init__.py,sha256=fPEa2N1Z4mjQHwps752TC-vhKA1CkCoEcAjh0YkfM5Y,826 +ansible/parsing/__init__.pyc,, +ansible/parsing/ajson.py,sha256=xWVceFisyWemkWlbp8Rz3HWa2_LdaJLfwNLuHTys7Z8,2290 +ansible/parsing/ajson.pyc,, +ansible/parsing/dataloader.py,sha256=9D-rh3aid0pskwjXFVywsainiKotecAX1tW01PFyP8w,18556 +ansible/parsing/dataloader.pyc,, +ansible/parsing/metadata.py,sha256=bygTFZugZ0MFSpVF1fFQADCKfkoTmMgP-wpcJKvQN5k,10058 +ansible/parsing/metadata.pyc,, +ansible/parsing/mod_args.py,sha256=HnObQRBuLwQtg6uqKu9JywjJgfuT_aH6KAlFIj1ZsKs,12036 +ansible/parsing/mod_args.pyc,, +ansible/parsing/plugin_docs.py,sha256=ea1N8mVx_0DQ_8nxNyewGEvFBVhO_N1tdXjBnBG0unY,4123 +ansible/parsing/plugin_docs.pyc,, +ansible/parsing/quoting.py,sha256=OsrBXkTzgn8PHH7VGA0kqnz6jBejdoQymDqsOYxTF-M,1141 +ansible/parsing/quoting.pyc,, +ansible/parsing/splitter.py,sha256=aTc_F8TQEr5ZhB6vvgckQloUV_jxCB0xKBt0VajkGDs,10682 +ansible/parsing/splitter.pyc,, +ansible/parsing/utils/__init__.py,sha256=1lMXN1i2fFqslda4BmeI5tpYMFP95D5Wpr1AjDJi-SQ,833 +ansible/parsing/utils/__init__.pyc,, +ansible/parsing/utils/addresses.py,sha256=3qPDjdRhy-z3zch90IYFoyxaR6RRTo8K5Cyuwa5c3jE,8167 +ansible/parsing/utils/addresses.pyc,, +ansible/parsing/utils/jsonify.py,sha256=lVKxFIuoWdmFdqLJe62SJUYPxqwbmi1E7WlSJ4tfFIA,1233 +ansible/parsing/utils/jsonify.pyc,, +ansible/parsing/utils/yaml.py,sha256=XLCe3h9SGYVE4VUA9SET3KhXw2x8TSECIrukhFxiMO8,2809 +ansible/parsing/utils/yaml.pyc,, +ansible/parsing/vault/__init__.py,sha256=qCSuZn6QYhqJUZNLQdsfR3XhwceokRbvEOKTUbXYwlU,52120 +ansible/parsing/vault/__init__.pyc,, +ansible/parsing/yaml/__init__.py,sha256=1lMXN1i2fFqslda4BmeI5tpYMFP95D5Wpr1AjDJi-SQ,833 +ansible/parsing/yaml/__init__.pyc,, +ansible/parsing/yaml/constructor.py,sha256=afSEiBYvLfAy4jIt9f6Ikca1tN8j9KZJjihDWZW7X0k,6286 +ansible/parsing/yaml/constructor.pyc,, +ansible/parsing/yaml/dumper.py,sha256=mx8ixwKoK0xcaRgTZJVkq3L903WpSHLquD612impSIU,2337 +ansible/parsing/yaml/dumper.pyc,, +ansible/parsing/yaml/loader.py,sha256=NTQhgtBrzJUJlRvyzqWQmzLmFdt9xN8Dk9hlkWznQYI,1976 +ansible/parsing/yaml/loader.pyc,, +ansible/parsing/yaml/objects.py,sha256=o0Tyeqe2T0v3PZ1_-yh1R5e3P2oOPuxqcYMSmY-bE5I,4225 +ansible/parsing/yaml/objects.pyc,, +ansible/playbook/__init__.py,sha256=Iau_N6kAsRSrJp9S0Rz_szLfwBH-91XoVroitePA5gA,4708 +ansible/playbook/__init__.pyc,, +ansible/playbook/attribute.py,sha256=W4x_OZ3k-LQSjBTbwHFPVgc2hgEd435uoFZWPgXQ7yI,4344 +ansible/playbook/attribute.pyc,, +ansible/playbook/base.py,sha256=GWgmALmdqRFWEOqsbTxxxUWZrYiN9Sm_Uu_fQrefkdQ,24831 +ansible/playbook/base.pyc,, +ansible/playbook/become.py,sha256=eryONxrilHqQ_Fpa60-InwiUaA4Ff1NWPFRP4zKeU_I,3551 +ansible/playbook/become.pyc,, +ansible/playbook/block.py,sha256=VXRkVW6PnED-2V28wRJBNVgqbMWxmyBJMdbsjPQmoAA,16205 +ansible/playbook/block.pyc,, +ansible/playbook/conditional.py,sha256=Gs-oEESL9WYoGKpCwp83ba8_p10v27Hw635X7V6LIjg,10089 +ansible/playbook/conditional.pyc,, +ansible/playbook/handler.py,sha256=F_udfLWTqtD38WS4Kxk4e0w7pcKwCM1dfHi9W_fLnEs,1974 +ansible/playbook/handler.pyc,, +ansible/playbook/handler_task_include.py,sha256=JMFD1uvmyPqzE6HqPuqaNkbC81v5vFbaM8WreJ75j0E,1307 +ansible/playbook/handler_task_include.pyc,, +ansible/playbook/helpers.py,sha256=fJppIiNqknDGvq2Kek8tL778HA6zNGVAmH6Tdn-1dpc,19153 +ansible/playbook/helpers.pyc,, +ansible/playbook/included_file.py,sha256=XsWk0y1ZRvixalX153fBiKDYW70q10NqkLVjVvNz0nM,9665 +ansible/playbook/included_file.pyc,, +ansible/playbook/loop_control.py,sha256=KeWQB8k3Tf2Ooh9lwQdFuHScTZs-DUPfGxAGL203FNE,1426 +ansible/playbook/loop_control.pyc,, +ansible/playbook/play.py,sha256=y6EX7Gt9106lR9jh60DIHosOnZveAdK-FsGdU-e6XUY,12428 +ansible/playbook/play.pyc,, +ansible/playbook/play_context.py,sha256=r_wSVo8hn3j60NRo2THBI4w6EJsC5eiIjU3f1ZuNO8w,25393 +ansible/playbook/play_context.pyc,, +ansible/playbook/playbook_include.py,sha256=4pyySw16LS2_KbJFvSV2tmqEns3w7E6tP5TqAGyjbRo,6978 +ansible/playbook/playbook_include.pyc,, +ansible/playbook/role/__init__.py,sha256=09J_3ew63xzqG_ibacTEgGzWGE5SfZwHT6FlfNnKiwI,19652 +ansible/playbook/role/__init__.pyc,, +ansible/playbook/role/definition.py,sha256=VZAsLgZyNfJ6sC2aurIMt5pNrDVCxNoSv_kgRTvNV_I,8570 +ansible/playbook/role/definition.pyc,, +ansible/playbook/role/include.py,sha256=e9qOsRf4E6uFGlKnBTnrYNz8jnJPKyv71VgAlQjcYeM,2453 +ansible/playbook/role/include.pyc,, +ansible/playbook/role/metadata.py,sha256=mhVEaGDQxiELAYxVO2cX6hR_3ppEwJggJpR0EsHgItg,4307 +ansible/playbook/role/metadata.pyc,, +ansible/playbook/role/requirement.py,sha256=OY7l6TMl7mtzva_gcuanvne0MPOY29mA3ZIuOaFYb24,6848 +ansible/playbook/role/requirement.pyc,, +ansible/playbook/role_include.py,sha256=Fa5EJCMxfx62-TeJYUA61BwtWU9NWiUu64rtiK79w4w,6752 +ansible/playbook/role_include.pyc,, +ansible/playbook/taggable.py,sha256=Pq2SnpA65XQpC_Ey7Q1jxhjHyjQCsqmkSAlO51kkjjc,3261 +ansible/playbook/taggable.pyc,, +ansible/playbook/task.py,sha256=PxD0cVOLX9SwcoYe37ngQP_JNrU7SDGESUEOCI4rTbc,19644 +ansible/playbook/task.pyc,, +ansible/playbook/task_include.py,sha256=4hipY4GEDsIdumt2YUgRgvBMT_o2nKWkyGJyETGAk7M,4686 +ansible/playbook/task_include.pyc,, +ansible/plugins/__init__.py,sha256=_ZFfi6O5-JGi53R_UpYcsmf5kYFUK7gJTIc51HVbNtY,3099 +ansible/plugins/__init__.pyc,, +ansible/plugins/action/__init__.py,sha256=QTOpt5PU0BwjNjXn_at9zS8R-8YInUE-7rDCGid6NxY,51221 +ansible/plugins/action/__init__.pyc,, +ansible/plugins/action/add_host.py,sha256=HadfsL5rsVpvmKV-kLwlFPEBNHyNiRzWvYcAZN7qjuA,3384 +ansible/plugins/action/add_host.pyc,, +ansible/plugins/action/aireos.py,sha256=xQdoifNurrXDE08Rlhssuus9THdCeYi_fVpgXWsdd2o,3591 +ansible/plugins/action/aireos.pyc,, +ansible/plugins/action/aireos_config.py,sha256=H9FrSj0kbGksGp3hmXUxAnCrcDCtzAKGI-Na6sGHpN4,4221 +ansible/plugins/action/aireos_config.pyc,, +ansible/plugins/action/aruba.py,sha256=mh4V0CGeJfNkt_zwA5zYCXnKiLD5Yk7nUty4QsJNpKo,3677 +ansible/plugins/action/aruba.pyc,, +ansible/plugins/action/aruba_config.py,sha256=9_75x3rhxiHG3ujtPoPTpp5kO3uY2SmlA13GOtz99vY,4220 +ansible/plugins/action/aruba_config.pyc,, +ansible/plugins/action/asa.py,sha256=UZmE0_Q3KmHrJz8pgeMwR_j_N7vqSdjE8YjZ98DFAqI,3031 +ansible/plugins/action/asa.pyc,, +ansible/plugins/action/asa_config.py,sha256=oi-AwERuA1MQJZPlAe7OarK3C-veWP12wSxVYfLhn-Y,4218 +ansible/plugins/action/asa_config.pyc,, +ansible/plugins/action/assemble.py,sha256=WBa6wz-0BlxVz1cN-ra9E3828HSpUNkqH4DFo-Ty0tA,6360 +ansible/plugins/action/assemble.pyc,, +ansible/plugins/action/assert.py,sha256=Qa2ta1UQGFWyd4VqIUuHTTnpdcy2JlKTQdvpcM7G-cw,3237 +ansible/plugins/action/assert.pyc,, +ansible/plugins/action/aws_s3.py,sha256=NI4jPKAWh6qIx4YG-HIfi-c48mFjhgz6FN-oDrEGc6c,2827 +ansible/plugins/action/aws_s3.pyc,, +ansible/plugins/action/bigip.py,sha256=Bt6u-btWqeTWQZ5mhnJHdPunfHnykT8mgrejvub__r0,4346 +ansible/plugins/action/bigip.pyc,, +ansible/plugins/action/bigiq.py,sha256=8Sa0bBfOK-A0EbiKTe11xtuFCwKj2rJYxFuAK8kgfDM,4308 +ansible/plugins/action/bigiq.pyc,, +ansible/plugins/action/ce.py,sha256=7K2B5Anv6YTGP9WuFJSNjN7kdGEswWY_maTtIS_C-0c,5313 +ansible/plugins/action/ce.pyc,, +ansible/plugins/action/ce_config.py,sha256=iy9I5XwQd8Ps37OfuJkmr1qoNjpvRzF76gaa7iB69ts,4247 +ansible/plugins/action/ce_config.pyc,, +ansible/plugins/action/ce_template.py,sha256=BEpSgRxIBjM5C-gAmSvCN7X_6pp0CCojoGOvFa4NQwY,3891 +ansible/plugins/action/ce_template.pyc,, +ansible/plugins/action/cli_command.py,sha256=ClO5Z_S2_YJd43qm4XUbxpzSc2-F9apJwFTXvZTgm2I,1184 +ansible/plugins/action/cli_command.pyc,, +ansible/plugins/action/cli_config.py,sha256=gW9WtBYVLHn5EIVLW3YcUH4y1IrCAxr5FHTt2eQ3xBc,1190 +ansible/plugins/action/cli_config.pyc,, +ansible/plugins/action/cnos.py,sha256=558__ASqIJIwRnPmwveHRdsy0KvFRIbNs2fjXOayS3s,3504 +ansible/plugins/action/cnos.pyc,, +ansible/plugins/action/cnos_config.py,sha256=PBwZjFbtOK6fkK6SrZmLnoXIGtNlDaV5eJRetKajh5U,4009 +ansible/plugins/action/cnos_config.pyc,, +ansible/plugins/action/command.py,sha256=GQSnOVO4f2YvIJ5k2RM5X5dT-rDNuikNvxh0Ae9zuCs,1121 +ansible/plugins/action/command.pyc,, +ansible/plugins/action/copy.py,sha256=hu65iYkWeB4HtTvfwbuj_GA5RueSCoBr-e9G5ukqG2s,26531 +ansible/plugins/action/copy.pyc,, +ansible/plugins/action/debug.py,sha256=EGu5C7fSvMX94PCYNX3YRI-3nIeeIKeBKwlwWM9qD5o,3325 +ansible/plugins/action/debug.pyc,, +ansible/plugins/action/dellos10.py,sha256=clTPKmfs8ZRUvLC4YPxWdsHZAfeB2IjTrnUBFJ4NnlY,4056 +ansible/plugins/action/dellos10.pyc,, +ansible/plugins/action/dellos10_config.py,sha256=Hg_m-OSaV10de_Qbqr5qaydqjQYdioS7PmvTRmJ0Gnw,4286 +ansible/plugins/action/dellos10_config.pyc,, +ansible/plugins/action/dellos6.py,sha256=8t7H_KPkB9MJBt3CC-RIVoLAO6BzzHHGO9SCPbcFZH0,4051 +ansible/plugins/action/dellos6.pyc,, +ansible/plugins/action/dellos6_config.py,sha256=tXJCXqPlgv2uAlYh-EwOqW8TRFQFfPedM8YHL_TelUY,4250 +ansible/plugins/action/dellos6_config.pyc,, +ansible/plugins/action/dellos9.py,sha256=g6RREZ0mmziuRQRzLXW7tnwydK9CfuOroHXHPWQJDzE,4061 +ansible/plugins/action/dellos9.pyc,, +ansible/plugins/action/dellos9_config.py,sha256=k21uC_p0m2TLGxy6rUUc036b_HghjlIpz3dWfQpe4Zk,4285 +ansible/plugins/action/dellos9_config.pyc,, +ansible/plugins/action/edgeos_config.py,sha256=ZWrWKN9w16CgQRYDslmYtv9CV9C96WF6N2PSWByvR8A,4399 +ansible/plugins/action/edgeos_config.pyc,, +ansible/plugins/action/enos.py,sha256=4ovcw0vMajKFEb92Nr_OQWO8v7SrCgOplmF4b7DdSjg,3504 +ansible/plugins/action/enos.pyc,, +ansible/plugins/action/enos_config.py,sha256=fQKUuZSb6PAeDM9Eyz01XAMM7HxCyD47vqD83AslqAA,4017 +ansible/plugins/action/enos_config.pyc,, +ansible/plugins/action/eos.py,sha256=H-UX3Iy7qgkfP3B37Cn37qOGp9eBgGQj_sHxUkT-Fsg,5865 +ansible/plugins/action/eos.pyc,, +ansible/plugins/action/eos_config.py,sha256=uVbS9GHVeaNwfnhspa8Acqfiw4oP_W3cHTwvAaMwXtM,4256 +ansible/plugins/action/eos_config.pyc,, +ansible/plugins/action/exos_config.py,sha256=07fgZqSO4I_enZtn8FODp6JsKniKYwXzim_2lYSRM78,4255 +ansible/plugins/action/exos_config.pyc,, +ansible/plugins/action/fail.py,sha256=tzfT2C4Qn0ifPyl8X3HfPXImTmSsp1DtpvHbojjwdO8,1477 +ansible/plugins/action/fail.pyc,, +ansible/plugins/action/fetch.py,sha256=PaP4ejJXjngjlkRMTD-SZPS9RJ1I-I9kOsBkJFH6Esc,10614 +ansible/plugins/action/fetch.pyc,, +ansible/plugins/action/fortios_config.py,sha256=FG-diX07uszU1xDGoGPuv9Bx6WC9AQA-5AAWeY-YwKE,3105 +ansible/plugins/action/fortios_config.pyc,, +ansible/plugins/action/group_by.py,sha256=bjgpc3YhM3B8BXPxzABHZU_qeb5vEVptFicuzJJnDxI,1914 +ansible/plugins/action/group_by.pyc,, +ansible/plugins/action/include_vars.py,sha256=giCTjJ8W_3IDatZWpIE91joMlak77blTa24OhNUqiug,10966 +ansible/plugins/action/include_vars.pyc,, +ansible/plugins/action/ios.py,sha256=-Q5QUZ2u7c1eFwF81y_cls2diePLMuM-WbHbF5L5lxM,4355 +ansible/plugins/action/ios.pyc,, +ansible/plugins/action/ios_config.py,sha256=pC9QJoVjpY7KJF2GOwQaS5Z8XNBYnvnnLv9DOMTv9B4,4225 +ansible/plugins/action/ios_config.pyc,, +ansible/plugins/action/iosxr.py,sha256=C6NSjSNuz2JwPHvPmcyarIUo45r-Rquz0d1FeXcQKmQ,4981 +ansible/plugins/action/iosxr.pyc,, +ansible/plugins/action/iosxr_config.py,sha256=MzLgkXHGZ1Bd_1VLzZn2ifzoAfgizwjd_SuDkcLCFq8,4227 +ansible/plugins/action/iosxr_config.pyc,, +ansible/plugins/action/ironware.py,sha256=DAqrfMSCJmND2Y_06A-yDuBckMmL05V-UVmADiyVP4M,4380 +ansible/plugins/action/ironware.pyc,, +ansible/plugins/action/ironware_config.py,sha256=nhSBigf-OkaSzIfBEH-UqUZX_1DJJXRmN7K6xGM2L9s,4223 +ansible/plugins/action/ironware_config.pyc,, +ansible/plugins/action/junos.py,sha256=51dBjR75ylY-0mjLP2-499DS2CT-VM4cfD2hJgCJwnE,6079 +ansible/plugins/action/junos.pyc,, +ansible/plugins/action/junos_config.py,sha256=0OtWzg-wGA-MzhfGjQaLqUoQjCbRaBVDo5wbXJsd6qQ,4313 +ansible/plugins/action/junos_config.pyc,, +ansible/plugins/action/net_banner.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_banner.pyc,, +ansible/plugins/action/net_base.py,sha256=pwgDdISe2PLYSz4pI4y5yeVdhEBAKqH0CkugQ2G2yng,9250 +ansible/plugins/action/net_base.pyc,, +ansible/plugins/action/net_config.py,sha256=BGiZB5K6_UAnIXnorlXTv6e1znrJd2cF2YGWqQztl0g,4251 +ansible/plugins/action/net_config.pyc,, +ansible/plugins/action/net_get.py,sha256=8aGC_RHDEZ0WP9iGwhwfO8pbq0uLNpL6YqvuqBIDOaQ,6174 +ansible/plugins/action/net_get.pyc,, +ansible/plugins/action/net_interface.py,sha256=68P6s8l-YInSTSFDX3mtnswP2WkAne3YU3GkMP8O6YA,1057 +ansible/plugins/action/net_interface.pyc,, +ansible/plugins/action/net_l2_interface.py,sha256=68P6s8l-YInSTSFDX3mtnswP2WkAne3YU3GkMP8O6YA,1057 +ansible/plugins/action/net_l2_interface.pyc,, +ansible/plugins/action/net_l3_interface.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_l3_interface.pyc,, +ansible/plugins/action/net_linkagg.py,sha256=68P6s8l-YInSTSFDX3mtnswP2WkAne3YU3GkMP8O6YA,1057 +ansible/plugins/action/net_linkagg.pyc,, +ansible/plugins/action/net_lldp.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_lldp.pyc,, +ansible/plugins/action/net_lldp_interface.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_lldp_interface.pyc,, +ansible/plugins/action/net_logging.py,sha256=68P6s8l-YInSTSFDX3mtnswP2WkAne3YU3GkMP8O6YA,1057 +ansible/plugins/action/net_logging.pyc,, +ansible/plugins/action/net_ping.py,sha256=gnZ-74Z5arU4pZC87rfxNNe2aZCzKzjsqMkQs24R4yE,533 +ansible/plugins/action/net_ping.pyc,, +ansible/plugins/action/net_put.py,sha256=xO0sAgf3-9-TNSrj3-VqAclIg6znzPYC_4veo18ED7E,9402 +ansible/plugins/action/net_put.pyc,, +ansible/plugins/action/net_static_route.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_static_route.pyc,, +ansible/plugins/action/net_system.py,sha256=68P6s8l-YInSTSFDX3mtnswP2WkAne3YU3GkMP8O6YA,1057 +ansible/plugins/action/net_system.pyc,, +ansible/plugins/action/net_user.py,sha256=68P6s8l-YInSTSFDX3mtnswP2WkAne3YU3GkMP8O6YA,1057 +ansible/plugins/action/net_user.pyc,, +ansible/plugins/action/net_vlan.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_vlan.pyc,, +ansible/plugins/action/net_vrf.py,sha256=4DDAMKLYbHKh-GroOU5gJkdCbIpfJpjj-iU9Ou5eq1k,1058 +ansible/plugins/action/net_vrf.pyc,, +ansible/plugins/action/netconf.py,sha256=axLSKmOqkN5sSJ2YjADv8iq_5wCcpBSGARQl3Z5WxmA,3542 +ansible/plugins/action/netconf.pyc,, +ansible/plugins/action/netconf_config.py,sha256=_-thKBlVs-qKRIi9RFP0LvMQcNwkACbwd6BGP3VMcHc,4302 +ansible/plugins/action/netconf_config.pyc,, +ansible/plugins/action/normal.py,sha256=qqPNyAGYbh-y9whTOG0alGF4XXzewVsFGhIqOXcSJbU,2291 +ansible/plugins/action/normal.pyc,, +ansible/plugins/action/nos_config.py,sha256=KBMr0VAoDQuinlQOw_h3CXJPEDpGQJydOwEI_NE6QY8,4235 +ansible/plugins/action/nos_config.pyc,, +ansible/plugins/action/nxos.py,sha256=Kv3asP2cnirflDZF9E_xWaS1oG8OPge8ZiTjqHi3uFw,7223 +ansible/plugins/action/nxos.pyc,, +ansible/plugins/action/nxos_config.py,sha256=C1QGjgFwaEmYgFycxGeOzXIa76saQr4GiyoBc5YSEbc,4256 +ansible/plugins/action/nxos_config.pyc,, +ansible/plugins/action/onyx_config.py,sha256=sC14hsZ6eFISYSPEEmKWpKUTArz9bzDUaNic5s1kcTs,4186 +ansible/plugins/action/onyx_config.pyc,, +ansible/plugins/action/ops_config.py,sha256=o0U2pBNPgnmtaoLrmxyLjwCSLdV63ITGScjz1-u1Pvg,987 +ansible/plugins/action/ops_config.pyc,, +ansible/plugins/action/package.py,sha256=fF4IUcRF40CCEZyEUbFMm_YCreA63LpVcBnPVWOjmzc,3275 +ansible/plugins/action/package.pyc,, +ansible/plugins/action/patch.py,sha256=xFab0ZXgLHvVWmvS4XIvGsVG344mvc0hAfkdVJ3YeOo,2644 +ansible/plugins/action/patch.pyc,, +ansible/plugins/action/pause.py,sha256=JTeRUMJx67AGeeTxKmFvQUCx4Qo7Rr0MtdlVmgJcYuc,10535 +ansible/plugins/action/pause.pyc,, +ansible/plugins/action/raw.py,sha256=gzY8ghrkK741necF08drjnEpGZJrgs_jYos0enp48qA,1823 +ansible/plugins/action/raw.pyc,, +ansible/plugins/action/reboot.py,sha256=9kdjXiya1rHpkOzogCXxWj3NJbGYipruyjxBM4WvTyk,18723 +ansible/plugins/action/reboot.pyc,, +ansible/plugins/action/script.py,sha256=P3RC1kCNjIWsoabVZBqnA94iuEP21k7CzPBnQNt_Rp0,7126 +ansible/plugins/action/script.pyc,, +ansible/plugins/action/service.py,sha256=RiInRV221xj-Asv5U90lMV9mXA1AEMpQOh6CmEAQodY,3488 +ansible/plugins/action/service.pyc,, +ansible/plugins/action/set_fact.py,sha256=M3oUmQJm13gmJj-7KELCvBh5uQQvHxBwen24NBxSwjM,2248 +ansible/plugins/action/set_fact.pyc,, +ansible/plugins/action/set_stats.py,sha256=JC0WHK7PGwD9e8BcQOeegJkq15vOiQOMeXUhXrBrdOc,2903 +ansible/plugins/action/set_stats.pyc,, +ansible/plugins/action/shell.py,sha256=1M7-Lp-a1n2jSdhejAfZ0urKczMFuH6W40KBlO-wDe8,1300 +ansible/plugins/action/shell.pyc,, +ansible/plugins/action/slxos_config.py,sha256=KBMr0VAoDQuinlQOw_h3CXJPEDpGQJydOwEI_NE6QY8,4235 +ansible/plugins/action/slxos_config.pyc,, +ansible/plugins/action/sros.py,sha256=Qm2GsCX5geh0k7UVmCUnh96iU77uJbWcMY3JAGiNEzg,3325 +ansible/plugins/action/sros.pyc,, +ansible/plugins/action/sros_config.py,sha256=oNqu0z1fi3xelpmgpRu2-C7LWLijWyHZXC-Zvs8m7i4,4249 +ansible/plugins/action/sros_config.pyc,, +ansible/plugins/action/synchronize.py,sha256=pG_vCVyl8F19QaYG_ak8Chpqayb-kY3JB_2lwb8WkBA,19868 +ansible/plugins/action/synchronize.pyc,, +ansible/plugins/action/telnet.py,sha256=gYlCtjFVex0Kpx42or6TBVotcbI-wVZqRpSfkOVfc0E,3586 +ansible/plugins/action/telnet.pyc,, +ansible/plugins/action/template.py,sha256=ujZInl-a3A8DKQ9cLQOPk6jtGNl-SoMHXVwyi9e9anA,10338 +ansible/plugins/action/template.pyc,, +ansible/plugins/action/unarchive.py,sha256=FPpVkRqN6TlbCaT-ARD6mhgcr8HHqEehltyWMRB5eWs,4756 +ansible/plugins/action/unarchive.pyc,, +ansible/plugins/action/uri.py,sha256=zqG19xe0kHsHrl61l2N2uva0GCqGI_x-UVbpnYe5_RE,2293 +ansible/plugins/action/uri.pyc,, +ansible/plugins/action/vyos.py,sha256=RRHEp3xUDEJxLEvM--Lkt7F-eIoX90o6FynnrugOBqE,4039 +ansible/plugins/action/vyos.pyc,, +ansible/plugins/action/vyos_config.py,sha256=kxiZ9sp9kV_pYZXrcVE_dytVa7NOi-8sYgBAPTPenTQ,4257 +ansible/plugins/action/vyos_config.pyc,, +ansible/plugins/action/wait_for_connection.py,sha256=zC-jCZj8lZix90kLOz3R1GLq4WZu-SgcrKbisOu-5KI,4571 +ansible/plugins/action/wait_for_connection.pyc,, +ansible/plugins/action/win_copy.py,sha256=JpJvf-Q-_2tGy6E2-N-PqD6lfFcHqcm5OJLyptsWI04,23403 +ansible/plugins/action/win_copy.pyc,, +ansible/plugins/action/win_reboot.py,sha256=px_rfO5XfkoaTLtSSj8IJiujNTLLCirmXOiOcuh7R7M,3876 +ansible/plugins/action/win_reboot.pyc,, +ansible/plugins/action/win_template.py,sha256=C5RVcj2ZmZv_cau2XRCrkQDFkPs5QpcoJn6aLnm18oY,1198 +ansible/plugins/action/win_template.pyc,, +ansible/plugins/action/win_updates.py,sha256=5S_BSDqZ0wcAg0_U97UAHFrYwKdiY0WVNy7X7RxED38,12639 +ansible/plugins/action/win_updates.pyc,, +ansible/plugins/action/yum.py,sha256=COE2VAeO_kTqgEBfhxN_S2vNzswTrD0uerJg722roL0,4249 +ansible/plugins/action/yum.pyc,, +ansible/plugins/cache/__init__.py,sha256=ZnS1CozTDPM1HQCllLrrePIDZPBD0XfreBZSUySf8D0,11632 +ansible/plugins/cache/__init__.pyc,, +ansible/plugins/cache/base.py,sha256=WuH2NKXu92mDw_s7VhT4Z-RBWfAL9K1dNG4u0tGrZGo,927 +ansible/plugins/cache/base.pyc,, +ansible/plugins/cache/jsonfile.py,sha256=9cBlpgwccIe-B2cGC--RWyEsDYh-h3sWsYeKxoAJfIc,1986 +ansible/plugins/cache/jsonfile.pyc,, +ansible/plugins/cache/memcached.py,sha256=PCwVW1aw0c_EdGTzKfI2ARewGoeB1u_1y7wMAOJQNMQ,6858 +ansible/plugins/cache/memcached.pyc,, +ansible/plugins/cache/memory.py,sha256=zZg9NoB5hkGWvES2d0nTAag70OCaUq9_qyctE8XB7HE,1272 +ansible/plugins/cache/memory.pyc,, +ansible/plugins/cache/mongodb.py,sha256=NdXqZXtaTWjZg8lfIHC9f1d-P2NW9O8uSAmorVRaR7k,5534 +ansible/plugins/cache/mongodb.pyc,, +ansible/plugins/cache/pickle.py,sha256=U_l5Y--yLOtyN3L3fqOZIY-yHYVZgXA4NCTLKQAcyaE,2016 +ansible/plugins/cache/pickle.pyc,, +ansible/plugins/cache/redis.py,sha256=Yz3Yapbr9ZR9KIchUYd3iHauR5hS92gkeCemFSIynq0,4392 +ansible/plugins/cache/redis.pyc,, +ansible/plugins/cache/yaml.py,sha256=SGYIngpsscHXUaHUzVRY9YHt6pbPmRjwPV3Hf7W7Nbk,1924 +ansible/plugins/cache/yaml.pyc,, +ansible/plugins/callback/__init__.py,sha256=VFxBsH0VLx0ukY2lNxoId0sPEL8TDsUwSTTqcsEgvUc,15639 +ansible/plugins/callback/__init__.pyc,, +ansible/plugins/callback/actionable.py,sha256=ah8YqPb5Ca5YN1XssibKT0AvyK9feJs_zunnPZY3PqE,4172 +ansible/plugins/callback/actionable.pyc,, +ansible/plugins/callback/cgroup_memory_recap.py,sha256=uVlr9De3YUp66tGkFttTcmR8SwrJMVvnbkfaoh8n81Q,4266 +ansible/plugins/callback/cgroup_memory_recap.pyc,, +ansible/plugins/callback/context_demo.py,sha256=AgW4pRItewktiNoqSeZCwmbM85dEF766FtR_s171bBI,1793 +ansible/plugins/callback/context_demo.pyc,, +ansible/plugins/callback/counter_enabled.py,sha256=44gRmWjcWt11XuWE3oanEOsb1g5j-TFC_Dnj9zwHMuw,10814 +ansible/plugins/callback/counter_enabled.pyc,, +ansible/plugins/callback/debug.py,sha256=-rSdbj5as6MNFucXs-68uO6xsWWBPYBU4e3cap-EfsY,1772 +ansible/plugins/callback/debug.pyc,, +ansible/plugins/callback/default.py,sha256=MMREu-Mg6kpziCxiqtyjj-aTldQ9HrDJIw6XNvT9vNU,16866 +ansible/plugins/callback/default.pyc,, +ansible/plugins/callback/dense.py,sha256=IPUg6Aw7t2LdRNB3nj6Cnux8OT-fps2tZZ_qkr3icvs,17305 +ansible/plugins/callback/dense.pyc,, +ansible/plugins/callback/foreman.py,sha256=3yzloeGrJdvnmlVes8x1OG01Xubx6KKdppVSxDeFMrQ,8807 +ansible/plugins/callback/foreman.pyc,, +ansible/plugins/callback/full_skip.py,sha256=V7SM9MfBTknUA1LxJg42HRok6TW0PwF7mLRFJO25CB0,2498 +ansible/plugins/callback/full_skip.pyc,, +ansible/plugins/callback/grafana_annotations.py,sha256=kPHKdo6oL4fu4H6pbKICa8TsyfYEStlInHKR9odL1HA,9217 +ansible/plugins/callback/grafana_annotations.pyc,, +ansible/plugins/callback/hipchat.py,sha256=S0g-w8U_vHX3MbtJQq6k6DR7ATobm0i9ZZf-GOx-SLA,8120 +ansible/plugins/callback/hipchat.pyc,, +ansible/plugins/callback/jabber.py,sha256=BCQ5eW7uoFuoQ6LkqdlkSxdrfE9Pj4gGbwRvx_EENSs,3912 +ansible/plugins/callback/jabber.pyc,, +ansible/plugins/callback/json.py,sha256=JWwHKa_nGq5qNwKs9qXc-mIk2I6palE13IGLNmOar3s,4338 +ansible/plugins/callback/json.pyc,, +ansible/plugins/callback/junit.py,sha256=E10qjxK6KjHshhqbD73PtgdwIO_p2oRolIOJPtGVd3Q,11703 +ansible/plugins/callback/junit.pyc,, +ansible/plugins/callback/log_plays.py,sha256=sJRJAIG6bxH6qXu_o1MSQn55oHqxT1ClbEbdOj5GWaA,3255 +ansible/plugins/callback/log_plays.pyc,, +ansible/plugins/callback/logdna.py,sha256=fKC5JKgtDHQVDHeFc0W3oM9byt7lZE2dwRueNXOyR4Q,6821 +ansible/plugins/callback/logdna.pyc,, +ansible/plugins/callback/logentries.py,sha256=J0OQiDAMlSLybZIURuD4RuOEmZ0LIb2kijWLt5Bc0zY,10967 +ansible/plugins/callback/logentries.pyc,, +ansible/plugins/callback/logstash.py,sha256=8fQrL19U2CrXTciSCp2BBCPQ2OYezRzicd8EvK0apoc,7348 +ansible/plugins/callback/logstash.pyc,, +ansible/plugins/callback/mail.py,sha256=IlsGlJ1Qe0RY9rysC0Z1yt6TRu6RjeyNJRGpovt7EYY,8479 +ansible/plugins/callback/mail.pyc,, +ansible/plugins/callback/minimal.py,sha256=YpA5_zleKpvGZFxbouNCgzhLbkEDo0nq17WcQpkXRKE,2986 +ansible/plugins/callback/minimal.pyc,, +ansible/plugins/callback/null.py,sha256=MorN25TyVpyruh9Vt6f6cyZTqyaqsNo16oqJHBOz7zo,799 +ansible/plugins/callback/null.pyc,, +ansible/plugins/callback/oneline.py,sha256=wXhULNYN8Bp2UhrwSxwmfBpoSlI6pFerOuLclERbhf8,3489 +ansible/plugins/callback/oneline.pyc,, +ansible/plugins/callback/osx_say.py,sha256=qcTvKHpLzGQOt9d8PbuEyKZx7jLWkv2Gek9NUf663ts,2869 +ansible/plugins/callback/osx_say.pyc,, +ansible/plugins/callback/profile_roles.py,sha256=n2wNwnliXsxRcMnpBmp3EMPqniDOVsfqDtcdnsBY3c4,3490 +ansible/plugins/callback/profile_roles.pyc,, +ansible/plugins/callback/profile_tasks.py,sha256=qXdEw8qtwWMonjxIVJQ8Ya9h6MKgG1I6SY-KxV6f1IQ,6396 +ansible/plugins/callback/profile_tasks.pyc,, +ansible/plugins/callback/selective.py,sha256=duobNyaXILHkkhV4T-raTuUeLQVHYhU9_-HY2a9gmGo,10384 +ansible/plugins/callback/selective.pyc,, +ansible/plugins/callback/skippy.py,sha256=MqSiuRUG-uxphFDLmcq2J7fora-aJzTd1npj5qgcEE4,1404 +ansible/plugins/callback/skippy.pyc,, +ansible/plugins/callback/slack.py,sha256=aV2JEShGZF9wp1ERT2Vrok0cOJK2nvukwIV1hpaN68M,7669 +ansible/plugins/callback/slack.pyc,, +ansible/plugins/callback/splunk.py,sha256=6CSVEMWvhSWNW5xvY0m-53g3ErxVr2RoDVJLlOz1-FA,8017 +ansible/plugins/callback/splunk.pyc,, +ansible/plugins/callback/stderr.py,sha256=K9_kmmuibzKvjRPMdKDlefKofW5HodcL5fZS_PfN-5g,2735 +ansible/plugins/callback/stderr.pyc,, +ansible/plugins/callback/sumologic.py,sha256=uGy58BcyLE97DZ6B6XA7467CCjUIOGV-K2d14xG2vCw,6802 +ansible/plugins/callback/sumologic.pyc,, +ansible/plugins/callback/syslog_json.py,sha256=9oPDJuLnTbkwacvqEOjzX_FwzA_3iWPCXvheKd1x0OU,3604 +ansible/plugins/callback/syslog_json.pyc,, +ansible/plugins/callback/timer.py,sha256=Wv46-tRVOrJ27OA7PChJnddRU8NA3pb6i1lBol7_iZ4,1529 +ansible/plugins/callback/timer.pyc,, +ansible/plugins/callback/tree.py,sha256=-DyIYL5sG4E7JuvtgHxKC8PiMLB6OCGe2IMXs-L698Y,2337 +ansible/plugins/callback/tree.pyc,, +ansible/plugins/callback/unixy.py,sha256=FEdt_8QcIsf92D6VLK_kkbUp6feYrBHerl6BQeEeQvs,7984 +ansible/plugins/callback/unixy.pyc,, +ansible/plugins/callback/yaml.py,sha256=GsPTWw-Y0HhVlSordz3b_CdUQI_o3XKxelTMaeIvvMk,4458 +ansible/plugins/callback/yaml.pyc,, +ansible/plugins/cliconf/__init__.py,sha256=geokgJywbcQkB55CYIns7H61gqc6TacronbDEp5Xnoo,21013 +ansible/plugins/cliconf/__init__.pyc,, +ansible/plugins/cliconf/aireos.py,sha256=z0JS-TB-N8pBKwvyE2Em6k8N1xGbJeNIZ7Ml9nmqcNQ,2802 +ansible/plugins/cliconf/aireos.pyc,, +ansible/plugins/cliconf/aruba.py,sha256=7IYHvVXWq9x_xCyOd0EOBSOluHq8M45aCCRAyUqTVoU,2798 +ansible/plugins/cliconf/aruba.pyc,, +ansible/plugins/cliconf/asa.py,sha256=cCarqASfGYdIA6caowg25S8VPa1PVekJBP79XvS6uoo,2688 +ansible/plugins/cliconf/asa.pyc,, +ansible/plugins/cliconf/ce.py,sha256=8jiKNUO4N9pCHvgB7ycMFOHt_Sj_r2vnERiQmavU2sU,3132 +ansible/plugins/cliconf/ce.pyc,, +ansible/plugins/cliconf/cnos.py,sha256=t5yGTmQJt19B4wUmw3uqYAb6zQn86lEjKLaF7wyJtnk,3094 +ansible/plugins/cliconf/cnos.pyc,, +ansible/plugins/cliconf/dellos10.py,sha256=7LlwzITJ6lq5aKMOyeM6sxrICRgtzKs-xODwvSCr7Vc,2861 +ansible/plugins/cliconf/dellos10.pyc,, +ansible/plugins/cliconf/dellos6.py,sha256=4T_d8TbTuxu8ZLxx_UxkJzkFXcbk3Y3F8hqLv0Sjkys,2853 +ansible/plugins/cliconf/dellos6.pyc,, +ansible/plugins/cliconf/dellos9.py,sha256=aNEV0Kh6oFGq_Qv8W1i5yMKOrJUJc_Zz1f0NDipHsAQ,2853 +ansible/plugins/cliconf/dellos9.pyc,, +ansible/plugins/cliconf/edgeos.py,sha256=HlV-_RGBlbDDuCATWnfFQxCuJABZ9hK_PHRqZKQLzC8,2196 +ansible/plugins/cliconf/edgeos.pyc,, +ansible/plugins/cliconf/enos.py,sha256=0V8QZbkEjhCWcG31CEF8F__RP8r8oMHynvXFRcV-L_c,2594 +ansible/plugins/cliconf/enos.pyc,, +ansible/plugins/cliconf/eos.py,sha256=gU90GRVw5eoWDrFI-b85InsAABabCMN2b7exlueDkb0,11633 +ansible/plugins/cliconf/eos.pyc,, +ansible/plugins/cliconf/exos.py,sha256=JPUGFdf5RVFQuA-WjfEkAgIQ6UbFGniQi7XyLAGfSQ0,4342 +ansible/plugins/cliconf/exos.pyc,, +ansible/plugins/cliconf/ios.py,sha256=udThUzdLDH2E_8OO1lQotmId9Ez0o2xHqWy5sFvwvbs,13844 +ansible/plugins/cliconf/ios.pyc,, +ansible/plugins/cliconf/iosxr.py,sha256=4RYiUEK1XdzdIUWsWWryHRzGP8frT9Ue6yU4IenBKZ8,9245 +ansible/plugins/cliconf/iosxr.pyc,, +ansible/plugins/cliconf/ironware.py,sha256=cpEjvXAygXJqRIyQkyr-kWF6pl6WhTVVRejgTzAw6vE,2790 +ansible/plugins/cliconf/ironware.pyc,, +ansible/plugins/cliconf/junos.py,sha256=xv9P_50qcZceBRgYW0ta7RvHfb0YMkHaz8F6tsF7y8A,8656 +ansible/plugins/cliconf/junos.pyc,, +ansible/plugins/cliconf/nos.py,sha256=QRWB-jZN45c-VwtFZJZf2Mp4KcrzNyMVc2CEh5Ug4yw,3614 +ansible/plugins/cliconf/nos.pyc,, +ansible/plugins/cliconf/nxos.py,sha256=bXepCB3xdII8DiWEFouYDq7a7jjPh3xM3qxh4sQzAA0,11036 +ansible/plugins/cliconf/nxos.pyc,, +ansible/plugins/cliconf/onyx.py,sha256=fM14UjGsHDiVo8tw6Ei948aGzjPqylHlE7Y54QLjGak,2529 +ansible/plugins/cliconf/onyx.pyc,, +ansible/plugins/cliconf/routeros.py,sha256=MedEY20R1Cf7wr1LxI3JjB1MNrZhlsgM5vuEfZwt40Y,2661 +ansible/plugins/cliconf/routeros.pyc,, +ansible/plugins/cliconf/slxos.py,sha256=sEnoY2fAsS8tpnUi43RxmNSmKCUrwF95ctPRZdBzDUk,3432 +ansible/plugins/cliconf/slxos.pyc,, +ansible/plugins/cliconf/voss.py,sha256=d3AcreugqMNilvq4cWqwJZmfTpxV7BEDjuAhaAzDEF8,9376 +ansible/plugins/cliconf/voss.pyc,, +ansible/plugins/cliconf/vyos.py,sha256=BbV-v2TWd36AKJQiOw1p37QhPUMX6n488E3AyYE1aiw,9009 +ansible/plugins/cliconf/vyos.pyc,, +ansible/plugins/connection/__init__.py,sha256=zD2sPXe9BN6SWvL458mOdNVvARf7YdC_nxi5lQtHd5M,16390 +ansible/plugins/connection/__init__.pyc,, +ansible/plugins/connection/buildah.py,sha256=5KbW2frqvCOI1UU-2gCGtnyyGo4Qf7IyobtvnQ9WgZ4,6344 +ansible/plugins/connection/buildah.pyc,, +ansible/plugins/connection/chroot.py,sha256=RX99QvThAXYVi9N3SaFPFDF4_CURYvPwzmGJEGRN-4o,8011 +ansible/plugins/connection/chroot.pyc,, +ansible/plugins/connection/docker.py,sha256=lMmSAsoMmtZqDTM9zDGRxuNJIglo80TJNMlMhpVvf1g,13481 +ansible/plugins/connection/docker.pyc,, +ansible/plugins/connection/funcd.py,sha256=EFc9gbj9lGZe266ZmJ0zP2H5-GLEE8tEhVGsLbrcyE8,3599 +ansible/plugins/connection/funcd.pyc,, +ansible/plugins/connection/httpapi.py,sha256=MKZ4jDATFYaUSyOvYaBlmscWwSG331gWYfrv6gCSWBU,9997 +ansible/plugins/connection/httpapi.pyc,, +ansible/plugins/connection/iocage.py,sha256=wkSxh8cvxV26xNt_sx1e11ErJJA6bYp2wxzf-q5fIko,2516 +ansible/plugins/connection/iocage.pyc,, +ansible/plugins/connection/jail.py,sha256=eTGS3u0HpE-zbL9-UAa937LXpV-d8kU6UcmXmFLpw-Y,8095 +ansible/plugins/connection/jail.pyc,, +ansible/plugins/connection/kubectl.py,sha256=NdC4-yA_NCivIbQUjbqYVp8aMBTD4yqB8Q14hj3ebKE,13358 +ansible/plugins/connection/kubectl.pyc,, +ansible/plugins/connection/libvirt_lxc.py,sha256=fRbo76UhfVASg_lgSXKBAQOJuYWAD1AA_tC6FhhA-gQ,7515 +ansible/plugins/connection/libvirt_lxc.pyc,, +ansible/plugins/connection/local.py,sha256=yrPf9kSd6252FxzhwR57ELwG5jaxPirxIyza9o6KtwE,6815 +ansible/plugins/connection/local.pyc,, +ansible/plugins/connection/lxc.py,sha256=lvy0nj9IPXkZsLYPAB5RKdkBq7FVHtOooytJByISloU,8230 +ansible/plugins/connection/lxc.pyc,, +ansible/plugins/connection/lxd.py,sha256=MY4FC2JH0gxMwPs4ciEI5HNEL_5Gp_RY7mhEVzQqR8A,4477 +ansible/plugins/connection/lxd.pyc,, +ansible/plugins/connection/netconf.py,sha256=iJzAkT90zC-neOP4vqUHWFEp-vq-Z4iY1Xk4nCpY6is,11799 +ansible/plugins/connection/netconf.pyc,, +ansible/plugins/connection/network_cli.py,sha256=Qcf5YFRQXwASPcFEZisXpewAdakz8A84OM3vpfqeASY,23294 +ansible/plugins/connection/network_cli.pyc,, +ansible/plugins/connection/oc.py,sha256=4ytltJRtrsJ_vltS0SfD8EV4pccmiifxXcc-xNVB6HE,4805 +ansible/plugins/connection/oc.pyc,, +ansible/plugins/connection/paramiko_ssh.py,sha256=K1OMnJgtOFnvpyrZyP8iviLyXqmo2OExkWRt5HaVqlU,23373 +ansible/plugins/connection/paramiko_ssh.pyc,, +ansible/plugins/connection/persistent.py,sha256=LNg-aMCfUPz-UgJqid0vseSw9r4tRIwvBYxagBiC5oI,5340 +ansible/plugins/connection/persistent.pyc,, +ansible/plugins/connection/psrp.py,sha256=abmgqREGec45YFdkY3avSQClyZDHgNRsICigWQyll9I,24264 +ansible/plugins/connection/psrp.pyc,, +ansible/plugins/connection/saltstack.py,sha256=i3_KGoEW3hAdTo8qdReZpnBbyyulIcKE5buZsawV1lg,3724 +ansible/plugins/connection/saltstack.pyc,, +ansible/plugins/connection/ssh.py,sha256=98GvaHZfAlyKg0ePz1HX_U8Kz56_eOzApMIpeNv2G6o,52732 +ansible/plugins/connection/ssh.pyc,, +ansible/plugins/connection/winrm.py,sha256=ZB3k25mxich--7diq2-Zbj9EybmGVKbYD2jEvBKcrGE,32106 +ansible/plugins/connection/winrm.pyc,, +ansible/plugins/connection/zone.py,sha256=HAZvuenXfM8DxxEz8VwwXN6G8i8UO2yEYxKI1aM-glw,8097 +ansible/plugins/connection/zone.pyc,, +ansible/plugins/filter/__init__.py,sha256=9gBS3ZO7DXC3ydwDfYXbwZBht33NF0GDN1sWv7WxrWY,119 +ansible/plugins/filter/__init__.pyc,, +ansible/plugins/filter/core.py,sha256=EmjCwCvDAOHZoA3C5QnGdfHPh-N3-QDAb6w7d3juwFU,19959 +ansible/plugins/filter/core.pyc,, +ansible/plugins/filter/ipaddr.py,sha256=notjy3ZAKezeOSZnLc-_Ls8DgiqiuLxmB_5p-J8Z92Q,32105 +ansible/plugins/filter/ipaddr.pyc,, +ansible/plugins/filter/json_query.py,sha256=A42dOJl_ynFArlaQmP0tbdK9TRO3fQ1OCE4-cKZNIlA,1857 +ansible/plugins/filter/json_query.pyc,, +ansible/plugins/filter/mathstuff.py,sha256=GD2frp_uVumaLYXeNvHM41ZpfKYcppptFGcPGiPztWA,6492 +ansible/plugins/filter/mathstuff.pyc,, +ansible/plugins/filter/network.py,sha256=RZAh4WUDfnCjPtRdFitwgFFWGGfN-pD9A6pp9_ZmkOc,13276 +ansible/plugins/filter/network.pyc,, +ansible/plugins/filter/urlsplit.py,sha256=I1RPI9YT7Zc0Cvs-_spmjj1rwrC29OUGcmQGhPEzK5g,1136 +ansible/plugins/filter/urlsplit.pyc,, +ansible/plugins/httpapi/__init__.py,sha256=BLrvTsxSrbeI8bpt4W3AxAaRn5g8vMEBEigP26gBVaM,2860 +ansible/plugins/httpapi/__init__.pyc,, +ansible/plugins/httpapi/eos.py,sha256=RZFje8oJdoa2tfqScSnQbY_7GxuTG6lgJRfQ9EhfKYg,6101 +ansible/plugins/httpapi/eos.pyc,, +ansible/plugins/httpapi/ftd.py,sha256=VYK8pG0xwB2PX_7X-ruuysvqQDFLo11oDHqevxsHZUQ,12052 +ansible/plugins/httpapi/ftd.pyc,, +ansible/plugins/httpapi/nxos.py,sha256=rF9wNWmzTRzgpKCXbi9RciJiN_iTnFSHhWFMa-g2WzQ,5356 +ansible/plugins/httpapi/nxos.pyc,, +ansible/plugins/inventory/__init__.py,sha256=R5pdjSsZRf-jdruLNv0h2FRBy2Fi2MkAdlFO361VN7g,14402 +ansible/plugins/inventory/__init__.pyc,, +ansible/plugins/inventory/advanced_host_list.py,sha256=i2jZiv33yoRleSbwAa3QC1a8bvhnj5aTHv9umRDyVc0,3140 +ansible/plugins/inventory/advanced_host_list.pyc,, +ansible/plugins/inventory/auto.py,sha256=NjaxdYXHo1apwofnF7CgXZtx9IGEHmnrPblyY-h0swk,2281 +ansible/plugins/inventory/auto.pyc,, +ansible/plugins/inventory/aws_ec2.py,sha256=W5CHEuTg9hWhYczpMosC4fsXhECRJFbXBCdifFfxgWs,24755 +ansible/plugins/inventory/aws_ec2.pyc,, +ansible/plugins/inventory/aws_rds.py,sha256=TcHUaxHvfWpD9-O--hzzxb_R4kozOnLKmyrtGj68IYc,15354 +ansible/plugins/inventory/aws_rds.pyc,, +ansible/plugins/inventory/azure_rm.py,sha256=1TGxFsTT5KB2a_VWYt7DPZx2Sn-pD1iujvGzoyIGUa0,27693 +ansible/plugins/inventory/azure_rm.pyc,, +ansible/plugins/inventory/constructed.py,sha256=HZvCG7tyjVa4VyeYEpQfMpyqSXGptPFXOki7RIqaPn8,5104 +ansible/plugins/inventory/constructed.pyc,, +ansible/plugins/inventory/foreman.py,sha256=SUudUsUyr1yx03B4-qAi0yRUCOn-e9YgkMPTgoyNX6A,9222 +ansible/plugins/inventory/foreman.pyc,, +ansible/plugins/inventory/gcp_compute.py,sha256=s0vEUoBwMJLeySsBskDf2wWitL8BBJwUcTqzV9iPWLM,13320 +ansible/plugins/inventory/gcp_compute.pyc,, +ansible/plugins/inventory/generator.py,sha256=f3ellSUFV9J59wGd3uXISWeEtWm0w13rpl0fGQvgVSc,5479 +ansible/plugins/inventory/generator.pyc,, +ansible/plugins/inventory/host_list.py,sha256=xIitPKqG77suT1ClJimhqJb0cgDx3di7jXRFhltkZa0,2286 +ansible/plugins/inventory/host_list.pyc,, +ansible/plugins/inventory/ini.py,sha256=0uaI7JA2czEALSem8cn694VXFzTxy7nE49nBHaaoSy4,17056 +ansible/plugins/inventory/ini.pyc,, +ansible/plugins/inventory/k8s.py,sha256=TI6BvA868_l0BrkoFZh649RakIeTbsofwQCYLTlEl9A,4893 +ansible/plugins/inventory/k8s.pyc,, +ansible/plugins/inventory/nmap.py,sha256=PnCHo9Ax7ZSBQj8Glj6_dK5PvDb5qMU7UDaE2sbGIAw,5747 +ansible/plugins/inventory/nmap.pyc,, +ansible/plugins/inventory/openshift.py,sha256=LtdaKEiKIh7doVHoCvz38x84GOyXDVMIgKyDkXVOE1g,4940 +ansible/plugins/inventory/openshift.pyc,, +ansible/plugins/inventory/openstack.py,sha256=KmnMyLIrVQ1QyYI1gikoxmszw7lrZHUrDf4RrYp8bTA,12882 +ansible/plugins/inventory/openstack.pyc,, +ansible/plugins/inventory/scaleway.py,sha256=EhSZiRbyl_-mGIFDR20XGLtVAFOdbaTABqIU203-5-Y,8144 +ansible/plugins/inventory/scaleway.pyc,, +ansible/plugins/inventory/script.py,sha256=vdoL-jj3-Ek810yhNsLituGw3Ve7wqtgbJP9Mvw68a4,8443 +ansible/plugins/inventory/script.pyc,, +ansible/plugins/inventory/tower.py,sha256=flsS9mDg8ne3MHGACei0BM8ZXgf2o6XNGnEPgcMmJTo,8475 +ansible/plugins/inventory/tower.pyc,, +ansible/plugins/inventory/virtualbox.py,sha256=U4DB9gmkdZeRMBF61V4BJzW7tDfS3j5oY5kiHXGTif8,9706 +ansible/plugins/inventory/virtualbox.pyc,, +ansible/plugins/inventory/vmware_vm_inventory.py,sha256=T9rXn3-d0lZ0GrHP0tOkKzvUBZnvkpHzB6UcTrgqOaQ,19677 +ansible/plugins/inventory/vmware_vm_inventory.pyc,, +ansible/plugins/inventory/vultr.py,sha256=tOn9B1PwOPUaHtbcvvX2SMcyOLEzk4syfes6Agf8fD4,5042 +ansible/plugins/inventory/vultr.pyc,, +ansible/plugins/inventory/yaml.py,sha256=BrBr66IOGTxk5vzVDFppDxuTIVIKU7VBKDJtcoQSJ0g,7092 +ansible/plugins/inventory/yaml.pyc,, +ansible/plugins/loader.py,sha256=d8I3ua9b9ohP2yraBl0kxx55RCDJKRXh94Q-rGglpJA,30192 +ansible/plugins/loader.pyc,, +ansible/plugins/lookup/__init__.py,sha256=jpr-yLrAhuoeHP2Dil37VVJCUtv9vfoLWCSnho7REyM,4474 +ansible/plugins/lookup/__init__.pyc,, +ansible/plugins/lookup/_openshift.py,sha256=iNUdvENoZQ9Dksp64Aq1sObao8AkobFLnawnbc9kGjg,11157 +ansible/plugins/lookup/_openshift.pyc,, +ansible/plugins/lookup/_redis_kv.py,sha256=Ag1QzrC7i2GHp-Ot1DCJeYgjbWPbV7nNMsjohpwiXQo,3040 +ansible/plugins/lookup/_redis_kv.pyc,, +ansible/plugins/lookup/aws_account_attribute.py,sha256=AwOwCwp-_HGegoEK6zFaQE9oGZuohcnmsAqfwtk0dV8,4585 +ansible/plugins/lookup/aws_account_attribute.pyc,, +ansible/plugins/lookup/aws_service_ip_ranges.py,sha256=5DiJEvX5jPo3zEccZqyF9knNy1mI7WkOfh5RIn1LjaI,3425 +ansible/plugins/lookup/aws_service_ip_ranges.pyc,, +ansible/plugins/lookup/aws_ssm.py,sha256=V_Aj44L-iX_Ed4240zVnw1FyFfzBsvMbpILpjl-luE0,10324 +ansible/plugins/lookup/aws_ssm.pyc,, +ansible/plugins/lookup/cartesian.py,sha256=MHrf8QePoI8Geg9LPTtUtE5M-F_AYYCg0Szf8m1heQ8,2174 +ansible/plugins/lookup/cartesian.pyc,, +ansible/plugins/lookup/chef_databag.py,sha256=S5F6QACGfp6qN1vA-av63pvT9_Aq3MtkaDv1QMDgEA0,3251 +ansible/plugins/lookup/chef_databag.pyc,, +ansible/plugins/lookup/config.py,sha256=a9-8XckEf0ga1LkaqRo3y2trmvn0M3Q1sgrMgphS4mA,3050 +ansible/plugins/lookup/config.pyc,, +ansible/plugins/lookup/conjur_variable.py,sha256=zFKzGhITpIROQnStF2SxaRJz51HD9v87QCJkPh9AbJs,6382 +ansible/plugins/lookup/conjur_variable.pyc,, +ansible/plugins/lookup/consul_kv.py,sha256=gGTMpX4IyKKUP2Bwe9qVLiy9xeBKQ4CnMos9D8XikYs,6400 +ansible/plugins/lookup/consul_kv.pyc,, +ansible/plugins/lookup/cpm_metering.py,sha256=Mh3IYONNT5ViUyVU91vuOMyJcRwS9sCTk8t2eKCqBAQ,5916 +ansible/plugins/lookup/cpm_metering.pyc,, +ansible/plugins/lookup/cpm_status.py,sha256=cqa-q0doJAfKUHRE7ZddDgxUF_mHtiku5v6y6j-MVQE,5627 +ansible/plugins/lookup/cpm_status.pyc,, +ansible/plugins/lookup/credstash.py,sha256=GVUbzHtiQN_MS9YD4kC4ypFyxwPhXv5lLhjBC3rIe84,4393 +ansible/plugins/lookup/credstash.pyc,, +ansible/plugins/lookup/csvfile.py,sha256=lPaj90NFd-NaMWGI-g2is5IhWlGGYLcTelz-1zZvHu4,5009 +ansible/plugins/lookup/csvfile.pyc,, +ansible/plugins/lookup/cyberarkpassword.py,sha256=EDQUZyHqboS8YlCkBpMEA-OOohnANLIAJsmQA2Ygx9M,6112 +ansible/plugins/lookup/cyberarkpassword.pyc,, +ansible/plugins/lookup/dict.py,sha256=WKmscU_V5zAS4gT0BXAqnQsnveuruQhNgju6FQbY0ZU,2182 +ansible/plugins/lookup/dict.pyc,, +ansible/plugins/lookup/dig.py,sha256=uNCUBjvIm6X7TPVhZ7S1QHa23dIyTdil_wxrjZtdaK8,13015 +ansible/plugins/lookup/dig.pyc,, +ansible/plugins/lookup/dnstxt.py,sha256=xxPTAMpX7g0QnQTPbsgVSr8oAAeJe_ZD8J-INfXcfpA,2615 +ansible/plugins/lookup/dnstxt.pyc,, +ansible/plugins/lookup/env.py,sha256=ZrhlwmHEpxFHEcBCWXXVEVCfomDSxP5DYYLZwXDMmH8,1179 +ansible/plugins/lookup/env.pyc,, +ansible/plugins/lookup/etcd.py,sha256=FwKUfc5kZmxXEc3-rM35pIC_lNgDuv0I2pSFx-4yuEY,5572 +ansible/plugins/lookup/etcd.pyc,, +ansible/plugins/lookup/file.py,sha256=MhZ5GzLW-i_FwvH5fFVH2b78mEkqWsWwWW9HOVV0xNg,2913 +ansible/plugins/lookup/file.pyc,, +ansible/plugins/lookup/fileglob.py,sha256=Iu6LBGdJYz5hM-XEYAQldqRDO0DM4ezTUVzyrI8_OuE,1924 +ansible/plugins/lookup/fileglob.pyc,, +ansible/plugins/lookup/filetree.py,sha256=25-b5eCCm86Oo-XN0kBWdsYHw_oHweXk9h6R6rZqhrE,5782 +ansible/plugins/lookup/filetree.pyc,, +ansible/plugins/lookup/first_found.py,sha256=6T3nfPfi6mCL3OyW_sxnIWGgLsGoILNRX0-6w8YjTSU,5232 +ansible/plugins/lookup/first_found.pyc,, +ansible/plugins/lookup/flattened.py,sha256=Qw89M_DRoc_Ld0U0m1Mnt6zh6EzJPwfQBEcSoyHnSAk,2821 +ansible/plugins/lookup/flattened.pyc,, +ansible/plugins/lookup/grafana_dashboard.py,sha256=fk9ZB9buZfEsa_bImC2C9sti9VKMD2BYpTvuCDD2Mbs,6337 +ansible/plugins/lookup/grafana_dashboard.pyc,, +ansible/plugins/lookup/hashi_vault.py,sha256=upXwaq1wXOqc5f9GfDP07yt04RxpDh7ix2p7zu2EEog,8367 +ansible/plugins/lookup/hashi_vault.pyc,, +ansible/plugins/lookup/hiera.py,sha256=4ipJLnRqmzzYHj3ov66ceiqJeHUgsRKvsqzgDxPqBmk,2509 +ansible/plugins/lookup/hiera.pyc,, +ansible/plugins/lookup/indexed_items.py,sha256=AzuCxnWkEJYKbzH0zgMYnQP5D5CIZX2CKlBj6b5HRxY,1579 +ansible/plugins/lookup/indexed_items.pyc,, +ansible/plugins/lookup/ini.py,sha256=a59K_kX_bWy3MJ_pRgy7vJkAiWAZ4If_9z2TT6IaO9U,5319 +ansible/plugins/lookup/ini.pyc,, +ansible/plugins/lookup/inventory_hostnames.py,sha256=MvV39sK5L0B-dH8G2gSfxApfVgvQt4QvlK3-9zYXK9U,2276 +ansible/plugins/lookup/inventory_hostnames.pyc,, +ansible/plugins/lookup/items.py,sha256=SGiPmUvOqQ5H9wvkaZAU24xLCr9bT5YSFKX1xq8hBUs,1829 +ansible/plugins/lookup/items.pyc,, +ansible/plugins/lookup/k8s.py,sha256=iNUdvENoZQ9Dksp64Aq1sObao8AkobFLnawnbc9kGjg,11157 +ansible/plugins/lookup/k8s.pyc,, +ansible/plugins/lookup/keyring.py,sha256=3DX0qnNii-hpkjzHSc3mnAju3GmOE__J6mDvOc49BZQ,1968 +ansible/plugins/lookup/keyring.pyc,, +ansible/plugins/lookup/lastpass.py,sha256=GIvVMQSbFzlc9bavoLKJpzSTVJIZqiccfK0MpvJMePY,2927 +ansible/plugins/lookup/lastpass.pyc,, +ansible/plugins/lookup/lines.py,sha256=t91PsFIPWSW1RYGIUCe-ucDddNOJK9zo4P8bPWqBHM8,2140 +ansible/plugins/lookup/lines.pyc,, +ansible/plugins/lookup/list.py,sha256=Y7Mku-lxk7xEDqrKf-RkQy9jkDw1WJL9D4BgAnGxkI0,1088 +ansible/plugins/lookup/list.pyc,, +ansible/plugins/lookup/mongodb.py,sha256=DNuoNEPIZrgXTscP61bjxukZEgosBlnTcGNSOyVXjG8,8872 +ansible/plugins/lookup/mongodb.pyc,, +ansible/plugins/lookup/nested.py,sha256=HZEtNP7o01MikivZUhAX4ffr0E6yCUqBf0ZGFjZuFC8,2693 +ansible/plugins/lookup/nested.pyc,, +ansible/plugins/lookup/nios.py,sha256=lTIDWeGrUgpJyhP1e8nNhPvojvErfTBA9d0_QOe4r6o,4057 +ansible/plugins/lookup/nios.pyc,, +ansible/plugins/lookup/nios_next_ip.py,sha256=SJv7nae_e6DM3LW4lk532I3MSsLjr-ET0Qn6e89y2Lg,3461 +ansible/plugins/lookup/nios_next_ip.pyc,, +ansible/plugins/lookup/nios_next_network.py,sha256=OI7B0Jrj9F3QODDuFnFadCerrgQ8bFnGzbM_W2j_7wU,4174 +ansible/plugins/lookup/nios_next_network.pyc,, +ansible/plugins/lookup/onepassword.py,sha256=CDFFQaIO5OlOqYPXxPUSReO6xzpugwhkPeVvkuG4xhM,6138 +ansible/plugins/lookup/onepassword.pyc,, +ansible/plugins/lookup/onepassword_raw.py,sha256=ikyxNF33anljsRynImjsJsCF2xFhFXtSM7OSrRkExWU,2553 +ansible/plugins/lookup/onepassword_raw.pyc,, +ansible/plugins/lookup/password.py,sha256=KsfqIfBp5hxw79oyz649Y1pENFgGQ24eAVQ1GALw4B8,13578 +ansible/plugins/lookup/password.pyc,, +ansible/plugins/lookup/passwordstore.py,sha256=JABqn6ljvj1-hXKFLxvi29bP9FeX9M1kV-p47Jb9nFY,10563 +ansible/plugins/lookup/passwordstore.pyc,, +ansible/plugins/lookup/pipe.py,sha256=4lGl7hOuGUgvCdfUMEmTtyBrnrxhrG6wgC3Z92rNPr0,2325 +ansible/plugins/lookup/pipe.pyc,, +ansible/plugins/lookup/random_choice.py,sha256=PZB9thqki-h6enfTE7NAKXvaMfXVzss7WEwcQaY556I,1573 +ansible/plugins/lookup/random_choice.pyc,, +ansible/plugins/lookup/redis.py,sha256=NUZ8IqlG-p0HM939xIEkWiE-TjrBLXqyhsEVjFU5OtQ,3102 +ansible/plugins/lookup/redis.pyc,, +ansible/plugins/lookup/sequence.py,sha256=Ht8wQW7kNyhBz3lj6Io-Td1XpvbdvaNwnx6hGl4zHgE,8760 +ansible/plugins/lookup/sequence.pyc,, +ansible/plugins/lookup/shelvefile.py,sha256=_LTdHTZrMF22HlN6ZD7O3duKprHHNRkOWojkkSvvyLI,2835 +ansible/plugins/lookup/shelvefile.pyc,, +ansible/plugins/lookup/subelements.py,sha256=615J-2mjUab4nK5c7rW_73h9YUyC_708VU-oS4fa3wY,6157 +ansible/plugins/lookup/subelements.pyc,, +ansible/plugins/lookup/template.py,sha256=ptq_OaGpP-bUit5RYLEeHDRuKvT3Em7oUdCrxctRkNs,3824 +ansible/plugins/lookup/template.pyc,, +ansible/plugins/lookup/together.py,sha256=3G271eLVijueNemDeykjdx9yL9ehjxGsVZsiYlsFPOU,2152 +ansible/plugins/lookup/together.pyc,, +ansible/plugins/lookup/url.py,sha256=ZAFHPRZfIYuVrBkw1r5KkeLXa0bBE1rSb2LoATIoKWI,2929 +ansible/plugins/lookup/url.pyc,, +ansible/plugins/lookup/vars.py,sha256=9pBrC3SLgjUUWwZndU-YIw7dl9Be-ZL8i_hXNwT3zNk,3004 +ansible/plugins/lookup/vars.pyc,, +ansible/plugins/netconf/__init__.py,sha256=nNBvRXYgqPeZHrm7TiIwxt_Cg-X57RODaAIvagJeyus,16292 +ansible/plugins/netconf/__init__.pyc,, +ansible/plugins/netconf/ce.py,sha256=oSDYDj1HKKBB2-HzUmEQZSv85WGo22IWjBhDCVy14jA,7598 +ansible/plugins/netconf/ce.pyc,, +ansible/plugins/netconf/default.py,sha256=DUEiYOdSl6NiqwEOqfA90pWkrH2KKmkYBjhKQmxM_CQ,2030 +ansible/plugins/netconf/default.pyc,, +ansible/plugins/netconf/iosxr.py,sha256=UKLNQBu48RL2v3pk9RHVYM5VdQzu-7I787qKAnMJuHY,8166 +ansible/plugins/netconf/iosxr.pyc,, +ansible/plugins/netconf/junos.py,sha256=ilZ8_hbUy-mnxIvIIAg0UeHjcNhgQ7LB1dZd8bxoJYs,8304 +ansible/plugins/netconf/junos.pyc,, +ansible/plugins/netconf/sros.py,sha256=ygLsKuEpHaN0_CpN5g5B2hhFIaES2HhYplFxb4LLE7k,3919 +ansible/plugins/netconf/sros.pyc,, +ansible/plugins/shell/__init__.py,sha256=EyvwuO5IgMZ_7-0096VRY_DIwNN1FQ0yifNHNSMuMYc,8409 +ansible/plugins/shell/__init__.pyc,, +ansible/plugins/shell/csh.py,sha256=sPQ9FXbFgXAnSvDmBAKiRAuWY7bX5oL4wFcKcBGZqxw,1217 +ansible/plugins/shell/csh.pyc,, +ansible/plugins/shell/fish.py,sha256=CnOKG3T-STf_GX1pmpIT16CXs3wwICma7tS8Tx-_31U,4411 +ansible/plugins/shell/fish.pyc,, +ansible/plugins/shell/powershell.py,sha256=hoS-oDbPP8wKMIxZnCem_sp5amovBwzk7DJ873yTjvw,66457 +ansible/plugins/shell/powershell.pyc,, +ansible/plugins/shell/sh.py,sha256=wviw7cEd-jztmtp7C9MxiCRuArLe_yI3nP1hQdRxeKk,3951 +ansible/plugins/shell/sh.pyc,, +ansible/plugins/strategy/__init__.py,sha256=qz-EkR8B4sXh5cYzAR5KCQR7KefCv0d_ty1gGzn3iXI,56367 +ansible/plugins/strategy/__init__.pyc,, +ansible/plugins/strategy/debug.py,sha256=40_uUeWTTFfkpMAtqUYSjuz_H4zvWdbFWOZkie1zViM,1288 +ansible/plugins/strategy/debug.pyc,, +ansible/plugins/strategy/free.py,sha256=aJu9FvccjirAibNWRgZp-0JF1YKiL3JwteqpTA0Pxn4,12943 +ansible/plugins/strategy/free.pyc,, +ansible/plugins/strategy/host_pinned.py,sha256=-vQ_PcaO7kaOoTSmLu9iey3sfnfICA5KTMdFj5QS2cU,2030 +ansible/plugins/strategy/host_pinned.pyc,, +ansible/plugins/strategy/linear.py,sha256=qzz0q1YLG-Tm4Ja14ylPupn-NoTmMBMDUBX9Rb7fK9I,22642 +ansible/plugins/strategy/linear.pyc,, +ansible/plugins/terminal/__init__.py,sha256=2F3YCXGYb-SPfST62H5Ld8IAF8dwf00Mua2x-Iphaso,4365 +ansible/plugins/terminal/__init__.pyc,, +ansible/plugins/terminal/aireos.py,sha256=xL01k5eABRDiuaywzdKfKtyavz_uQuNkr7SgWugahFE,1999 +ansible/plugins/terminal/aireos.pyc,, +ansible/plugins/terminal/aruba.py,sha256=u2KQjGageh_PsUFTfE5OQkNVAAEDyC7QqbDEOzvu5ms,2315 +ansible/plugins/terminal/aruba.pyc,, +ansible/plugins/terminal/asa.py,sha256=DVh5zdGGLcXI5n33gAFBgS8yNjFKA4fPLeI9OZLC6eQ,2414 +ansible/plugins/terminal/asa.pyc,, +ansible/plugins/terminal/bigip.py,sha256=zdQB7W5LCkhV7LRRktH8SJQseH9zW1vs7T_CKOvwwo0,2499 +ansible/plugins/terminal/bigip.pyc,, +ansible/plugins/terminal/ce.py,sha256=WgrWAjYMOPl6lW3IGXEvYom8NNyrO-wzhYbFshCeAy4,1841 +ansible/plugins/terminal/ce.pyc,, +ansible/plugins/terminal/cnos.py,sha256=eczQqc8IALjheZni46RYmu6dcd6jjTwm3fLKvfrN6bc,2824 +ansible/plugins/terminal/cnos.pyc,, +ansible/plugins/terminal/dellos10.py,sha256=7xm3y1hL26UpD4fVmAQXag5xUWfuLZcV47A9ax9_dbA,2767 +ansible/plugins/terminal/dellos10.pyc,, +ansible/plugins/terminal/dellos6.py,sha256=cwQC4WKeGsyf1yLkM6q6s47H6q4_U30UitR_qc1XT-E,3165 +ansible/plugins/terminal/dellos6.pyc,, +ansible/plugins/terminal/dellos9.py,sha256=r8_4f6B1UzTIW9EzN4FLiJUEEQfavz21UIimnMsqsOA,2774 +ansible/plugins/terminal/dellos9.pyc,, +ansible/plugins/terminal/edgeos.py,sha256=AOgljY2mCHT_1pSwdO2FrEfa0_U-2Wmdzu-aO-cMdVw,1126 +ansible/plugins/terminal/edgeos.pyc,, +ansible/plugins/terminal/enos.py,sha256=36woKHSt9pVXP7mGh93KJVkAVTi8BIKzZi1LcMkM31U,2824 +ansible/plugins/terminal/enos.pyc,, +ansible/plugins/terminal/eos.py,sha256=cjPfcspjgbkvEFOWKDlYA3grDfscthMSkJGtXA0Esyw,3523 +ansible/plugins/terminal/eos.pyc,, +ansible/plugins/terminal/exos.py,sha256=ejJZAFMmaKigfAWBIloafaljCv4Sbzr2TzeFKi0Wt-M,2026 +ansible/plugins/terminal/exos.pyc,, +ansible/plugins/terminal/ios.py,sha256=yoe2ywwraSxvX49lVzXYymwv1Za4sk5JV3LBjyc_E1U,3572 +ansible/plugins/terminal/ios.pyc,, +ansible/plugins/terminal/iosxr.py,sha256=MQ6jSuV4x205J3Zl1cvFLKLd0NdY56mhsGKhgUCEmOw,1882 +ansible/plugins/terminal/iosxr.pyc,, +ansible/plugins/terminal/ironware.py,sha256=lbZBkUSiuFB5NLF36yZxGMR9mi8FGEbRarT1a7hqzBE,2697 +ansible/plugins/terminal/ironware.pyc,, +ansible/plugins/terminal/junos.py,sha256=4o2BSJwEFyR6eIYu2W0l8NEvQAGGcN1wqdTPLbyZckY,1833 +ansible/plugins/terminal/junos.pyc,, +ansible/plugins/terminal/nos.py,sha256=NZdfv-nLGn2xxXzvDBfBHIvOGnySMfqdxhmBHJM9peE,1962 +ansible/plugins/terminal/nos.pyc,, +ansible/plugins/terminal/nxos.py,sha256=FcEz07RnhkwJ51IH7oS66RfdSwWAKl3UBlcOkAI0YVk,3851 +ansible/plugins/terminal/nxos.pyc,, +ansible/plugins/terminal/onyx.py,sha256=i35jcDQlYvvJTqKN45jaonrIhbqjFifmW7u6cc10-dk,2656 +ansible/plugins/terminal/onyx.pyc,, +ansible/plugins/terminal/routeros.py,sha256=VNvNj_pcBV1S_w_WuDUvBMnCsXl2HeN4cdZ5wMIs0x0,2250 +ansible/plugins/terminal/routeros.pyc,, +ansible/plugins/terminal/slxos.py,sha256=NZdfv-nLGn2xxXzvDBfBHIvOGnySMfqdxhmBHJM9peE,1962 +ansible/plugins/terminal/slxos.pyc,, +ansible/plugins/terminal/sros.py,sha256=FPhCwlzB7Z9jimFBBu2ubjclCptvt-28r1eIrrp12kQ,1393 +ansible/plugins/terminal/sros.pyc,, +ansible/plugins/terminal/voss.py,sha256=zP3sXV5n1rXzixEOBhs8NNB6S9vQghe6cOYj_rsKugE,3455 +ansible/plugins/terminal/voss.pyc,, +ansible/plugins/terminal/vyos.py,sha256=AFZv_utb8rW0fI3DorZ8_Ky00camFfTvdb5vzDPtEz4,1700 +ansible/plugins/terminal/vyos.pyc,, +ansible/plugins/test/__init__.py,sha256=9gBS3ZO7DXC3ydwDfYXbwZBht33NF0GDN1sWv7WxrWY,119 +ansible/plugins/test/__init__.pyc,, +ansible/plugins/test/core.py,sha256=kvhDgmJ9q6zHmlkSzla6ilC-CIVcEMbtpFJ91QUewjc,6592 +ansible/plugins/test/core.pyc,, +ansible/plugins/test/files.py,sha256=su5uuYHtZMRi-b4Om5TQnCu5znxfIRTVT9mN4NGnVVQ,1518 +ansible/plugins/test/files.pyc,, +ansible/plugins/test/mathstuff.py,sha256=85mherdvP3qe52oNo1zu4Csb9i9LW-fAGnCgXJAj9kk,1327 +ansible/plugins/test/mathstuff.pyc,, +ansible/plugins/vars/__init__.py,sha256=TYq9MH4JcpHz6BE-SiJ-sp-2dPaERdEev5PbXgmhC78,1329 +ansible/plugins/vars/__init__.pyc,, +ansible/plugins/vars/host_group_vars.py,sha256=WT2JtH7pDZCDmIu1AaWprwlaJSEW5y08GiTt3RzZB9U,4381 +ansible/plugins/vars/host_group_vars.pyc,, +ansible/release.py,sha256=BvqgWy384Uqith-wKCG7ZAzlKIRdcyvMea2VUocOxTI,916 +ansible/release.pyc,, +ansible/template/__init__.py,sha256=k1XS3wwURi1LA9X3CfSg73ddjL8MFETvqXK9CN8wXV0,32703 +ansible/template/__init__.pyc,, +ansible/template/native_helpers.py,sha256=kDwxSldTy6-0XHLKTsYWPW59zu88ztEKNs3PVuL9La0,2319 +ansible/template/native_helpers.pyc,, +ansible/template/safe_eval.py,sha256=_925WA7x7bzbjp_x6nPZ3EebpQf0fOwVuC2ldqweiPw,4921 +ansible/template/safe_eval.pyc,, +ansible/template/template.py,sha256=UDUSBILbwGrMZSTsWPxs7tkyYXQkOw9K9N0Kr5pYzfI,1632 +ansible/template/template.pyc,, +ansible/template/vars.py,sha256=OxkqjDjbQC4pRqY9TzmwMYXHiIsdXFyGE4waC9xwGcI,4941 +ansible/template/vars.pyc,, +ansible/utils/__init__.py,sha256=1lMXN1i2fFqslda4BmeI5tpYMFP95D5Wpr1AjDJi-SQ,833 +ansible/utils/__init__.pyc,, +ansible/utils/cmd_functions.py,sha256=U88iuZWLvL_ZIRA5rt0dv-mP4E05uURCe36wkdXlZdg,2793 +ansible/utils/cmd_functions.pyc,, +ansible/utils/color.py,sha256=3pE6FMJx2vrUEov0FlXEcMODWYr-X3t28Limf7WdDKE,3893 +ansible/utils/color.pyc,, +ansible/utils/display.py,sha256=5wvJdiwQSmYX77tdSMz7ALnt5XHhB8s_tMzOZ31iazk,12706 +ansible/utils/display.pyc,, +ansible/utils/encrypt.py,sha256=Qov2XPWYBc2SLr9Me0lw9aHny89w3Soa_9TYB0VKa_Y,7605 +ansible/utils/encrypt.pyc,, +ansible/utils/hashing.py,sha256=26goW0qla950Ke8elwuxeV7U_cuHHE9TVDrdc7CulZs,3181 +ansible/utils/hashing.pyc,, +ansible/utils/helpers.py,sha256=llgy3pUDBmblMuv7WII48GCpxP5-oA3OHsYLOjA7el0,1614 +ansible/utils/helpers.pyc,, +ansible/utils/jsonrpc.py,sha256=Cwoh_jA8VKnuYx3WaZbS9dl3bRPJETXHmCitLXA0sJs,3213 +ansible/utils/jsonrpc.pyc,, +ansible/utils/listify.py,sha256=JteOXHkWtvSAoRrenkkYYhojNpTeoRmcRDs2tv7-O7w,1462 +ansible/utils/listify.pyc,, +ansible/utils/module_docs_fragments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/utils/module_docs_fragments/__init__.pyc,, +ansible/utils/module_docs_fragments/a10.py,sha256=TlaiONS8g-TlVlumyUs59D1ZaWc-zBdKxCrzR9dNnEo,1845 +ansible/utils/module_docs_fragments/a10.pyc,, +ansible/utils/module_docs_fragments/aci.py,sha256=j0byYGoXuH2eaMf0ne2YnfzdsLCVYEE7xRLQoh9urvg,2904 +ansible/utils/module_docs_fragments/aci.pyc,, +ansible/utils/module_docs_fragments/acme.py,sha256=h6wZt9keP2hG_Fdfp10W17gWT4GMDha-eDlWe48V2_E,4739 +ansible/utils/module_docs_fragments/acme.pyc,, +ansible/utils/module_docs_fragments/aireos.py,sha256=NSFdG01QRAWcSxf7eotubsXTCuAEsrKGeq9lqo5vetg,2702 +ansible/utils/module_docs_fragments/aireos.pyc,, +ansible/utils/module_docs_fragments/aruba.py,sha256=NSFdG01QRAWcSxf7eotubsXTCuAEsrKGeq9lqo5vetg,2702 +ansible/utils/module_docs_fragments/aruba.pyc,, +ansible/utils/module_docs_fragments/asa.py,sha256=GejU4bmYn38OHav_Mek8gMYg1z-tFv8_99akUjonF5I,4785 +ansible/utils/module_docs_fragments/asa.pyc,, +ansible/utils/module_docs_fragments/auth_basic.py,sha256=tthyFKfDyZPxi1lilEkaLCemHRJhAkUNzlYG5ZNLkLw,1180 +ansible/utils/module_docs_fragments/auth_basic.pyc,, +ansible/utils/module_docs_fragments/avi.py,sha256=H7iHqFXSbirSZFx7IVeivXCUcs3pK-GyAyrJCSLZOYA,2345 +ansible/utils/module_docs_fragments/avi.pyc,, +ansible/utils/module_docs_fragments/aws.py,sha256=9tOZPXvNncUwlzTOe2QNlUWv3vT3sccDq1nz8wBq6JE,2898 +ansible/utils/module_docs_fragments/aws.pyc,, +ansible/utils/module_docs_fragments/aws_credentials.py,sha256=R8blCts6F0bcCwcC4jBxL1fAm2rJU5TVdQnkhOmORKk,1061 +ansible/utils/module_docs_fragments/aws_credentials.pyc,, +ansible/utils/module_docs_fragments/azure.py,sha256=CKi81BPkzaJTOC5tfO3Lr9k64iXcyq1D0poejYBR9yk,5440 +ansible/utils/module_docs_fragments/azure.pyc,, +ansible/utils/module_docs_fragments/azure_tags.py,sha256=EBJYq9S-KLbKufYUUUv89kFmgP75ppGrwJj_82gINX4,1420 +ansible/utils/module_docs_fragments/azure_tags.pyc,, +ansible/utils/module_docs_fragments/backup.py,sha256=2poCfiKg_O1AvQa4QjFNW3zcFU7J-i2O6OwuOFF-EA8,1071 +ansible/utils/module_docs_fragments/backup.pyc,, +ansible/utils/module_docs_fragments/ce.py,sha256=l1e0IaCTTV-p9wguzZoNkMktoGGMhKrgO-lO8GtR0ds,2821 +ansible/utils/module_docs_fragments/ce.pyc,, +ansible/utils/module_docs_fragments/cloudstack.py,sha256=hSZwh4jXI_02x3mbfMFs6REELLjX7g9iDapJD1Kys_o,2922 +ansible/utils/module_docs_fragments/cloudstack.pyc,, +ansible/utils/module_docs_fragments/cnos.py,sha256=qR1BzmFTF40h4FQkTRBgLYyRopfJYlSN5Juvy-5fySc,3747 +ansible/utils/module_docs_fragments/cnos.pyc,, +ansible/utils/module_docs_fragments/constructed.py,sha256=Vd0uylQGOneTNuYpXEl-Q36l5vCwJedBy7wCQVzLAKE,826 +ansible/utils/module_docs_fragments/constructed.pyc,, +ansible/utils/module_docs_fragments/decrypt.py,sha256=zdgC76KMh9WdGODIsazmobMmd-reUF2OZCup85AHHXY,999 +ansible/utils/module_docs_fragments/decrypt.pyc,, +ansible/utils/module_docs_fragments/default_callback.py,sha256=mQRpEcdZULe8m76bTch1LvM1ApKmvJ2HJ1Wbbg96jPc,1589 +ansible/utils/module_docs_fragments/default_callback.pyc,, +ansible/utils/module_docs_fragments/dellos10.py,sha256=-kASOcXxmJweX5dRXjKF4vIHvc22MMWU-I2tJNoMdmk,2551 +ansible/utils/module_docs_fragments/dellos10.pyc,, +ansible/utils/module_docs_fragments/dellos6.py,sha256=-kASOcXxmJweX5dRXjKF4vIHvc22MMWU-I2tJNoMdmk,2551 +ansible/utils/module_docs_fragments/dellos6.pyc,, +ansible/utils/module_docs_fragments/dellos9.py,sha256=-kASOcXxmJweX5dRXjKF4vIHvc22MMWU-I2tJNoMdmk,2551 +ansible/utils/module_docs_fragments/dellos9.pyc,, +ansible/utils/module_docs_fragments/digital_ocean.py,sha256=aW35ak1Wx6nQlBhY2dKRXT7Vhw2hA8bGdZDpyPx6JII,946 +ansible/utils/module_docs_fragments/digital_ocean.pyc,, +ansible/utils/module_docs_fragments/dimensiondata.py,sha256=oMVlMzzVXZMJjnwLTh2N9EjBqsQMvy8HJ52rm1IbgU8,2098 +ansible/utils/module_docs_fragments/dimensiondata.pyc,, +ansible/utils/module_docs_fragments/dimensiondata_wait.py,sha256=GIJ3zkZ1xZv5GRxYlb39tGig9caeysHpY5bZqk5W2d4,1429 +ansible/utils/module_docs_fragments/dimensiondata_wait.pyc,, +ansible/utils/module_docs_fragments/docker.py,sha256=rrxKmYo5493pJ3vbo_6l6pjSWcrJ6P_Bm5Fii5SBcqQ,6115 +ansible/utils/module_docs_fragments/docker.pyc,, +ansible/utils/module_docs_fragments/ec2.py,sha256=kHKwpOI8K1VLu9knfO1aoWA9pDXePe49RPWZf7mowNA,1119 +ansible/utils/module_docs_fragments/ec2.pyc,, +ansible/utils/module_docs_fragments/emc.py,sha256=SDv_H302qumql5b_GFsR6q-Vh-jaa9VFKftzd5YUk6Y,1140 +ansible/utils/module_docs_fragments/emc.pyc,, +ansible/utils/module_docs_fragments/enos.py,sha256=k4UnRaJa-C-VyMqzHIR0THXjBUs81MCBO6-eU91tT74,3949 +ansible/utils/module_docs_fragments/enos.pyc,, +ansible/utils/module_docs_fragments/eos.py,sha256=tyfFm4bPGJteISs3tfQAVgiZzDCP07mhnQLUVHNcLuw,6957 +ansible/utils/module_docs_fragments/eos.pyc,, +ansible/utils/module_docs_fragments/exoscale.py,sha256=KoSAoRuWHxdZyxKh39eNttBPboHqrmJUtSKkYRfshCI,2085 +ansible/utils/module_docs_fragments/exoscale.pyc,, +ansible/utils/module_docs_fragments/f5.py,sha256=4mipzFo2E7u_RbkTQHsIvJoPFtUll4QTihjPLtEHSsU,4818 +ansible/utils/module_docs_fragments/f5.pyc,, +ansible/utils/module_docs_fragments/files.py,sha256=FP0yYTb0s7eAtBTe_GrT2q349RbCb4rlHgINQZjjW6I,3701 +ansible/utils/module_docs_fragments/files.pyc,, +ansible/utils/module_docs_fragments/fortios.py,sha256=5CcxEnvCZUSW-laZkk4z_m8xSwXD3a58uDy4-Ya0Ero,2295 +ansible/utils/module_docs_fragments/fortios.pyc,, +ansible/utils/module_docs_fragments/gcp.py,sha256=X9Bsu72aAEeouX3fP4JLqQz34STrsbJvJSfp2Mo-cBM,1522 +ansible/utils/module_docs_fragments/gcp.pyc,, +ansible/utils/module_docs_fragments/ibm_storage.py,sha256=nEVMosjeqmJtLrRUZ4rWHMQpYDUtXqdE7mKsMHk_4mk,941 +ansible/utils/module_docs_fragments/ibm_storage.pyc,, +ansible/utils/module_docs_fragments/infinibox.py,sha256=Zj5feE52aD1sy4C-oX_xXZ3Mud5rZImEhf4N4zJ3m3Q,1564 +ansible/utils/module_docs_fragments/infinibox.pyc,, +ansible/utils/module_docs_fragments/influxdb.py,sha256=hsVqPhdMiyu1z_OSCCNmonObRsdWnebesJHhhr9dMWo,1983 +ansible/utils/module_docs_fragments/influxdb.pyc,, +ansible/utils/module_docs_fragments/inventory_cache.py,sha256=Pla3v1oyeAw_fW5ehqBHzPC2shJAEMnQQ6GE8goPBDU,1175 +ansible/utils/module_docs_fragments/inventory_cache.pyc,, +ansible/utils/module_docs_fragments/ios.py,sha256=X0BhlldKSG5uhwFd2D4aN9jBsD_9cBCAxOr8L5VfA1A,5333 +ansible/utils/module_docs_fragments/ios.pyc,, +ansible/utils/module_docs_fragments/iosxr.py,sha256=AoXvainpsLidO5bhQS8sZdSBckmlXiC5PTzhj6fbXGQ,3361 +ansible/utils/module_docs_fragments/iosxr.pyc,, +ansible/utils/module_docs_fragments/ipa.py,sha256=gjrTvQVwpgmURX5y7MO8IJL75wCnO5s0Qc4QQopQeUU,3121 +ansible/utils/module_docs_fragments/ipa.pyc,, +ansible/utils/module_docs_fragments/ironware.py,sha256=jhrrEMBX-SkE1cJPnJ5p6tKDdSCYUOj9Xz8w44LABME,4524 +ansible/utils/module_docs_fragments/ironware.pyc,, +ansible/utils/module_docs_fragments/junos.py,sha256=Fy2pD9w8cIt5YDCV-GL1XORAsZaEfNVwr7Ww6zS38rI,3516 +ansible/utils/module_docs_fragments/junos.pyc,, +ansible/utils/module_docs_fragments/k8s_auth_options.py,sha256=Q4lUCMTuku6CEV9_EwkdxHgLIgejsz881boVZWd0X48,3115 +ansible/utils/module_docs_fragments/k8s_auth_options.pyc,, +ansible/utils/module_docs_fragments/k8s_name_options.py,sha256=EF_N-ulbh3JYRt9C57_GvqCQUOCTOtf2PBD2GDyDiE4,2450 +ansible/utils/module_docs_fragments/k8s_name_options.pyc,, +ansible/utils/module_docs_fragments/k8s_resource_options.py,sha256=F-11YL6e2eZweepMg2pSvgxkdZSFuzibfFSDwPBvZzw,1787 +ansible/utils/module_docs_fragments/k8s_resource_options.pyc,, +ansible/utils/module_docs_fragments/k8s_scale_options.py,sha256=ByOMGkIEd6KzukeYDq8msveUk1Y1FyPCHrozDIhRwVI,1832 +ansible/utils/module_docs_fragments/k8s_scale_options.pyc,, +ansible/utils/module_docs_fragments/k8s_state_options.py,sha256=3q1LbYK4Ym-sszMAtsYykKBuZrfKNNuhXfcUItxdkQo,1411 +ansible/utils/module_docs_fragments/k8s_state_options.pyc,, +ansible/utils/module_docs_fragments/keycloak.py,sha256=BoZ9VVs9ZtAirRsT1uQmo3_VT4k8sRINwgpFhBL4hjc,1868 +ansible/utils/module_docs_fragments/keycloak.pyc,, +ansible/utils/module_docs_fragments/ldap.py,sha256=j2stKKDDytBRj0o8bp-rbBuoKmy678JqDljsN35-_jQ,1334 +ansible/utils/module_docs_fragments/ldap.pyc,, +ansible/utils/module_docs_fragments/manageiq.py,sha256=r-Wq3yKJX-FpR4577uMfxowW3AoRKuBr7absa0sebFE,1378 +ansible/utils/module_docs_fragments/manageiq.pyc,, +ansible/utils/module_docs_fragments/meraki.py,sha256=frPoQDxXRMhMCYkjAVu_yaNMDfjJU2rOrRkds0PmT6c,1763 +ansible/utils/module_docs_fragments/meraki.pyc,, +ansible/utils/module_docs_fragments/mysql.py,sha256=ayEiBai3cPTKVro9ghjQbwBjLf1RfyOvB2DqlF3EqRE,2727 +ansible/utils/module_docs_fragments/mysql.pyc,, +ansible/utils/module_docs_fragments/netapp.py,sha256=2_V8YLWbj3SMUM296hUoxkAP0pzgP_C8aKfr7qQ2h_w,5701 +ansible/utils/module_docs_fragments/netapp.pyc,, +ansible/utils/module_docs_fragments/netconf.py,sha256=eptS55-DgVT27O4Cp1as_RRmA84yxx9W3JTWkbQheQI,3145 +ansible/utils/module_docs_fragments/netconf.pyc,, +ansible/utils/module_docs_fragments/netscaler.py,sha256=be5qjTNMT6HRwU8Mmr4Bzh1YKBppCbpYsoJ_sqpqRzw,1992 +ansible/utils/module_docs_fragments/netscaler.pyc,, +ansible/utils/module_docs_fragments/nios.py,sha256=BYTDoGFiI8N20rNrPefrgs3ctaXAc1lfl1-Z01NCT3o,3302 +ansible/utils/module_docs_fragments/nios.pyc,, +ansible/utils/module_docs_fragments/nso.py,sha256=qhILZEkr1gYsZuaWjxh1UpA8P70PlQX9sWLREYXe0zY,1123 +ansible/utils/module_docs_fragments/nso.pyc,, +ansible/utils/module_docs_fragments/nxos.py,sha256=tAr504n9U2yUEzpF-6shgtSlBe3CqzHxpudfXLBmzSo,5759 +ansible/utils/module_docs_fragments/nxos.pyc,, +ansible/utils/module_docs_fragments/oneview.py,sha256=pewBk6X_NAGIlOxMBWjRPNYgnHJPXBXOrPnFBVpyek0,2873 +ansible/utils/module_docs_fragments/oneview.pyc,, +ansible/utils/module_docs_fragments/online.py,sha256=J_o_9r3KVpitjosQOg82oWh90XKEvAGb_OplCjpzQKs,1084 +ansible/utils/module_docs_fragments/online.pyc,, +ansible/utils/module_docs_fragments/onyx.py,sha256=UhLPG8PQVvIWoypBzG_GyRitTNC20SJNcTO4HBLkErk,3458 +ansible/utils/module_docs_fragments/onyx.pyc,, +ansible/utils/module_docs_fragments/opennebula.py,sha256=wacI2FCx7A_tMUGIy22jqq5uZL_BTs8pKY2mH6bKrxY,1345 +ansible/utils/module_docs_fragments/opennebula.pyc,, +ansible/utils/module_docs_fragments/openstack.py,sha256=JSd-o3oUjWFBiOJ_xGpv3cItE73Gz9n0wDxeAUEMDwU,4172 +ansible/utils/module_docs_fragments/openstack.pyc,, +ansible/utils/module_docs_fragments/openswitch.py,sha256=Uy_5nYTtwagK10sO_OYfY-TC0y9N0JQVscZveoWdedI,3815 +ansible/utils/module_docs_fragments/openswitch.pyc,, +ansible/utils/module_docs_fragments/ovirt.py,sha256=HD8_CAMUqtipGykNo0W-oeBOcq0jJM0MjIOGQtmvsSY,4068 +ansible/utils/module_docs_fragments/ovirt.pyc,, +ansible/utils/module_docs_fragments/ovirt_facts.py,sha256=Jt8ZOZRGEpn2tp9-2WUGXCRLrgpHpQhISp5kaxOPSWQ,3556 +ansible/utils/module_docs_fragments/ovirt_facts.pyc,, +ansible/utils/module_docs_fragments/panos.py,sha256=o1MyPdr6KOaitMh-Ece4W2DmmBRBc1pmP-HbK4UZvJ4,669 +ansible/utils/module_docs_fragments/panos.pyc,, +ansible/utils/module_docs_fragments/postgres.py,sha256=ZmhQcaxaa7m4MwzQJIR354vQtv7dC7EXC8IU697T_no,2562 +ansible/utils/module_docs_fragments/postgres.pyc,, +ansible/utils/module_docs_fragments/proxysql.py,sha256=HIvxrhzV4L8_VjP0YQhVjbgqESH-XnN85arEU_MNSCU,1293 +ansible/utils/module_docs_fragments/proxysql.pyc,, +ansible/utils/module_docs_fragments/purestorage.py,sha256=wcAA3wEbYkYjxXk2trHiDFw7F8DQYN7rw2Y0ryKXIOk,2091 +ansible/utils/module_docs_fragments/purestorage.pyc,, +ansible/utils/module_docs_fragments/rackspace.py,sha256=1qvbhVJq1R7XIset9RSEoogtr4Ahdyxc7z1gtFpjLUc,4170 +ansible/utils/module_docs_fragments/rackspace.pyc,, +ansible/utils/module_docs_fragments/return_common.py,sha256=rl5vZ4dlMibVrg_SqdlObChUG3yZK7Dpqd3WvySePDo,1591 +ansible/utils/module_docs_fragments/return_common.pyc,, +ansible/utils/module_docs_fragments/scaleway.py,sha256=cixz_O9GQ8RdyZfwxfoPV-D4jLxo3reh51WY-WTHGUk,1135 +ansible/utils/module_docs_fragments/scaleway.pyc,, +ansible/utils/module_docs_fragments/shell_common.py,sha256=l2QHwrSxqFtJGnFiwj7v6rG00VubsL3DzHdrrpbeDxc,1833 +ansible/utils/module_docs_fragments/shell_common.pyc,, +ansible/utils/module_docs_fragments/sros.py,sha256=1SGVj2KeFujo4843v9kx1K7gMlcfc2VDvLu5l3Kpx4o,2847 +ansible/utils/module_docs_fragments/sros.pyc,, +ansible/utils/module_docs_fragments/tower.py,sha256=FL_08Mbd7k7gVqrl0-hEpOUtA4gigoQu01pei-fiM9M,1791 +ansible/utils/module_docs_fragments/tower.pyc,, +ansible/utils/module_docs_fragments/ucs.py,sha256=JJ-aMDajNycyrwKuNsMCIqT0bO4KXyDWV6brwHYayVY,2722 +ansible/utils/module_docs_fragments/ucs.pyc,, +ansible/utils/module_docs_fragments/url.py,sha256=ulZUhgUpu4jNSNurqJjnRTqM6xL9RHA3BaGzz3jhcpQ,2627 +ansible/utils/module_docs_fragments/url.pyc,, +ansible/utils/module_docs_fragments/validate.py,sha256=_QSzv4T479WnTXtbQOsBw5gONVOgMGtIYJh-oQg7m8k,1104 +ansible/utils/module_docs_fragments/validate.pyc,, +ansible/utils/module_docs_fragments/vca.py,sha256=lSivv1EyiPBc1bTaWn1h0sLq2I6WVOtmPFSt1tKxJV8,2295 +ansible/utils/module_docs_fragments/vca.pyc,, +ansible/utils/module_docs_fragments/vmware.py,sha256=fk8BDD_EbSH4gS_k1hrAK1kMFMZEbtpuX4nz3OEfpRM,2053 +ansible/utils/module_docs_fragments/vmware.pyc,, +ansible/utils/module_docs_fragments/vmware_rest_client.py,sha256=A-TqTrvxcNcJQuQEgfMDZ5l5MyWjMiqKRG-ui__nPLk,1500 +ansible/utils/module_docs_fragments/vmware_rest_client.pyc,, +ansible/utils/module_docs_fragments/vultr.py,sha256=0Jir6a_sXIkW8R1Ir6im6frN73P_gCMvhrNWzA17zLQ,1510 +ansible/utils/module_docs_fragments/vultr.pyc,, +ansible/utils/module_docs_fragments/vyos.py,sha256=Rnzi6sPDcQ1HeawqwDB3n4LsdNgTXF8LEH_BMca447o,3118 +ansible/utils/module_docs_fragments/vyos.pyc,, +ansible/utils/module_docs_fragments/zabbix.py,sha256=Mn2jd26a_Bkks8R4VBNgg-66m9EFWcIBLV3aKPSXHaw,1772 +ansible/utils/module_docs_fragments/zabbix.pyc,, +ansible/utils/path.py,sha256=hO7vC23MrJcPFqQ4izY4-X5WGEpWUnzJk96DKf7jtqg,3613 +ansible/utils/path.pyc,, +ansible/utils/plugin_docs.py,sha256=8DJYZAf8iTTQuOaDHsj5sH4c_ZUH6JMpFx6LQc4VU-Q,4834 +ansible/utils/plugin_docs.pyc,, +ansible/utils/py3compat.py,sha256=mjzzCd8spTTwjRUxetKvvKrKp1iBKZnEou2e_HMTWRY,2161 +ansible/utils/py3compat.pyc,, +ansible/utils/shlex.py,sha256=OMoMe9Kd5Ck3LLiiL87OixmYt4Qf3hpiphseg6rwX1Q,1279 +ansible/utils/shlex.pyc,, +ansible/utils/ssh_functions.py,sha256=E6oj1ZrTfM2cIMV_FkCcZcwD71k6PptgMrcXGVZHXQA,1600 +ansible/utils/ssh_functions.pyc,, +ansible/utils/unicode.py,sha256=cIJT9lBHYZz-UI4j51MYGhQjtS_wmPI8lysCrIqmOBQ,1166 +ansible/utils/unicode.pyc,, +ansible/utils/unsafe_proxy.py,sha256=fYF7ZS1o2e1C0LKHzFvs62CcCWUVRidCA_GPogv9U7k,4212 +ansible/utils/unsafe_proxy.pyc,, +ansible/utils/vars.py,sha256=U77pC-j2aEu-_eD3U7L5UTW101YpQh6BxQa95_vNi9I,5792 +ansible/utils/vars.pyc,, +ansible/vars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +ansible/vars/__init__.pyc,, +ansible/vars/clean.py,sha256=LwyGhdqIOBDWWQ3mhtCFq_CxE8nQtEZCxf7eyHVerDA,5760 +ansible/vars/clean.pyc,, +ansible/vars/hostvars.py,sha256=WAH_Yh2iKdmPSWyYTZvIlJd2ZG3aACMNesEnHpRPlks,4327 +ansible/vars/hostvars.pyc,, +ansible/vars/manager.py,sha256=0xbWix4tVbgcpdQM9ggIt1bR81phz3OZpLA2iaY6hSc,31302 +ansible/vars/manager.pyc,, +ansible/vars/reserved.py,sha256=SghtxVoafO6qk6xLnbbaKCG-vRro5sWm4sx8EJ_SfRA,2591 +ansible/vars/reserved.pyc,, +ansible/vars/unsafe_proxy.py,sha256=RLARkRNllEYtU3Nely-EPkl0CrtcOqAALeiO9THenik,1242 +ansible/vars/unsafe_proxy.pyc,, diff --git a/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/WHEEL b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/WHEEL new file mode 100644 index 0000000..5d26497 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.33.1) +Root-Is-Purelib: true +Tag: cp27-none-any + diff --git a/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/top_level.txt b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/top_level.txt new file mode 100644 index 0000000..90d4055 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-2.7.10.dist-info/top_level.txt @@ -0,0 +1 @@ +ansible diff --git a/env_27/lib/python2.7/site-packages/ansible-later.egg-link b/env_27/lib/python2.7/site-packages/ansible-later.egg-link new file mode 100644 index 0000000..08e2afc --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible-later.egg-link @@ -0,0 +1,2 @@ +/Users/rkau2905/Devel/python/private/ansible-later +. \ No newline at end of file diff --git a/env_27/lib/python2.7/site-packages/ansible/__init__.py b/env_27/lib/python2.7/site-packages/ansible/__init__.py new file mode 100644 index 0000000..d8aeac5 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/__init__.py @@ -0,0 +1,28 @@ +# (c) 2012-2014, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +# Note: Do not add any code to this file. The ansible module may be +# a namespace package when using Ansible-2.1+ Anything in this file may not be +# available if one of the other packages in the namespace is loaded first. +# +# This is for backwards compat. Code should be ported to get these from +# ansible.release instead of from here. +from ansible.release import __version__, __author__ diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/__init__.py b/env_27/lib/python2.7/site-packages/ansible/cli/__init__.py new file mode 100644 index 0000000..86d2480 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/__init__.py @@ -0,0 +1,820 @@ +# (c) 2012-2014, Michael DeHaan +# (c) 2016, Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import getpass +import operator +import optparse +import os +import subprocess +import re +import sys +import time +import yaml + +from abc import ABCMeta, abstractmethod + +import ansible +from ansible import constants as C +from ansible.errors import AnsibleOptionsError, AnsibleError +from ansible.inventory.manager import InventoryManager +from ansible.module_utils.six import with_metaclass, string_types +from ansible.module_utils._text import to_bytes, to_text +from ansible.parsing.dataloader import DataLoader +from ansible.release import __version__ +from ansible.utils.path import unfrackpath +from ansible.utils.vars import load_extra_vars, load_options_vars +from ansible.vars.manager import VariableManager +from ansible.parsing.vault import PromptVaultSecret, get_file_vault_secret + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class SortedOptParser(optparse.OptionParser): + '''Optparser which sorts the options by opt before outputting --help''' + + def format_help(self, formatter=None, epilog=None): + self.option_list.sort(key=operator.methodcaller('get_opt_string')) + return optparse.OptionParser.format_help(self, formatter=None) + + +# Note: Inherit from SortedOptParser so that we get our format_help method +class InvalidOptsParser(SortedOptParser): + '''Ignore invalid options. + + Meant for the special case where we need to take care of help and version + but may not know the full range of options yet. (See it in use in set_action) + ''' + def __init__(self, parser): + # Since this is special purposed to just handle help and version, we + # take a pre-existing option parser here and set our options from + # that. This allows us to give accurate help based on the given + # option parser. + SortedOptParser.__init__(self, usage=parser.usage, + option_list=parser.option_list, + option_class=parser.option_class, + conflict_handler=parser.conflict_handler, + description=parser.description, + formatter=parser.formatter, + add_help_option=False, + prog=parser.prog, + epilog=parser.epilog) + self.version = parser.version + + def _process_long_opt(self, rargs, values): + try: + optparse.OptionParser._process_long_opt(self, rargs, values) + except optparse.BadOptionError: + pass + + def _process_short_opts(self, rargs, values): + try: + optparse.OptionParser._process_short_opts(self, rargs, values) + except optparse.BadOptionError: + pass + + +class CLI(with_metaclass(ABCMeta, object)): + ''' code behind bin/ansible* programs ''' + + VALID_ACTIONS = [] + + _ITALIC = re.compile(r"I\(([^)]+)\)") + _BOLD = re.compile(r"B\(([^)]+)\)") + _MODULE = re.compile(r"M\(([^)]+)\)") + _URL = re.compile(r"U\(([^)]+)\)") + _CONST = re.compile(r"C\(([^)]+)\)") + + PAGER = 'less' + + # -F (quit-if-one-screen) -R (allow raw ansi control chars) + # -S (chop long lines) -X (disable termcap init and de-init) + LESS_OPTS = 'FRSX' + SKIP_INVENTORY_DEFAULTS = False + + def __init__(self, args, callback=None): + """ + Base init method for all command line programs + """ + + self.args = args + self.options = None + self.parser = None + self.action = None + self.callback = callback + + def set_action(self): + """ + Get the action the user wants to execute from the sys argv list. + """ + for i in range(0, len(self.args)): + arg = self.args[i] + if arg in self.VALID_ACTIONS: + self.action = arg + del self.args[i] + break + + if not self.action: + # if we're asked for help or version, we don't need an action. + # have to use a special purpose Option Parser to figure that out as + # the standard OptionParser throws an error for unknown options and + # without knowing action, we only know of a subset of the options + # that could be legal for this command + tmp_parser = InvalidOptsParser(self.parser) + tmp_options, tmp_args = tmp_parser.parse_args(self.args) + if not(hasattr(tmp_options, 'help') and tmp_options.help) or (hasattr(tmp_options, 'version') and tmp_options.version): + raise AnsibleOptionsError("Missing required action") + + def execute(self): + """ + Actually runs a child defined method using the execute_ pattern + """ + fn = getattr(self, "execute_%s" % self.action) + fn() + + @abstractmethod + def run(self): + """Run the ansible command + + Subclasses must implement this method. It does the actual work of + running an Ansible command. + """ + + display.vv(to_text(self.parser.get_version())) + + if C.CONFIG_FILE: + display.v(u"Using %s as config file" % to_text(C.CONFIG_FILE)) + else: + display.v(u"No config file found; using defaults") + + # warn about deprecated config options + for deprecated in C.config.DEPRECATED: + name = deprecated[0] + why = deprecated[1]['why'] + if 'alternatives' in deprecated[1]: + alt = ', use %s instead' % deprecated[1]['alternatives'] + else: + alt = '' + ver = deprecated[1]['version'] + display.deprecated("%s option, %s %s" % (name, why, alt), version=ver) + + @staticmethod + def split_vault_id(vault_id): + # return (before_@, after_@) + # if no @, return whole string as after_ + if '@' not in vault_id: + return (None, vault_id) + + parts = vault_id.split('@', 1) + ret = tuple(parts) + return ret + + @staticmethod + def build_vault_ids(vault_ids, vault_password_files=None, + ask_vault_pass=None, create_new_password=None, + auto_prompt=True): + vault_password_files = vault_password_files or [] + vault_ids = vault_ids or [] + + # convert vault_password_files into vault_ids slugs + for password_file in vault_password_files: + id_slug = u'%s@%s' % (C.DEFAULT_VAULT_IDENTITY, password_file) + + # note this makes --vault-id higher precendence than --vault-password-file + # if we want to intertwingle them in order probably need a cli callback to populate vault_ids + # used by --vault-id and --vault-password-file + vault_ids.append(id_slug) + + # if an action needs an encrypt password (create_new_password=True) and we dont + # have other secrets setup, then automatically add a password prompt as well. + # prompts cant/shouldnt work without a tty, so dont add prompt secrets + if ask_vault_pass or (not vault_ids and auto_prompt): + + id_slug = u'%s@%s' % (C.DEFAULT_VAULT_IDENTITY, u'prompt_ask_vault_pass') + vault_ids.append(id_slug) + + return vault_ids + + # TODO: remove the now unused args + @staticmethod + def setup_vault_secrets(loader, vault_ids, vault_password_files=None, + ask_vault_pass=None, create_new_password=False, + auto_prompt=True): + # list of tuples + vault_secrets = [] + + # Depending on the vault_id value (including how --ask-vault-pass / --vault-password-file create a vault_id) + # we need to show different prompts. This is for compat with older Towers that expect a + # certain vault password prompt format, so 'promp_ask_vault_pass' vault_id gets the old format. + prompt_formats = {} + + # If there are configured default vault identities, they are considered 'first' + # so we prepend them to vault_ids (from cli) here + + vault_password_files = vault_password_files or [] + if C.DEFAULT_VAULT_PASSWORD_FILE: + vault_password_files.append(C.DEFAULT_VAULT_PASSWORD_FILE) + + if create_new_password: + prompt_formats['prompt'] = ['New vault password (%(vault_id)s): ', + 'Confirm vew vault password (%(vault_id)s): '] + # 2.3 format prompts for --ask-vault-pass + prompt_formats['prompt_ask_vault_pass'] = ['New Vault password: ', + 'Confirm New Vault password: '] + else: + prompt_formats['prompt'] = ['Vault password (%(vault_id)s): '] + # The format when we use just --ask-vault-pass needs to match 'Vault password:\s*?$' + prompt_formats['prompt_ask_vault_pass'] = ['Vault password: '] + + vault_ids = CLI.build_vault_ids(vault_ids, + vault_password_files, + ask_vault_pass, + create_new_password, + auto_prompt=auto_prompt) + + for vault_id_slug in vault_ids: + vault_id_name, vault_id_value = CLI.split_vault_id(vault_id_slug) + if vault_id_value in ['prompt', 'prompt_ask_vault_pass']: + + # --vault-id some_name@prompt_ask_vault_pass --vault-id other_name@prompt_ask_vault_pass will be a little + # confusing since it will use the old format without the vault id in the prompt + built_vault_id = vault_id_name or C.DEFAULT_VAULT_IDENTITY + + # choose the prompt based on --vault-id=prompt or --ask-vault-pass. --ask-vault-pass + # always gets the old format for Tower compatibility. + # ie, we used --ask-vault-pass, so we need to use the old vault password prompt + # format since Tower needs to match on that format. + prompted_vault_secret = PromptVaultSecret(prompt_formats=prompt_formats[vault_id_value], + vault_id=built_vault_id) + + # a empty or invalid password from the prompt will warn and continue to the next + # without erroring globablly + try: + prompted_vault_secret.load() + except AnsibleError as exc: + display.warning('Error in vault password prompt (%s): %s' % (vault_id_name, exc)) + raise + + vault_secrets.append((built_vault_id, prompted_vault_secret)) + + # update loader with new secrets incrementally, so we can load a vault password + # that is encrypted with a vault secret provided earlier + loader.set_vault_secrets(vault_secrets) + continue + + # assuming anything else is a password file + display.vvvvv('Reading vault password file: %s' % vault_id_value) + # read vault_pass from a file + file_vault_secret = get_file_vault_secret(filename=vault_id_value, + vault_id=vault_id_name, + loader=loader) + + # an invalid password file will error globally + try: + file_vault_secret.load() + except AnsibleError as exc: + display.warning('Error in vault password file loading (%s): %s' % (vault_id_name, exc)) + raise + + if vault_id_name: + vault_secrets.append((vault_id_name, file_vault_secret)) + else: + vault_secrets.append((C.DEFAULT_VAULT_IDENTITY, file_vault_secret)) + + # update loader with as-yet-known vault secrets + loader.set_vault_secrets(vault_secrets) + + return vault_secrets + + def ask_passwords(self): + ''' prompt for connection and become passwords if needed ''' + + op = self.options + sshpass = None + becomepass = None + become_prompt = '' + + become_prompt_method = "BECOME" if C.AGNOSTIC_BECOME_PROMPT else op.become_method.upper() + + try: + if op.ask_pass: + sshpass = getpass.getpass(prompt="SSH password: ") + become_prompt = "%s password[defaults to SSH password]: " % become_prompt_method + if sshpass: + sshpass = to_bytes(sshpass, errors='strict', nonstring='simplerepr') + else: + become_prompt = "%s password: " % become_prompt_method + + if op.become_ask_pass: + becomepass = getpass.getpass(prompt=become_prompt) + if op.ask_pass and becomepass == '': + becomepass = sshpass + if becomepass: + becomepass = to_bytes(becomepass) + except EOFError: + pass + + return (sshpass, becomepass) + + def normalize_become_options(self): + ''' this keeps backwards compatibility with sudo/su self.options ''' + self.options.become_ask_pass = self.options.become_ask_pass or self.options.ask_sudo_pass or self.options.ask_su_pass or C.DEFAULT_BECOME_ASK_PASS + self.options.become_user = self.options.become_user or self.options.sudo_user or self.options.su_user or C.DEFAULT_BECOME_USER + + def _dep(which): + display.deprecated('The %s command line option has been deprecated in favor of the "become" command line arguments' % which, '2.9') + + if self.options.become: + pass + elif self.options.sudo: + self.options.become = True + self.options.become_method = 'sudo' + _dep('sudo') + elif self.options.su: + self.options.become = True + self.options.become_method = 'su' + _dep('su') + + # other deprecations: + if self.options.ask_sudo_pass or self.options.sudo_user: + _dep('sudo') + if self.options.ask_su_pass or self.options.su_user: + _dep('su') + + def validate_conflicts(self, vault_opts=False, runas_opts=False, fork_opts=False, vault_rekey_opts=False): + ''' check for conflicting options ''' + + op = self.options + + if vault_opts: + # Check for vault related conflicts + if (op.ask_vault_pass and op.vault_password_files): + self.parser.error("--ask-vault-pass and --vault-password-file are mutually exclusive") + + if vault_rekey_opts: + if (op.new_vault_id and op.new_vault_password_file): + self.parser.error("--new-vault-password-file and --new-vault-id are mutually exclusive") + + if runas_opts: + # Check for privilege escalation conflicts + if ((op.su or op.su_user) and (op.sudo or op.sudo_user) or + (op.su or op.su_user) and (op.become or op.become_user) or + (op.sudo or op.sudo_user) and (op.become or op.become_user)): + + self.parser.error("Sudo arguments ('--sudo', '--sudo-user', and '--ask-sudo-pass') and su arguments ('--su', '--su-user', and '--ask-su-pass') " + "and become arguments ('--become', '--become-user', and '--ask-become-pass') are exclusive of each other") + + if fork_opts: + if op.forks < 1: + self.parser.error("The number of processes (--forks) must be >= 1") + + @staticmethod + def unfrack_paths(option, opt, value, parser): + paths = getattr(parser.values, option.dest) + if paths is None: + paths = [] + + if isinstance(value, string_types): + paths[:0] = [unfrackpath(x) for x in value.split(os.pathsep) if x] + elif isinstance(value, list): + paths[:0] = [unfrackpath(x) for x in value if x] + else: + pass # FIXME: should we raise options error? + + setattr(parser.values, option.dest, paths) + + @staticmethod + def unfrack_path(option, opt, value, parser): + if value != '-': + setattr(parser.values, option.dest, unfrackpath(value)) + else: + setattr(parser.values, option.dest, value) + + @staticmethod + def base_parser(usage="", output_opts=False, runas_opts=False, meta_opts=False, runtask_opts=False, vault_opts=False, module_opts=False, + async_opts=False, connect_opts=False, subset_opts=False, check_opts=False, inventory_opts=False, epilog=None, fork_opts=False, + runas_prompt_opts=False, desc=None, basedir_opts=False, vault_rekey_opts=False): + ''' create an options parser for most ansible scripts ''' + + # base opts + parser = SortedOptParser(usage, version=CLI.version("%prog"), description=desc, epilog=epilog) + parser.add_option('-v', '--verbose', dest='verbosity', default=C.DEFAULT_VERBOSITY, action="count", + help="verbose mode (-vvv for more, -vvvv to enable connection debugging)") + + if inventory_opts: + parser.add_option('-i', '--inventory', '--inventory-file', dest='inventory', action="append", + help="specify inventory host path or comma separated host list. --inventory-file is deprecated") + parser.add_option('--list-hosts', dest='listhosts', action='store_true', + help='outputs a list of matching hosts; does not execute anything else') + parser.add_option('-l', '--limit', default=C.DEFAULT_SUBSET, dest='subset', + help='further limit selected hosts to an additional pattern') + + if module_opts: + parser.add_option('-M', '--module-path', dest='module_path', default=None, + help="prepend colon-separated path(s) to module library (default=%s)" % C.DEFAULT_MODULE_PATH, + action="callback", callback=CLI.unfrack_paths, type='str') + if runtask_opts: + parser.add_option('-e', '--extra-vars', dest="extra_vars", action="append", + help="set additional variables as key=value or YAML/JSON, if filename prepend with @", default=[]) + + if fork_opts: + parser.add_option('-f', '--forks', dest='forks', default=C.DEFAULT_FORKS, type='int', + help="specify number of parallel processes to use (default=%s)" % C.DEFAULT_FORKS) + + if vault_opts: + parser.add_option('--ask-vault-pass', default=C.DEFAULT_ASK_VAULT_PASS, dest='ask_vault_pass', action='store_true', + help='ask for vault password') + parser.add_option('--vault-password-file', default=[], dest='vault_password_files', + help="vault password file", action="callback", callback=CLI.unfrack_paths, type='string') + parser.add_option('--vault-id', default=[], dest='vault_ids', action='append', type='string', + help='the vault identity to use') + + if vault_rekey_opts: + parser.add_option('--new-vault-password-file', default=None, dest='new_vault_password_file', + help="new vault password file for rekey", action="callback", callback=CLI.unfrack_path, type='string') + parser.add_option('--new-vault-id', default=None, dest='new_vault_id', type='string', + help='the new vault identity to use for rekey') + + if subset_opts: + parser.add_option('-t', '--tags', dest='tags', default=C.TAGS_RUN, action='append', + help="only run plays and tasks tagged with these values") + parser.add_option('--skip-tags', dest='skip_tags', default=C.TAGS_SKIP, action='append', + help="only run plays and tasks whose tags do not match these values") + + if output_opts: + parser.add_option('-o', '--one-line', dest='one_line', action='store_true', + help='condense output') + parser.add_option('-t', '--tree', dest='tree', default=None, + help='log output to this directory') + + if connect_opts: + connect_group = optparse.OptionGroup(parser, "Connection Options", "control as whom and how to connect to hosts") + connect_group.add_option('-k', '--ask-pass', default=C.DEFAULT_ASK_PASS, dest='ask_pass', action='store_true', + help='ask for connection password') + connect_group.add_option('--private-key', '--key-file', default=C.DEFAULT_PRIVATE_KEY_FILE, dest='private_key_file', + help='use this file to authenticate the connection', action="callback", callback=CLI.unfrack_path, type='string') + connect_group.add_option('-u', '--user', default=C.DEFAULT_REMOTE_USER, dest='remote_user', + help='connect as this user (default=%s)' % C.DEFAULT_REMOTE_USER) + connect_group.add_option('-c', '--connection', dest='connection', default=C.DEFAULT_TRANSPORT, + help="connection type to use (default=%s)" % C.DEFAULT_TRANSPORT) + connect_group.add_option('-T', '--timeout', default=C.DEFAULT_TIMEOUT, type='int', dest='timeout', + help="override the connection timeout in seconds (default=%s)" % C.DEFAULT_TIMEOUT) + connect_group.add_option('--ssh-common-args', default='', dest='ssh_common_args', + help="specify common arguments to pass to sftp/scp/ssh (e.g. ProxyCommand)") + connect_group.add_option('--sftp-extra-args', default='', dest='sftp_extra_args', + help="specify extra arguments to pass to sftp only (e.g. -f, -l)") + connect_group.add_option('--scp-extra-args', default='', dest='scp_extra_args', + help="specify extra arguments to pass to scp only (e.g. -l)") + connect_group.add_option('--ssh-extra-args', default='', dest='ssh_extra_args', + help="specify extra arguments to pass to ssh only (e.g. -R)") + + parser.add_option_group(connect_group) + + runas_group = None + rg = optparse.OptionGroup(parser, "Privilege Escalation Options", "control how and which user you become as on target hosts") + if runas_opts: + runas_group = rg + # priv user defaults to root later on to enable detecting when this option was given here + runas_group.add_option("-s", "--sudo", default=C.DEFAULT_SUDO, action="store_true", dest='sudo', + help="run operations with sudo (nopasswd) (deprecated, use become)") + runas_group.add_option('-U', '--sudo-user', dest='sudo_user', default=None, + help='desired sudo user (default=root) (deprecated, use become)') + runas_group.add_option('-S', '--su', default=C.DEFAULT_SU, action='store_true', + help='run operations with su (deprecated, use become)') + runas_group.add_option('-R', '--su-user', default=None, + help='run operations with su as this user (default=%s) (deprecated, use become)' % C.DEFAULT_SU_USER) + + # consolidated privilege escalation (become) + runas_group.add_option("-b", "--become", default=C.DEFAULT_BECOME, action="store_true", dest='become', + help="run operations with become (does not imply password prompting)") + runas_group.add_option('--become-method', dest='become_method', default=C.DEFAULT_BECOME_METHOD, type='choice', choices=C.BECOME_METHODS, + help="privilege escalation method to use (default=%s), valid choices: [ %s ]" % + (C.DEFAULT_BECOME_METHOD, ' | '.join(C.BECOME_METHODS))) + runas_group.add_option('--become-user', default=None, dest='become_user', type='string', + help='run operations as this user (default=%s)' % C.DEFAULT_BECOME_USER) + + if runas_opts or runas_prompt_opts: + if not runas_group: + runas_group = rg + runas_group.add_option('--ask-sudo-pass', default=C.DEFAULT_ASK_SUDO_PASS, dest='ask_sudo_pass', action='store_true', + help='ask for sudo password (deprecated, use become)') + runas_group.add_option('--ask-su-pass', default=C.DEFAULT_ASK_SU_PASS, dest='ask_su_pass', action='store_true', + help='ask for su password (deprecated, use become)') + runas_group.add_option('-K', '--ask-become-pass', default=False, dest='become_ask_pass', action='store_true', + help='ask for privilege escalation password') + + if runas_group: + parser.add_option_group(runas_group) + + if async_opts: + parser.add_option('-P', '--poll', default=C.DEFAULT_POLL_INTERVAL, type='int', dest='poll_interval', + help="set the poll interval if using -B (default=%s)" % C.DEFAULT_POLL_INTERVAL) + parser.add_option('-B', '--background', dest='seconds', type='int', default=0, + help='run asynchronously, failing after X seconds (default=N/A)') + + if check_opts: + parser.add_option("-C", "--check", default=False, dest='check', action='store_true', + help="don't make any changes; instead, try to predict some of the changes that may occur") + parser.add_option('--syntax-check', dest='syntax', action='store_true', + help="perform a syntax check on the playbook, but do not execute it") + parser.add_option("-D", "--diff", default=C.DIFF_ALWAYS, dest='diff', action='store_true', + help="when changing (small) files and templates, show the differences in those files; works great with --check") + + if meta_opts: + parser.add_option('--force-handlers', default=C.DEFAULT_FORCE_HANDLERS, dest='force_handlers', action='store_true', + help="run handlers even if a task fails") + parser.add_option('--flush-cache', dest='flush_cache', action='store_true', + help="clear the fact cache for every host in inventory") + + if basedir_opts: + parser.add_option('--playbook-dir', default=None, dest='basedir', action='store', + help="Since this tool does not use playbooks, use this as a subsitute playbook directory." + "This sets the relative path for many features including roles/ group_vars/ etc.") + return parser + + @abstractmethod + def parse(self): + """Parse the command line args + + This method parses the command line arguments. It uses the parser + stored in the self.parser attribute and saves the args and options in + self.args and self.options respectively. + + Subclasses need to implement this method. They will usually create + a base_parser, add their own options to the base_parser, and then call + this method to do the actual parsing. An implementation will look + something like this:: + + def parse(self): + parser = super(MyCLI, self).base_parser(usage="My Ansible CLI", inventory_opts=True) + parser.add_option('--my-option', dest='my_option', action='store') + self.parser = parser + super(MyCLI, self).parse() + # If some additional transformations are needed for the + # arguments and options, do it here. + """ + + self.options, self.args = self.parser.parse_args(self.args[1:]) + + # process tags + if hasattr(self.options, 'tags') and not self.options.tags: + # optparse defaults does not do what's expected + self.options.tags = ['all'] + if hasattr(self.options, 'tags') and self.options.tags: + tags = set() + for tag_set in self.options.tags: + for tag in tag_set.split(u','): + tags.add(tag.strip()) + self.options.tags = list(tags) + + # process skip_tags + if hasattr(self.options, 'skip_tags') and self.options.skip_tags: + skip_tags = set() + for tag_set in self.options.skip_tags: + for tag in tag_set.split(u','): + skip_tags.add(tag.strip()) + self.options.skip_tags = list(skip_tags) + + # process inventory options except for CLIs that require their own processing + if hasattr(self.options, 'inventory') and not self.SKIP_INVENTORY_DEFAULTS: + + if self.options.inventory: + + # should always be list + if isinstance(self.options.inventory, string_types): + self.options.inventory = [self.options.inventory] + + # Ensure full paths when needed + self.options.inventory = [unfrackpath(opt, follow=False) if ',' not in opt else opt for opt in self.options.inventory] + else: + self.options.inventory = C.DEFAULT_HOST_LIST + + @staticmethod + def version(prog): + ''' return ansible version ''' + result = "{0} {1}".format(prog, __version__) + gitinfo = CLI._gitinfo() + if gitinfo: + result = result + " {0}".format(gitinfo) + result += "\n config file = %s" % C.CONFIG_FILE + if C.DEFAULT_MODULE_PATH is None: + cpath = "Default w/o overrides" + else: + cpath = C.DEFAULT_MODULE_PATH + result = result + "\n configured module search path = %s" % cpath + result = result + "\n ansible python module location = %s" % ':'.join(ansible.__path__) + result = result + "\n executable location = %s" % sys.argv[0] + result = result + "\n python version = %s" % ''.join(sys.version.splitlines()) + return result + + @staticmethod + def version_info(gitinfo=False): + ''' return full ansible version info ''' + if gitinfo: + # expensive call, user with care + ansible_version_string = CLI.version('') + else: + ansible_version_string = __version__ + ansible_version = ansible_version_string.split()[0] + ansible_versions = ansible_version.split('.') + for counter in range(len(ansible_versions)): + if ansible_versions[counter] == "": + ansible_versions[counter] = 0 + try: + ansible_versions[counter] = int(ansible_versions[counter]) + except Exception: + pass + if len(ansible_versions) < 3: + for counter in range(len(ansible_versions), 3): + ansible_versions.append(0) + return {'string': ansible_version_string.strip(), + 'full': ansible_version, + 'major': ansible_versions[0], + 'minor': ansible_versions[1], + 'revision': ansible_versions[2]} + + @staticmethod + def _git_repo_info(repo_path): + ''' returns a string containing git branch, commit id and commit date ''' + result = None + if os.path.exists(repo_path): + # Check if the .git is a file. If it is a file, it means that we are in a submodule structure. + if os.path.isfile(repo_path): + try: + gitdir = yaml.safe_load(open(repo_path)).get('gitdir') + # There is a possibility the .git file to have an absolute path. + if os.path.isabs(gitdir): + repo_path = gitdir + else: + repo_path = os.path.join(repo_path[:-4], gitdir) + except (IOError, AttributeError): + return '' + f = open(os.path.join(repo_path, "HEAD")) + line = f.readline().rstrip("\n") + if line.startswith("ref:"): + branch_path = os.path.join(repo_path, line[5:]) + else: + branch_path = None + f.close() + if branch_path and os.path.exists(branch_path): + branch = '/'.join(line.split('/')[2:]) + f = open(branch_path) + commit = f.readline()[:10] + f.close() + else: + # detached HEAD + commit = line[:10] + branch = 'detached HEAD' + branch_path = os.path.join(repo_path, "HEAD") + + date = time.localtime(os.stat(branch_path).st_mtime) + if time.daylight == 0: + offset = time.timezone + else: + offset = time.altzone + result = "({0} {1}) last updated {2} (GMT {3:+04d})".format(branch, commit, time.strftime("%Y/%m/%d %H:%M:%S", date), int(offset / -36)) + else: + result = '' + return result + + @staticmethod + def _gitinfo(): + basedir = os.path.join(os.path.dirname(__file__), '..', '..', '..') + repo_path = os.path.join(basedir, '.git') + result = CLI._git_repo_info(repo_path) + submodules = os.path.join(basedir, '.gitmodules') + if not os.path.exists(submodules): + return result + f = open(submodules) + for line in f: + tokens = line.strip().split(' ') + if tokens[0] == 'path': + submodule_path = tokens[2] + submodule_info = CLI._git_repo_info(os.path.join(basedir, submodule_path, '.git')) + if not submodule_info: + submodule_info = ' not found - use git submodule update --init ' + submodule_path + result += "\n {0}: {1}".format(submodule_path, submodule_info) + f.close() + return result + + def pager(self, text): + ''' find reasonable way to display text ''' + # this is a much simpler form of what is in pydoc.py + if not sys.stdout.isatty(): + display.display(text, screen_only=True) + elif 'PAGER' in os.environ: + if sys.platform == 'win32': + display.display(text, screen_only=True) + else: + self.pager_pipe(text, os.environ['PAGER']) + else: + p = subprocess.Popen('less --version', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p.communicate() + if p.returncode == 0: + self.pager_pipe(text, 'less') + else: + display.display(text, screen_only=True) + + @staticmethod + def pager_pipe(text, cmd): + ''' pipe text through a pager ''' + if 'LESS' not in os.environ: + os.environ['LESS'] = CLI.LESS_OPTS + try: + cmd = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=sys.stdout) + cmd.communicate(input=to_bytes(text)) + except IOError: + pass + except KeyboardInterrupt: + pass + + @classmethod + def tty_ify(cls, text): + + t = cls._ITALIC.sub("`" + r"\1" + "'", text) # I(word) => `word' + t = cls._BOLD.sub("*" + r"\1" + "*", t) # B(word) => *word* + t = cls._MODULE.sub("[" + r"\1" + "]", t) # M(word) => [word] + t = cls._URL.sub(r"\1", t) # U(word) => word + t = cls._CONST.sub("`" + r"\1" + "'", t) # C(word) => `word' + + return t + + @staticmethod + def _play_prereqs(options): + + # all needs loader + loader = DataLoader() + + basedir = getattr(options, 'basedir', False) + if basedir: + loader.set_basedir(basedir) + + vault_ids = options.vault_ids + default_vault_ids = C.DEFAULT_VAULT_IDENTITY_LIST + vault_ids = default_vault_ids + vault_ids + + vault_secrets = CLI.setup_vault_secrets(loader, + vault_ids=vault_ids, + vault_password_files=options.vault_password_files, + ask_vault_pass=options.ask_vault_pass, + auto_prompt=False) + loader.set_vault_secrets(vault_secrets) + + # create the inventory, and filter it based on the subset specified (if any) + inventory = InventoryManager(loader=loader, sources=options.inventory) + + # create the variable manager, which will be shared throughout + # the code, ensuring a consistent view of global variables + variable_manager = VariableManager(loader=loader, inventory=inventory) + + if hasattr(options, 'basedir'): + if options.basedir: + variable_manager.safe_basedir = True + else: + variable_manager.safe_basedir = True + + # load vars from cli options + variable_manager.extra_vars = load_extra_vars(loader=loader, options=options) + variable_manager.options_vars = load_options_vars(options, CLI.version_info(gitinfo=False)) + + return loader, inventory, variable_manager + + @staticmethod + def get_host_list(inventory, subset, pattern='all'): + + no_hosts = False + if len(inventory.list_hosts()) == 0: + # Empty inventory + if C.LOCALHOST_WARNING: + display.warning("provided hosts list is empty, only localhost is available. Note that the implicit localhost does not match 'all'") + no_hosts = True + + inventory.subset(subset) + + hosts = inventory.list_hosts(pattern) + if len(hosts) == 0 and no_hosts is False: + raise AnsibleError("Specified hosts and/or --limit does not match any hosts") + + return hosts diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/adhoc.py b/env_27/lib/python2.7/site-packages/ansible/cli/adhoc.py new file mode 100644 index 0000000..18427d8 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/adhoc.py @@ -0,0 +1,188 @@ +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +######################################################## + +from ansible import constants as C +from ansible.cli import CLI +from ansible.errors import AnsibleError, AnsibleOptionsError +from ansible.executor.task_queue_manager import TaskQueueManager +from ansible.module_utils._text import to_text +from ansible.parsing.splitter import parse_kv +from ansible.playbook import Playbook +from ansible.playbook.play import Play +from ansible.plugins.loader import get_all_plugin_loaders + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +######################################################## + +class AdHocCLI(CLI): + ''' is an extra-simple tool/framework/API for doing 'remote things'. + this command allows you to define and run a single task 'playbook' against a set of hosts + ''' + + def parse(self): + ''' create an options parser for bin/ansible ''' + + self.parser = CLI.base_parser( + usage='%prog [options]', + runas_opts=True, + inventory_opts=True, + async_opts=True, + output_opts=True, + connect_opts=True, + check_opts=True, + runtask_opts=True, + vault_opts=True, + fork_opts=True, + module_opts=True, + basedir_opts=True, + desc="Define and run a single task 'playbook' against a set of hosts", + epilog="Some modules do not make sense in Ad-Hoc (include, meta, etc)", + ) + + # options unique to ansible ad-hoc + self.parser.add_option('-a', '--args', dest='module_args', + help="module arguments", default=C.DEFAULT_MODULE_ARGS) + self.parser.add_option('-m', '--module-name', dest='module_name', + help="module name to execute (default=%s)" % C.DEFAULT_MODULE_NAME, + default=C.DEFAULT_MODULE_NAME) + + super(AdHocCLI, self).parse() + + if len(self.args) < 1: + raise AnsibleOptionsError("Missing target hosts") + elif len(self.args) > 1: + raise AnsibleOptionsError("Extraneous options or arguments") + + display.verbosity = self.options.verbosity + self.validate_conflicts(runas_opts=True, vault_opts=True, fork_opts=True) + + def _play_ds(self, pattern, async_val, poll): + check_raw = self.options.module_name in ('command', 'win_command', 'shell', 'win_shell', 'script', 'raw') + return dict( + name="Ansible Ad-Hoc", + hosts=pattern, + gather_facts='no', + tasks=[dict(action=dict(module=self.options.module_name, args=parse_kv(self.options.module_args, check_raw=check_raw)), async_val=async_val, + poll=poll)] + ) + + def run(self): + ''' create and execute the single task playbook ''' + + super(AdHocCLI, self).run() + + # only thing left should be host pattern + pattern = to_text(self.args[0], errors='surrogate_or_strict') + + sshpass = None + becomepass = None + + self.normalize_become_options() + (sshpass, becomepass) = self.ask_passwords() + passwords = {'conn_pass': sshpass, 'become_pass': becomepass} + + # dynamically load any plugins + get_all_plugin_loaders() + + loader, inventory, variable_manager = self._play_prereqs(self.options) + + try: + hosts = CLI.get_host_list(inventory, self.options.subset, pattern) + except AnsibleError: + if self.options.subset: + raise + else: + hosts = [] + display.warning("No hosts matched, nothing to do") + + if self.options.listhosts: + display.display(' hosts (%d):' % len(hosts)) + for host in hosts: + display.display(' %s' % host) + return 0 + + if self.options.module_name in C.MODULE_REQUIRE_ARGS and not self.options.module_args: + err = "No argument passed to %s module" % self.options.module_name + if pattern.endswith(".yml"): + err = err + ' (did you mean to run ansible-playbook?)' + raise AnsibleOptionsError(err) + + # Avoid modules that don't work with ad-hoc + if self.options.module_name in ('import_playbook',): + raise AnsibleOptionsError("'%s' is not a valid action for ad-hoc commands" % self.options.module_name) + + play_ds = self._play_ds(pattern, self.options.seconds, self.options.poll_interval) + play = Play().load(play_ds, variable_manager=variable_manager, loader=loader) + + # used in start callback + playbook = Playbook(loader) + playbook._entries.append(play) + playbook._file_name = '__adhoc_playbook__' + + if self.callback: + cb = self.callback + elif self.options.one_line: + cb = 'oneline' + # Respect custom 'stdout_callback' only with enabled 'bin_ansible_callbacks' + elif C.DEFAULT_LOAD_CALLBACK_PLUGINS and C.DEFAULT_STDOUT_CALLBACK != 'default': + cb = C.DEFAULT_STDOUT_CALLBACK + else: + cb = 'minimal' + + run_tree = False + if self.options.tree: + C.DEFAULT_CALLBACK_WHITELIST.append('tree') + C.TREE_DIR = self.options.tree + run_tree = True + + # now create a task queue manager to execute the play + self._tqm = None + try: + self._tqm = TaskQueueManager( + inventory=inventory, + variable_manager=variable_manager, + loader=loader, + options=self.options, + passwords=passwords, + stdout_callback=cb, + run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS, + run_tree=run_tree, + ) + + self._tqm.send_callback('v2_playbook_on_start', playbook) + + result = self._tqm.run(play) + + self._tqm.send_callback('v2_playbook_on_stats', self._tqm._stats) + finally: + if self._tqm: + self._tqm.cleanup() + if loader: + loader.cleanup_all_tmp_files() + + return result diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/config.py b/env_27/lib/python2.7/site-packages/ansible/cli/config.py new file mode 100644 index 0000000..f6f2398 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/config.py @@ -0,0 +1,174 @@ +# Copyright: (c) 2017, Ansible Project +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import os +import shlex +import subprocess +import sys +import yaml + +from ansible.cli import CLI +from ansible.config.manager import ConfigManager, Setting, find_ini_config_file +from ansible.errors import AnsibleError, AnsibleOptionsError +from ansible.module_utils._text import to_native, to_text +from ansible.parsing.yaml.dumper import AnsibleDumper +from ansible.utils.color import stringc +from ansible.utils.path import unfrackpath + + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class ConfigCLI(CLI): + """ Config command line class """ + + VALID_ACTIONS = ("view", "dump", "list") # TODO: edit, update, search + + def __init__(self, args, callback=None): + + self.config_file = None + self.config = None + super(ConfigCLI, self).__init__(args, callback) + + def parse(self): + + self.parser = CLI.base_parser( + usage="usage: %%prog [%s] [--help] [options] [ansible.cfg]" % "|".join(self.VALID_ACTIONS), + epilog="\nSee '%s --help' for more information on a specific command.\n\n" % os.path.basename(sys.argv[0]), + desc="View, edit, and manage ansible configuration.", + ) + self.parser.add_option('-c', '--config', dest='config_file', help="path to configuration file, defaults to first file found in precedence.") + + self.set_action() + + # options specific to self.actions + if self.action == "list": + self.parser.set_usage("usage: %prog list [options] ") + if self.action == "dump": + self.parser.add_option('--only-changed', dest='only_changed', action='store_true', + help="Only show configurations that have changed from the default") + elif self.action == "update": + self.parser.add_option('-s', '--setting', dest='setting', help="config setting, the section defaults to 'defaults'") + self.parser.set_usage("usage: %prog update [options] [-c ansible.cfg] -s '[section.]setting=value'") + elif self.action == "search": + self.parser.set_usage("usage: %prog update [options] [-c ansible.cfg] ") + + self.options, self.args = self.parser.parse_args() + display.verbosity = self.options.verbosity + + def run(self): + + super(ConfigCLI, self).run() + + if self.options.config_file: + self.config_file = unfrackpath(self.options.config_file, follow=False) + self.config = ConfigManager(self.config_file) + else: + self.config = ConfigManager() + self.config_file = find_ini_config_file() + + if self.config_file: + try: + if not os.path.exists(self.config_file): + raise AnsibleOptionsError("%s does not exist or is not accessible" % (self.config_file)) + elif not os.path.isfile(self.config_file): + raise AnsibleOptionsError("%s is not a valid file" % (self.config_file)) + + os.environ['ANSIBLE_CONFIG'] = to_native(self.config_file) + except: + if self.action in ['view']: + raise + elif self.action in ['edit', 'update']: + display.warning("File does not exist, used empty file: %s" % self.config_file) + + elif self.action == 'view': + raise AnsibleError('Invalid or no config file was supplied') + + self.execute() + + def execute_update(self): + ''' + Updates a single setting in the specified ansible.cfg + ''' + raise AnsibleError("Option not implemented yet") + + # pylint: disable=unreachable + if self.options.setting is None: + raise AnsibleOptionsError("update option requries a setting to update") + + (entry, value) = self.options.setting.split('=') + if '.' in entry: + (section, option) = entry.split('.') + else: + section = 'defaults' + option = entry + subprocess.call([ + 'ansible', + '-m', 'ini_file', + 'localhost', + '-c', 'local', + '-a', '"dest=%s section=%s option=%s value=%s backup=yes"' % (self.config_file, section, option, value) + ]) + + def execute_view(self): + ''' + Displays the current config file + ''' + try: + with open(self.config_file, 'rb') as f: + self.pager(to_text(f.read(), errors='surrogate_or_strict')) + except Exception as e: + raise AnsibleError("Failed to open config file: %s" % to_native(e)) + + def execute_edit(self): + ''' + Opens ansible.cfg in the default EDITOR + ''' + raise AnsibleError("Option not implemented yet") + + # pylint: disable=unreachable + try: + editor = shlex.split(os.environ.get('EDITOR', 'vi')) + editor.append(self.config_file) + subprocess.call(editor) + except Exception as e: + raise AnsibleError("Failed to open editor: %s" % to_native(e)) + + def execute_list(self): + ''' + list all current configs reading lib/constants.py and shows env and config file setting names + ''' + self.pager(to_text(yaml.dump(self.config.get_configuration_definitions(), Dumper=AnsibleDumper), errors='surrogate_or_strict')) + + def execute_dump(self): + ''' + Shows the current settings, merges ansible.cfg if specified + ''' + # FIXME: deal with plugins, not just base config + text = [] + defaults = self.config.get_configuration_definitions().copy() + for setting in self.config.data.get_settings(): + if setting.name in defaults: + defaults[setting.name] = setting + + for setting in sorted(defaults): + if isinstance(defaults[setting], Setting): + if defaults[setting].origin == 'default': + color = 'green' + else: + color = 'yellow' + msg = "%s(%s) = %s" % (setting, defaults[setting].origin, defaults[setting].value) + else: + color = 'green' + msg = "%s(%s) = %s" % (setting, 'default', defaults[setting].get('default')) + if not self.options.only_changed or color == 'yellow': + text.append(stringc(msg, color)) + + self.pager(to_text('\n'.join(text), errors='surrogate_or_strict')) diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/console.py b/env_27/lib/python2.7/site-packages/ansible/cli/console.py new file mode 100644 index 0000000..f2349fc --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/console.py @@ -0,0 +1,442 @@ +# (c) 2014, Nandor Sivok +# (c) 2016, Redhat Inc +# +# ansible-console is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ansible-console is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . +# + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +######################################################## +# ansible-console is an interactive REPL shell for ansible +# with built-in tab completion for all the documented modules +# +# Available commands: +# cd - change host/group (you can use host patterns eg.: app*.dc*:!app01*) +# list - list available hosts in the current path +# forks - change fork +# become - become +# ! - forces shell module instead of the ansible module (!yum update -y) + +import atexit +import cmd +import getpass +import readline +import os +import sys + +from ansible import constants as C +from ansible.cli import CLI +from ansible.executor.task_queue_manager import TaskQueueManager +from ansible.module_utils._text import to_native, to_text +from ansible.module_utils.parsing.convert_bool import boolean +from ansible.parsing.splitter import parse_kv +from ansible.playbook.play import Play +from ansible.plugins.loader import module_loader, fragment_loader +from ansible.utils import plugin_docs +from ansible.utils.color import stringc + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class ConsoleCLI(CLI, cmd.Cmd): + ''' a REPL that allows for running ad-hoc tasks against a chosen inventory (based on dominis' ansible-shell).''' + + modules = [] + ARGUMENTS = {'host-pattern': 'A name of a group in the inventory, a shell-like glob ' + 'selecting hosts in inventory or any combination of the two separated by commas.'} + + # use specific to console, but fallback to highlight for backwards compatibility + NORMAL_PROMPT = C.COLOR_CONSOLE_PROMPT or C.COLOR_HIGHLIGHT + + def __init__(self, args): + + super(ConsoleCLI, self).__init__(args) + + self.intro = 'Welcome to the ansible console.\nType help or ? to list commands.\n' + + self.groups = [] + self.hosts = [] + self.pattern = None + self.variable_manager = None + self.loader = None + self.passwords = dict() + + self.modules = None + cmd.Cmd.__init__(self) + + def parse(self): + self.parser = CLI.base_parser( + usage='%prog [] [options]', + runas_opts=True, + inventory_opts=True, + connect_opts=True, + check_opts=True, + vault_opts=True, + fork_opts=True, + module_opts=True, + basedir_opts=True, + desc="REPL console for executing Ansible tasks.", + epilog="This is not a live session/connection, each task executes in the background and returns it's results." + ) + + # options unique to shell + self.parser.add_option('--step', dest='step', action='store_true', + help="one-step-at-a-time: confirm each task before running") + + self.parser.set_defaults(cwd='*') + + super(ConsoleCLI, self).parse() + + display.verbosity = self.options.verbosity + self.validate_conflicts(runas_opts=True, vault_opts=True, fork_opts=True) + + def get_names(self): + return dir(self) + + def cmdloop(self): + try: + cmd.Cmd.cmdloop(self) + except KeyboardInterrupt: + self.do_exit(self) + + def set_prompt(self): + login_user = self.options.remote_user or getpass.getuser() + self.selected = self.inventory.list_hosts(self.options.cwd) + prompt = "%s@%s (%d)[f:%s]" % (login_user, self.options.cwd, len(self.selected), self.options.forks) + if self.options.become and self.options.become_user in [None, 'root']: + prompt += "# " + color = C.COLOR_ERROR + else: + prompt += "$ " + color = self.NORMAL_PROMPT + self.prompt = stringc(prompt, color) + + def list_modules(self): + modules = set() + if self.options.module_path: + for path in self.options.module_path: + if path: + module_loader.add_directory(path) + + module_paths = module_loader._get_paths() + for path in module_paths: + if path is not None: + modules.update(self._find_modules_in_path(path)) + return modules + + def _find_modules_in_path(self, path): + + if os.path.isdir(path): + for module in os.listdir(path): + if module.startswith('.'): + continue + elif os.path.isdir(module): + self._find_modules_in_path(module) + elif module.startswith('__'): + continue + elif any(module.endswith(x) for x in C.BLACKLIST_EXTS): + continue + elif module in C.IGNORE_FILES: + continue + elif module.startswith('_'): + fullpath = '/'.join([path, module]) + if os.path.islink(fullpath): # avoids aliases + continue + module = module.replace('_', '', 1) + + module = os.path.splitext(module)[0] # removes the extension + yield module + + def default(self, arg, forceshell=False): + """ actually runs modules """ + if arg.startswith("#"): + return False + + if not self.options.cwd: + display.error("No host found") + return False + + if arg.split()[0] in self.modules: + module = arg.split()[0] + module_args = ' '.join(arg.split()[1:]) + else: + module = 'shell' + module_args = arg + + if forceshell is True: + module = 'shell' + module_args = arg + + self.options.module_name = module + + result = None + try: + check_raw = self.options.module_name in ('command', 'shell', 'script', 'raw') + play_ds = dict( + name="Ansible Shell", + hosts=self.options.cwd, + gather_facts='no', + tasks=[dict(action=dict(module=module, args=parse_kv(module_args, check_raw=check_raw)))] + ) + play = Play().load(play_ds, variable_manager=self.variable_manager, loader=self.loader) + except Exception as e: + display.error(u"Unable to build command: %s" % to_text(e)) + return False + + try: + cb = 'minimal' # FIXME: make callbacks configurable + # now create a task queue manager to execute the play + self._tqm = None + try: + self._tqm = TaskQueueManager( + inventory=self.inventory, + variable_manager=self.variable_manager, + loader=self.loader, + options=self.options, + passwords=self.passwords, + stdout_callback=cb, + run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS, + run_tree=False, + ) + + result = self._tqm.run(play) + finally: + if self._tqm: + self._tqm.cleanup() + if self.loader: + self.loader.cleanup_all_tmp_files() + + if result is None: + display.error("No hosts found") + return False + except KeyboardInterrupt: + display.error('User interrupted execution') + return False + except Exception as e: + display.error(to_text(e)) + # FIXME: add traceback in very very verbose mode + return False + + def emptyline(self): + return + + def do_shell(self, arg): + """ + You can run shell commands through the shell module. + + eg.: + shell ps uax | grep java | wc -l + shell killall python + shell halt -n + + You can use the ! to force the shell module. eg.: + !ps aux | grep java | wc -l + """ + self.default(arg, True) + + def do_forks(self, arg): + """Set the number of forks""" + if not arg: + display.display('Usage: forks ') + return + self.options.forks = int(arg) + self.set_prompt() + + do_serial = do_forks + + def do_verbosity(self, arg): + """Set verbosity level""" + if not arg: + display.display('Usage: verbosity ') + else: + display.verbosity = int(arg) + display.v('verbosity level set to %s' % arg) + + def do_cd(self, arg): + """ + Change active host/group. You can use hosts patterns as well eg.: + cd webservers + cd webservers:dbservers + cd webservers:!phoenix + cd webservers:&staging + cd webservers:dbservers:&staging:!phoenix + """ + if not arg: + self.options.cwd = '*' + elif arg in '/*': + self.options.cwd = 'all' + elif self.inventory.get_hosts(arg): + self.options.cwd = arg + else: + display.display("no host matched") + + self.set_prompt() + + def do_list(self, arg): + """List the hosts in the current group""" + if arg == 'groups': + for group in self.groups: + display.display(group) + else: + for host in self.selected: + display.display(host.name) + + def do_become(self, arg): + """Toggle whether plays run with become""" + if arg: + self.options.become = boolean(arg, strict=False) + display.v("become changed to %s" % self.options.become) + self.set_prompt() + else: + display.display("Please specify become value, e.g. `become yes`") + + def do_remote_user(self, arg): + """Given a username, set the remote user plays are run by""" + if arg: + self.options.remote_user = arg + self.set_prompt() + else: + display.display("Please specify a remote user, e.g. `remote_user root`") + + def do_become_user(self, arg): + """Given a username, set the user that plays are run by when using become""" + if arg: + self.options.become_user = arg + else: + display.display("Please specify a user, e.g. `become_user jenkins`") + display.v("Current user is %s" % self.options.become_user) + self.set_prompt() + + def do_become_method(self, arg): + """Given a become_method, set the privilege escalation method when using become""" + if arg: + self.options.become_method = arg + display.v("become_method changed to %s" % self.options.become_method) + else: + display.display("Please specify a become_method, e.g. `become_method su`") + + def do_check(self, arg): + """Toggle whether plays run with check mode""" + if arg: + self.options.check = boolean(arg, strict=False) + display.v("check mode changed to %s" % self.options.check) + else: + display.display("Please specify check mode value, e.g. `check yes`") + + def do_diff(self, arg): + """Toggle whether plays run with diff""" + if arg: + self.options.diff = boolean(arg, strict=False) + display.v("diff mode changed to %s" % self.options.diff) + else: + display.display("Please specify a diff value , e.g. `diff yes`") + + def do_exit(self, args): + """Exits from the console""" + sys.stdout.write('\n') + return -1 + + do_EOF = do_exit + + def helpdefault(self, module_name): + if module_name in self.modules: + in_path = module_loader.find_plugin(module_name) + if in_path: + oc, a, _, _ = plugin_docs.get_docstring(in_path, fragment_loader) + if oc: + display.display(oc['short_description']) + display.display('Parameters:') + for opt in oc['options'].keys(): + display.display(' ' + stringc(opt, self.NORMAL_PROMPT) + ' ' + oc['options'][opt]['description'][0]) + else: + display.error('No documentation found for %s.' % module_name) + else: + display.error('%s is not a valid command, use ? to list all valid commands.' % module_name) + + def complete_cd(self, text, line, begidx, endidx): + mline = line.partition(' ')[2] + offs = len(mline) - len(text) + + if self.options.cwd in ('all', '*', '\\'): + completions = self.hosts + self.groups + else: + completions = [x.name for x in self.inventory.list_hosts(self.options.cwd)] + + return [to_native(s)[offs:] for s in completions if to_native(s).startswith(to_native(mline))] + + def completedefault(self, text, line, begidx, endidx): + if line.split()[0] in self.modules: + mline = line.split(' ')[-1] + offs = len(mline) - len(text) + completions = self.module_args(line.split()[0]) + + return [s[offs:] + '=' for s in completions if s.startswith(mline)] + + def module_args(self, module_name): + in_path = module_loader.find_plugin(module_name) + oc, a, _, _ = plugin_docs.get_docstring(in_path, fragment_loader) + return list(oc['options'].keys()) + + def run(self): + + super(ConsoleCLI, self).run() + + sshpass = None + becomepass = None + + # hosts + if len(self.args) != 1: + self.pattern = 'all' + else: + self.pattern = self.args[0] + self.options.cwd = self.pattern + + # dynamically add modules as commands + self.modules = self.list_modules() + for module in self.modules: + setattr(self, 'do_' + module, lambda arg, module=module: self.default(module + ' ' + arg)) + setattr(self, 'help_' + module, lambda module=module: self.helpdefault(module)) + + self.normalize_become_options() + (sshpass, becomepass) = self.ask_passwords() + self.passwords = {'conn_pass': sshpass, 'become_pass': becomepass} + + self.loader, self.inventory, self.variable_manager = self._play_prereqs(self.options) + + hosts = CLI.get_host_list(self.inventory, self.options.subset, self.pattern) + + self.groups = self.inventory.list_groups() + self.hosts = [x.name for x in hosts] + + # This hack is to work around readline issues on a mac: + # http://stackoverflow.com/a/7116997/541202 + if 'libedit' in readline.__doc__: + readline.parse_and_bind("bind ^I rl_complete") + else: + readline.parse_and_bind("tab: complete") + + histfile = os.path.join(os.path.expanduser("~"), ".ansible-console_history") + try: + readline.read_history_file(histfile) + except IOError: + pass + + atexit.register(readline.write_history_file, histfile) + self.set_prompt() + self.cmdloop() diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/doc.py b/env_27/lib/python2.7/site-packages/ansible/cli/doc.py new file mode 100644 index 0000000..e9ecfc1 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/doc.py @@ -0,0 +1,653 @@ +# Copyright: (c) 2014, James Tanner +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import datetime +import json +import os +import textwrap +import traceback +import yaml + +from collections import Sequence +import ansible.plugins.loader as plugin_loader + +from ansible import constants as C +from ansible.cli import CLI +from ansible.errors import AnsibleError, AnsibleOptionsError +from ansible.module_utils._text import to_native +from ansible.module_utils.six import string_types +from ansible.parsing.metadata import extract_metadata +from ansible.parsing.plugin_docs import read_docstub +from ansible.parsing.yaml.dumper import AnsibleDumper +from ansible.plugins.loader import action_loader, fragment_loader +from ansible.utils.plugin_docs import BLACKLIST, get_docstring + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class DocCLI(CLI): + ''' displays information on modules installed in Ansible libraries. + It displays a terse listing of plugins and their short descriptions, + provides a printout of their DOCUMENTATION strings, + and it can create a short "snippet" which can be pasted into a playbook. ''' + + # default ignore list for detailed views + IGNORE = ('module', 'docuri', 'version_added', 'short_description', 'now_date', 'plainexamples', 'returndocs') + + def __init__(self, args): + + super(DocCLI, self).__init__(args) + self.plugin_list = set() + + def parse(self): + + self.parser = CLI.base_parser( + usage='usage: %prog [-l|-F|-s] [options] [-t ] [plugin]', + module_opts=True, + desc="plugin documentation tool", + epilog="See man pages for Ansible CLI options or website for tutorials https://docs.ansible.com" + ) + + self.parser.add_option("-F", "--list_files", action="store_true", default=False, dest="list_files", + help='Show plugin names and their source files without summaries (implies --list)') + self.parser.add_option("-l", "--list", action="store_true", default=False, dest='list_dir', + help='List available plugins') + self.parser.add_option("-s", "--snippet", action="store_true", default=False, dest='show_snippet', + help='Show playbook snippet for specified plugin(s)') + self.parser.add_option("-a", "--all", action="store_true", default=False, dest='all_plugins', + help='**For internal testing only** Show documentation for all plugins.') + self.parser.add_option("-j", "--json", action="store_true", default=False, dest='json_dump', + help='**For internal testing only** Dump json metadata for all plugins.') + self.parser.add_option("-t", "--type", action="store", default='module', dest='type', type='choice', + help='Choose which plugin type (defaults to "module")', + choices=C.DOCUMENTABLE_PLUGINS) + super(DocCLI, self).parse() + + if [self.options.all_plugins, self.options.json_dump, self.options.list_dir, self.options.list_files, self.options.show_snippet].count(True) > 1: + raise AnsibleOptionsError("Only one of -l, -F, -s, -j or -a can be used at the same time.") + + display.verbosity = self.options.verbosity + + def run(self): + + super(DocCLI, self).run() + + plugin_type = self.options.type + + if plugin_type in C.DOCUMENTABLE_PLUGINS: + loader = getattr(plugin_loader, '%s_loader' % plugin_type) + else: + raise AnsibleOptionsError("Unknown or undocumentable plugin type: %s" % plugin_type) + + # add to plugin path from command line + if self.options.module_path: + for path in self.options.module_path: + if path: + loader.add_directory(path) + + # save only top level paths for errors + search_paths = DocCLI.print_paths(loader) + loader._paths = None # reset so we can use subdirs below + + # list plugins names and filepath for type + if self.options.list_files: + paths = loader._get_paths() + for path in paths: + self.plugin_list.update(self.find_plugins(path, plugin_type)) + + list_text = self.get_plugin_list_filenames(loader) + self.pager(list_text) + return 0 + + # list plugins for type + if self.options.list_dir: + paths = loader._get_paths() + for path in paths: + self.plugin_list.update(self.find_plugins(path, plugin_type)) + + self.pager(self.get_plugin_list_text(loader)) + return 0 + + # process all plugins of type + if self.options.all_plugins: + self.args = self.get_all_plugins_of_type(plugin_type) + + # dump plugin metadata as JSON + if self.options.json_dump: + plugin_data = {} + for plugin_type in C.DOCUMENTABLE_PLUGINS: + plugin_data[plugin_type] = dict() + plugin_names = self.get_all_plugins_of_type(plugin_type) + for plugin_name in plugin_names: + plugin_info = self.get_plugin_metadata(plugin_type, plugin_name) + if plugin_info is not None: + plugin_data[plugin_type][plugin_name] = plugin_info + + self.pager(json.dumps(plugin_data, sort_keys=True, indent=4)) + + return 0 + + if len(self.args) == 0: + raise AnsibleOptionsError("Incorrect options passed") + + # process command line list + text = '' + for plugin in self.args: + textret = self.format_plugin_doc(plugin, loader, plugin_type, search_paths) + + if textret: + text += textret + + if text: + self.pager(text) + + return 0 + + def get_all_plugins_of_type(self, plugin_type): + loader = getattr(plugin_loader, '%s_loader' % plugin_type) + plugin_list = set() + paths = loader._get_paths() + for path in paths: + plugins_to_add = self.find_plugins(path, plugin_type) + plugin_list.update(plugins_to_add) + return sorted(set(plugin_list)) + + def get_plugin_metadata(self, plugin_type, plugin_name): + # if the plugin lives in a non-python file (eg, win_X.ps1), require the corresponding python file for docs + loader = getattr(plugin_loader, '%s_loader' % plugin_type) + filename = loader.find_plugin(plugin_name, mod_type='.py', ignore_deprecated=True, check_aliases=True) + if filename is None: + raise AnsibleError("unable to load {0} plugin named {1} ".format(plugin_type, plugin_name)) + + try: + doc, __, __, metadata = get_docstring(filename, fragment_loader, verbose=(self.options.verbosity > 0)) + except Exception: + display.vvv(traceback.format_exc()) + raise AnsibleError( + "%s %s at %s has a documentation error formatting or is missing documentation." % + (plugin_type, plugin_name, filename)) + + if doc is None: + if 'removed' not in metadata.get('status', []): + raise AnsibleError( + "%s %s at %s has a documentation error formatting or is missing documentation." % + (plugin_type, plugin_name, filename)) + + # Removed plugins don't have any documentation + return None + + return dict( + name=plugin_name, + namespace=self.namespace_from_plugin_filepath(filename, plugin_name, loader.package_path), + description=doc.get('short_description', "UNKNOWN"), + version_added=doc.get('version_added', "UNKNOWN") + ) + + def namespace_from_plugin_filepath(self, filepath, plugin_name, basedir): + if not basedir.endswith('/'): + basedir += '/' + rel_path = filepath.replace(basedir, '') + extension_free = os.path.splitext(rel_path)[0] + namespace_only = extension_free.rsplit(plugin_name, 1)[0].strip('/_') + clean_ns = namespace_only.replace('/', '.') + if clean_ns == '': + clean_ns = None + + return clean_ns + + def format_plugin_doc(self, plugin, loader, plugin_type, search_paths): + text = '' + + try: + # if the plugin lives in a non-python file (eg, win_X.ps1), require the corresponding python file for docs + filename = loader.find_plugin(plugin, mod_type='.py', ignore_deprecated=True, check_aliases=True) + if filename is None: + display.warning("%s %s not found in:\n%s\n" % (plugin_type, plugin, search_paths)) + return + + if any(filename.endswith(x) for x in C.BLACKLIST_EXTS): + return + + try: + doc, plainexamples, returndocs, metadata = get_docstring(filename, fragment_loader, + verbose=(self.options.verbosity > 0)) + except Exception: + display.vvv(traceback.format_exc()) + display.error( + "%s %s has a documentation error formatting or is missing documentation." % (plugin_type, plugin), + wrap_text=False) + return + + if doc is not None: + + # assign from other sections + doc['plainexamples'] = plainexamples + doc['returndocs'] = returndocs + doc['metadata'] = metadata + + # generate extra data + if plugin_type == 'module': + # is there corresponding action plugin? + if plugin in action_loader: + doc['action'] = True + else: + doc['action'] = False + doc['filename'] = filename + doc['now_date'] = datetime.date.today().strftime('%Y-%m-%d') + if 'docuri' in doc: + doc['docuri'] = doc[plugin_type].replace('_', '-') + + if self.options.show_snippet and plugin_type == 'module': + text += self.get_snippet_text(doc) + else: + text += self.get_man_text(doc) + + return text + else: + if 'removed' in metadata.get('status', []): + display.warning("%s %s has been removed\n" % (plugin_type, plugin)) + return + + # this typically means we couldn't even parse the docstring, not just that the YAML is busted, + # probably a quoting issue. + raise AnsibleError("Parsing produced an empty object.") + except Exception as e: + display.vvv(traceback.format_exc()) + raise AnsibleError( + "%s %s missing documentation (or could not parse documentation): %s\n" % (plugin_type, plugin, str(e))) + + def find_plugins(self, path, ptype): + + display.vvvv("Searching %s for plugins" % path) + + plugin_list = set() + + if not os.path.exists(path): + display.vvvv("%s does not exist" % path) + return plugin_list + + bkey = ptype.upper() + for plugin in os.listdir(path): + display.vvvv("Found %s" % plugin) + full_path = '/'.join([path, plugin]) + + if plugin.startswith('.'): + continue + elif os.path.isdir(full_path): + continue + elif any(plugin.endswith(x) for x in C.BLACKLIST_EXTS): + continue + elif plugin.startswith('__'): + continue + elif plugin in C.IGNORE_FILES: + continue + elif plugin .startswith('_'): + if os.path.islink(full_path): # avoids aliases + continue + + plugin = os.path.splitext(plugin)[0] # removes the extension + plugin = plugin.lstrip('_') # remove underscore from deprecated plugins + + if plugin not in BLACKLIST.get(bkey, ()): + plugin_list.add(plugin) + display.vvvv("Added %s" % plugin) + + return plugin_list + + def get_plugin_list_text(self, loader): + columns = display.columns + displace = max(len(x) for x in self.plugin_list) + linelimit = columns - displace - 5 + text = [] + deprecated = [] + for plugin in sorted(self.plugin_list): + + try: + # if the module lives in a non-python file (eg, win_X.ps1), require the corresponding python file for docs + filename = loader.find_plugin(plugin, mod_type='.py', ignore_deprecated=True, check_aliases=True) + + if filename is None: + continue + if filename.endswith(".ps1"): + continue + if os.path.isdir(filename): + continue + + doc = None + try: + doc = read_docstub(filename) + except Exception: + display.warning("%s has a documentation formatting error" % plugin) + continue + + if not doc or not isinstance(doc, dict): + with open(filename) as f: + metadata = extract_metadata(module_data=f.read()) + if metadata[0]: + if 'removed' not in metadata[0].get('status', []): + display.warning("%s parsing did not produce documentation." % plugin) + else: + continue + desc = 'UNDOCUMENTED' + else: + desc = self.tty_ify(doc.get('short_description', 'INVALID SHORT DESCRIPTION').strip()) + + if len(desc) > linelimit: + desc = desc[:linelimit] + '...' + + if plugin.startswith('_'): # Handle deprecated + deprecated.append("%-*s %-*.*s" % (displace, plugin[1:], linelimit, len(desc), desc)) + else: + text.append("%-*s %-*.*s" % (displace, plugin, linelimit, len(desc), desc)) + except Exception as e: + raise AnsibleError("Failed reading docs at %s: %s" % (plugin, to_native(e)), orig_exc=e) + + if len(deprecated) > 0: + text.append("\nDEPRECATED:") + text.extend(deprecated) + return "\n".join(text) + + def get_plugin_list_filenames(self, loader): + columns = display.columns + displace = max(len(x) for x in self.plugin_list) + linelimit = columns - displace - 5 + text = [] + + for plugin in sorted(self.plugin_list): + + try: + # if the module lives in a non-python file (eg, win_X.ps1), require the corresponding python file for docs + filename = loader.find_plugin(plugin, mod_type='.py', ignore_deprecated=True, check_aliases=True) + + if filename is None: + continue + if filename.endswith(".ps1"): + continue + if os.path.isdir(filename): + continue + + text.append("%-*s %-*.*s" % (displace, plugin, linelimit, len(filename), filename)) + + except Exception as e: + raise AnsibleError("Failed reading docs at %s: %s" % (plugin, to_native(e)), orig_exc=e) + + return "\n".join(text) + + @staticmethod + def print_paths(finder): + ''' Returns a string suitable for printing of the search path ''' + + # Uses a list to get the order right + ret = [] + for i in finder._get_paths(subdirs=False): + if i not in ret: + ret.append(i) + return os.pathsep.join(ret) + + def get_snippet_text(self, doc): + + text = [] + desc = CLI.tty_ify(doc['short_description']) + text.append("- name: %s" % (desc)) + text.append(" %s:" % (doc['module'])) + pad = 31 + subdent = " " * pad + limit = display.columns - pad + + for o in sorted(doc['options'].keys()): + opt = doc['options'][o] + if isinstance(opt['description'], string_types): + desc = CLI.tty_ify(opt['description']) + else: + desc = CLI.tty_ify(" ".join(opt['description'])) + + required = opt.get('required', False) + if not isinstance(required, bool): + raise("Incorrect value for 'Required', a boolean is needed.: %s" % required) + if required: + desc = "(required) %s" % desc + o = '%s:' % o + text.append(" %-20s # %s" % (o, textwrap.fill(desc, limit, subsequent_indent=subdent))) + text.append('') + + return "\n".join(text) + + def _dump_yaml(self, struct, indent): + return CLI.tty_ify('\n'.join([indent + line for line in yaml.dump(struct, default_flow_style=False, Dumper=AnsibleDumper).split('\n')])) + + def add_fields(self, text, fields, limit, opt_indent): + + for o in sorted(fields): + opt = fields[o] + + required = opt.pop('required', False) + if not isinstance(required, bool): + raise AnsibleError("Incorrect value for 'Required', a boolean is needed.: %s" % required) + if required: + opt_leadin = "=" + else: + opt_leadin = "-" + + text.append("%s %s" % (opt_leadin, o)) + + if isinstance(opt['description'], list): + for entry in opt['description']: + text.append(textwrap.fill(CLI.tty_ify(entry), limit, initial_indent=opt_indent, subsequent_indent=opt_indent)) + else: + text.append(textwrap.fill(CLI.tty_ify(opt['description']), limit, initial_indent=opt_indent, subsequent_indent=opt_indent)) + del opt['description'] + + aliases = '' + if 'aliases' in opt: + if len(opt['aliases']) > 0: + aliases = "(Aliases: " + ", ".join(str(i) for i in opt['aliases']) + ")" + del opt['aliases'] + choices = '' + if 'choices' in opt: + if len(opt['choices']) > 0: + choices = "(Choices: " + ", ".join(str(i) for i in opt['choices']) + ")" + del opt['choices'] + default = '' + if 'default' in opt or not required: + default = "[Default: %s" % str(opt.pop('default', '(null)')) + "]" + + text.append(textwrap.fill(CLI.tty_ify(aliases + choices + default), limit, initial_indent=opt_indent, subsequent_indent=opt_indent)) + + if 'options' in opt: + text.append("%soptions:\n" % opt_indent) + self.add_fields(text, opt.pop('options'), limit, opt_indent + opt_indent) + + if 'spec' in opt: + text.append("%sspec:\n" % opt_indent) + self.add_fields(text, opt.pop('spec'), limit, opt_indent + opt_indent) + + conf = {} + for config in ('env', 'ini', 'yaml', 'vars', 'keywords'): + if config in opt and opt[config]: + conf[config] = opt.pop(config) + for ignore in self.IGNORE: + for item in conf[config]: + if ignore in item: + del item[ignore] + + if conf: + text.append(self._dump_yaml({'set_via': conf}, opt_indent)) + + for k in sorted(opt): + if k.startswith('_'): + continue + if isinstance(opt[k], string_types): + text.append('%s%s: %s' % (opt_indent, k, textwrap.fill(CLI.tty_ify(opt[k]), limit - (len(k) + 2), subsequent_indent=opt_indent))) + elif isinstance(opt[k], (Sequence)) and all(isinstance(x, string_types) for x in opt[k]): + text.append(CLI.tty_ify('%s%s: %s' % (opt_indent, k, ', '.join(opt[k])))) + else: + text.append(self._dump_yaml({k: opt[k]}, opt_indent)) + text.append('') + + @staticmethod + def get_support_block(doc): + # Note: 'curated' is deprecated and not used in any of the modules we ship + support_level_msg = {'core': 'The Ansible Core Team', + 'network': 'The Ansible Network Team', + 'certified': 'an Ansible Partner', + 'community': 'The Ansible Community', + 'curated': 'A Third Party', + } + if doc['metadata'].get('metadata_version') in ('1.0', '1.1'): + return [" * This module is maintained by %s" % support_level_msg[doc['metadata']['supported_by']]] + + return [] + + @staticmethod + def get_metadata_block(doc): + text = [] + if doc['metadata'].get('metadata_version') in ('1.0', '1.1'): + text.append("METADATA:") + text.append('\tSUPPORT LEVEL: %s' % doc['metadata']['supported_by']) + + for k in (m for m in doc['metadata'] if m not in ('version', 'metadata_version', 'supported_by')): + if isinstance(k, list): + text.append("\t%s: %s" % (k.capitalize(), ", ".join(doc['metadata'][k]))) + else: + text.append("\t%s: %s" % (k.capitalize(), doc['metadata'][k])) + return text + + return [] + + def get_man_text(self, doc): + + self.IGNORE = self.IGNORE + (self.options.type,) + opt_indent = " " + text = [] + pad = display.columns * 0.20 + limit = max(display.columns - int(pad), 70) + + text.append("> %s (%s)\n" % (doc.get(self.options.type, doc.get('plugin_type')).upper(), doc.pop('filename'))) + + if isinstance(doc['description'], list): + desc = " ".join(doc.pop('description')) + else: + desc = doc.pop('description') + + text.append("%s\n" % textwrap.fill(CLI.tty_ify(desc), limit, initial_indent=opt_indent, subsequent_indent=opt_indent)) + + if 'deprecated' in doc and doc['deprecated'] is not None and len(doc['deprecated']) > 0: + text.append("DEPRECATED: \n") + if isinstance(doc['deprecated'], dict): + if 'version' in doc['deprecated'] and 'removed_in' not in doc['deprecated']: + doc['deprecated']['removed_in'] = doc['deprecated']['version'] + text.append("\tReason: %(why)s\n\tWill be removed in: Ansible %(removed_in)s\n\tAlternatives: %(alternative)s" % doc.pop('deprecated')) + else: + text.append("%s" % doc.pop('deprecated')) + text.append("\n") + + try: + support_block = self.get_support_block(doc) + if support_block: + text.extend(support_block) + except Exception: + pass # FIXME: not suported by plugins + + if doc.pop('action', False): + text.append(" * note: %s\n" % "This module has a corresponding action plugin.") + + if 'options' in doc and doc['options']: + text.append("OPTIONS (= is mandatory):\n") + self.add_fields(text, doc.pop('options'), limit, opt_indent) + text.append('') + + if 'notes' in doc and doc['notes'] and len(doc['notes']) > 0: + text.append("NOTES:") + for note in doc['notes']: + text.append(textwrap.fill(CLI.tty_ify(note), limit - 6, initial_indent=opt_indent[:-2] + "* ", subsequent_indent=opt_indent)) + text.append('') + text.append('') + del doc['notes'] + + if 'seealso' in doc and doc['seealso']: + text.append("SEE ALSO:") + for item in doc['seealso']: + if 'module' in item and 'description' in item: + text.append(textwrap.fill(CLI.tty_ify('Module %s' % item['module']), + limit - 6, initial_indent=opt_indent[:-2] + "* ", subsequent_indent=opt_indent)) + text.append(textwrap.fill(CLI.tty_ify(item['description']), + limit - 6, initial_indent=opt_indent, subsequent_indent=opt_indent)) + text.append(textwrap.fill(CLI.tty_ify('https://docs.ansible.com/ansible/latest/modules/%s_module.html' % item['module']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent)) + elif 'module' in item: + text.append(textwrap.fill(CLI.tty_ify('Module %s' % item['module']), + limit - 6, initial_indent=opt_indent[:-2] + "* ", subsequent_indent=opt_indent)) + text.append(textwrap.fill(CLI.tty_ify('The official documentation on the %s module.' % item['module']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent + ' ')) + text.append(textwrap.fill(CLI.tty_ify('https://docs.ansible.com/ansible/latest/modules/%s_module.html' % item['module']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent)) + elif 'name' in item and 'link' in item and 'description' in item: + text.append(textwrap.fill(CLI.tty_ify(item['name']), + limit - 6, initial_indent=opt_indent[:-2] + "* ", subsequent_indent=opt_indent)) + text.append(textwrap.fill(CLI.tty_ify(item['description']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent + ' ')) + text.append(textwrap.fill(CLI.tty_ify(item['link']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent + ' ')) + elif 'ref' in item and 'description' in item: + text.append(textwrap.fill(CLI.tty_ify('Ansible documentation [%s]' % item['ref']), + limit - 6, initial_indent=opt_indent[:-2] + "* ", subsequent_indent=opt_indent)) + text.append(textwrap.fill(CLI.tty_ify(item['description']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent + ' ')) + text.append(textwrap.fill(CLI.tty_ify('https://docs.ansible.com/ansible/latest/#stq=%s&stp=1' % item['ref']), + limit - 6, initial_indent=opt_indent + ' ', subsequent_indent=opt_indent + ' ')) + + text.append('') + text.append('') + del doc['seealso'] + + if 'requirements' in doc and doc['requirements'] is not None and len(doc['requirements']) > 0: + req = ", ".join(doc.pop('requirements')) + text.append("REQUIREMENTS:%s\n" % textwrap.fill(CLI.tty_ify(req), limit - 16, initial_indent=" ", subsequent_indent=opt_indent)) + + # Generic handler + for k in sorted(doc): + if k in self.IGNORE or not doc[k]: + continue + if isinstance(doc[k], string_types): + text.append('%s: %s' % (k.upper(), textwrap.fill(CLI.tty_ify(doc[k]), limit - (len(k) + 2), subsequent_indent=opt_indent))) + elif isinstance(doc[k], (list, tuple)): + text.append('%s: %s' % (k.upper(), ', '.join(doc[k]))) + else: + text.append(self._dump_yaml({k.upper(): doc[k]}, opt_indent)) + del doc[k] + text.append('') + + if 'plainexamples' in doc and doc['plainexamples'] is not None: + text.append("EXAMPLES:") + text.append('') + if isinstance(doc['plainexamples'], string_types): + text.append(doc.pop('plainexamples').strip()) + else: + text.append(yaml.dump(doc.pop('plainexamples'), indent=2, default_flow_style=False)) + text.append('') + text.append('') + + if 'returndocs' in doc and doc['returndocs'] is not None: + text.append("RETURN VALUES:") + if isinstance(doc['returndocs'], string_types): + text.append(doc.pop('returndocs')) + else: + text.append(yaml.dump(doc.pop('returndocs'), indent=2, default_flow_style=False)) + text.append('') + + try: + metadata_block = self.get_metadata_block(doc) + if metadata_block: + text.extend(metadata_block) + text.append('') + except Exception: + pass # metadata is optional + + return "\n".join(text) diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/galaxy.py b/env_27/lib/python2.7/site-packages/ansible/cli/galaxy.py new file mode 100644 index 0000000..631f368 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/galaxy.py @@ -0,0 +1,691 @@ +######################################################################## +# +# (C) 2013, James Cammarata +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . +# +######################################################################## + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import os.path +import re +import shutil +import sys +import time +import yaml + +from jinja2 import Environment, FileSystemLoader + +import ansible.constants as C +from ansible.cli import CLI +from ansible.errors import AnsibleError, AnsibleOptionsError +from ansible.galaxy import Galaxy +from ansible.galaxy.api import GalaxyAPI +from ansible.galaxy.login import GalaxyLogin +from ansible.galaxy.role import GalaxyRole +from ansible.galaxy.token import GalaxyToken +from ansible.module_utils._text import to_text +from ansible.playbook.role.requirement import RoleRequirement + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class GalaxyCLI(CLI): + '''command to manage Ansible roles in shared repositories, the default of which is Ansible Galaxy *https://galaxy.ansible.com*.''' + + SKIP_INFO_KEYS = ("name", "description", "readme_html", "related", "summary_fields", "average_aw_composite", "average_aw_score", "url") + VALID_ACTIONS = ("delete", "import", "info", "init", "install", "list", "login", "remove", "search", "setup") + + def __init__(self, args): + self.api = None + self.galaxy = None + super(GalaxyCLI, self).__init__(args) + + def set_action(self): + + super(GalaxyCLI, self).set_action() + + # specific to actions + if self.action == "delete": + self.parser.set_usage("usage: %prog delete [options] github_user github_repo") + self.parser.set_description("Removes the role from Galaxy. It does not remove or alter the actual GitHub repository.") + elif self.action == "import": + self.parser.set_usage("usage: %prog import [options] github_user github_repo") + self.parser.set_description("Import a role.") + self.parser.add_option('--no-wait', dest='wait', action='store_false', default=True, help='Don\'t wait for import results.') + self.parser.add_option('--branch', dest='reference', + help='The name of a branch to import. Defaults to the repository\'s default branch (usually master)') + self.parser.add_option('--role-name', dest='role_name', help='The name the role should have, if different than the repo name') + self.parser.add_option('--status', dest='check_status', action='store_true', default=False, + help='Check the status of the most recent import request for given github_user/github_repo.') + elif self.action == "info": + self.parser.set_usage("usage: %prog info [options] role_name[,version]") + self.parser.set_description("View more details about a specific role.") + elif self.action == "init": + self.parser.set_usage("usage: %prog init [options] role_name") + self.parser.set_description("Initialize new role with the base structure of a role.") + self.parser.add_option('--init-path', dest='init_path', default="./", + help='The path in which the skeleton role will be created. The default is the current working directory.') + self.parser.add_option('--type', dest='role_type', action='store', default='default', + help="Initialize using an alternate role type. Valid types include: 'container', 'apb' and 'network'.") + self.parser.add_option('--role-skeleton', dest='role_skeleton', default=C.GALAXY_ROLE_SKELETON, + help='The path to a role skeleton that the new role should be based upon.') + elif self.action == "install": + self.parser.set_usage("usage: %prog install [options] [-r FILE | role_name(s)[,version] | scm+role_repo_url[,version] | tar_file(s)]") + self.parser.set_description("Install Roles from file(s), URL(s) or tar file(s)") + self.parser.add_option('-i', '--ignore-errors', dest='ignore_errors', action='store_true', default=False, + help='Ignore errors and continue with the next specified role.') + self.parser.add_option('-n', '--no-deps', dest='no_deps', action='store_true', default=False, help='Don\'t download roles listed as dependencies') + self.parser.add_option('-r', '--role-file', dest='role_file', help='A file containing a list of roles to be imported') + self.parser.add_option('-g', '--keep-scm-meta', dest='keep_scm_meta', action='store_true', + default=False, help='Use tar instead of the scm archive option when packaging the role') + elif self.action == "remove": + self.parser.set_usage("usage: %prog remove role1 role2 ...") + self.parser.set_description("Delete a role from roles_path.") + elif self.action == "list": + self.parser.set_usage("usage: %prog list [role_name]") + self.parser.set_description("Show the name and version of each role installed in the roles_path.") + elif self.action == "login": + self.parser.set_usage("usage: %prog login [options]") + self.parser.set_description("Login to api.github.com server in order to use ansible-galaxy sub command such as 'import', 'delete' and 'setup'.") + self.parser.add_option('--github-token', dest='token', default=None, help='Identify with github token rather than username and password.') + elif self.action == "search": + self.parser.set_usage("usage: %prog search [searchterm1 searchterm2] [--galaxy-tags galaxy_tag1,galaxy_tag2] [--platforms platform1,platform2] " + "[--author username]") + self.parser.add_option('--platforms', dest='platforms', help='list of OS platforms to filter by') + self.parser.add_option('--galaxy-tags', dest='galaxy_tags', help='list of galaxy tags to filter by') + self.parser.add_option('--author', dest='author', help='GitHub username') + self.parser.set_description("Search the Galaxy database by tags, platforms, author and multiple keywords.") + elif self.action == "setup": + self.parser.set_usage("usage: %prog setup [options] source github_user github_repo secret") + self.parser.add_option('--remove', dest='remove_id', default=None, + help='Remove the integration matching the provided ID value. Use --list to see ID values.') + self.parser.add_option('--list', dest="setup_list", action='store_true', default=False, help='List all of your integrations.') + self.parser.set_description("Manage the integration between Galaxy and the given source.") + # options that apply to more than one action + if self.action in ['init', 'info']: + self.parser.add_option('--offline', dest='offline', default=False, action='store_true', help="Don't query the galaxy API when creating roles") + + if self.action not in ("delete", "import", "init", "login", "setup"): + # NOTE: while the option type=str, the default is a list, and the + # callback will set the value to a list. + self.parser.add_option('-p', '--roles-path', dest='roles_path', action="callback", callback=CLI.unfrack_paths, default=C.DEFAULT_ROLES_PATH, + help='The path to the directory containing your roles. The default is the roles_path configured in your ansible.cfg' + ' file (/etc/ansible/roles if not configured)', type='str') + if self.action in ("init", "install"): + self.parser.add_option('-f', '--force', dest='force', action='store_true', default=False, help='Force overwriting an existing role') + + def parse(self): + ''' create an options parser for bin/ansible ''' + + self.parser = CLI.base_parser( + usage="usage: %%prog [%s] [--help] [options] ..." % "|".join(self.VALID_ACTIONS), + epilog="\nSee '%s --help' for more information on a specific command.\n\n" % os.path.basename(sys.argv[0]), + desc="Perform various Role related operations.", + ) + + # common + self.parser.add_option('-s', '--server', dest='api_server', default=C.GALAXY_SERVER, help='The API server destination') + self.parser.add_option('-c', '--ignore-certs', action='store_true', dest='ignore_certs', default=C.GALAXY_IGNORE_CERTS, + help='Ignore SSL certificate validation errors.') + self.set_action() + + super(GalaxyCLI, self).parse() + + display.verbosity = self.options.verbosity + self.galaxy = Galaxy(self.options) + + def run(self): + + super(GalaxyCLI, self).run() + + self.api = GalaxyAPI(self.galaxy) + self.execute() + + def exit_without_ignore(self, rc=1): + """ + Exits with the specified return code unless the + option --ignore-errors was specified + """ + if not self.options.ignore_errors: + raise AnsibleError('- you can use --ignore-errors to skip failed roles and finish processing the list.') + + def _display_role_info(self, role_info): + + text = [u"", u"Role: %s" % to_text(role_info['name'])] + text.append(u"\tdescription: %s" % role_info.get('description', '')) + + for k in sorted(role_info.keys()): + + if k in self.SKIP_INFO_KEYS: + continue + + if isinstance(role_info[k], dict): + text.append(u"\t%s:" % (k)) + for key in sorted(role_info[k].keys()): + if key in self.SKIP_INFO_KEYS: + continue + text.append(u"\t\t%s: %s" % (key, role_info[k][key])) + else: + text.append(u"\t%s: %s" % (k, role_info[k])) + + return u'\n'.join(text) + +############################ +# execute actions +############################ + + def execute_init(self): + """ + creates the skeleton framework of a role that complies with the galaxy metadata format. + """ + + init_path = self.options.init_path + force = self.options.force + role_skeleton = self.options.role_skeleton + + role_name = self.args.pop(0).strip() if self.args else None + if not role_name: + raise AnsibleOptionsError("- no role name specified for init") + role_path = os.path.join(init_path, role_name) + if os.path.exists(role_path): + if os.path.isfile(role_path): + raise AnsibleError("- the path %s already exists, but is a file - aborting" % role_path) + elif not force: + raise AnsibleError("- the directory %s already exists." + "you can use --force to re-initialize this directory,\n" + "however it will reset any main.yml files that may have\n" + "been modified there already." % role_path) + + inject_data = dict( + role_name=role_name, + author='your name', + description='your description', + company='your company (optional)', + license='license (GPLv2, CC-BY, etc)', + issue_tracker_url='http://example.com/issue/tracker', + min_ansible_version='2.4', + role_type=self.options.role_type + ) + + # create role directory + if not os.path.exists(role_path): + os.makedirs(role_path) + + if role_skeleton is not None: + skeleton_ignore_expressions = C.GALAXY_ROLE_SKELETON_IGNORE + else: + role_skeleton = self.galaxy.default_role_skeleton_path + skeleton_ignore_expressions = ['^.*/.git_keep$'] + + role_skeleton = os.path.expanduser(role_skeleton) + skeleton_ignore_re = [re.compile(x) for x in skeleton_ignore_expressions] + + template_env = Environment(loader=FileSystemLoader(role_skeleton)) + + for root, dirs, files in os.walk(role_skeleton, topdown=True): + rel_root = os.path.relpath(root, role_skeleton) + in_templates_dir = rel_root.split(os.sep, 1)[0] == 'templates' + dirs[:] = [d for d in dirs if not any(r.match(d) for r in skeleton_ignore_re)] + + for f in files: + filename, ext = os.path.splitext(f) + if any(r.match(os.path.join(rel_root, f)) for r in skeleton_ignore_re): + continue + elif ext == ".j2" and not in_templates_dir: + src_template = os.path.join(rel_root, f) + dest_file = os.path.join(role_path, rel_root, filename) + template_env.get_template(src_template).stream(inject_data).dump(dest_file) + else: + f_rel_path = os.path.relpath(os.path.join(root, f), role_skeleton) + shutil.copyfile(os.path.join(root, f), os.path.join(role_path, f_rel_path)) + + for d in dirs: + dir_path = os.path.join(role_path, rel_root, d) + if not os.path.exists(dir_path): + os.makedirs(dir_path) + + display.display("- %s was created successfully" % role_name) + + def execute_info(self): + """ + prints out detailed information about an installed role as well as info available from the galaxy API. + """ + + if len(self.args) == 0: + # the user needs to specify a role + raise AnsibleOptionsError("- you must specify a user/role name") + + roles_path = self.options.roles_path + + data = '' + for role in self.args: + + role_info = {'path': roles_path} + gr = GalaxyRole(self.galaxy, role) + + install_info = gr.install_info + if install_info: + if 'version' in install_info: + install_info['installed_version'] = install_info['version'] + del install_info['version'] + role_info.update(install_info) + + remote_data = False + if not self.options.offline: + remote_data = self.api.lookup_role_by_name(role, False) + + if remote_data: + role_info.update(remote_data) + + if gr.metadata: + role_info.update(gr.metadata) + + req = RoleRequirement() + role_spec = req.role_yaml_parse({'role': role}) + if role_spec: + role_info.update(role_spec) + + data = self._display_role_info(role_info) + # FIXME: This is broken in both 1.9 and 2.0 as + # _display_role_info() always returns something + if not data: + data = u"\n- the role %s was not found" % role + + self.pager(data) + + def execute_install(self): + """ + uses the args list of roles to be installed, unless -f was specified. The list of roles + can be a name (which will be downloaded via the galaxy API and github), or it can be a local .tar.gz file. + """ + role_file = self.options.role_file + + if len(self.args) == 0 and role_file is None: + # the user needs to specify one of either --role-file or specify a single user/role name + raise AnsibleOptionsError("- you must specify a user/role name or a roles file") + + no_deps = self.options.no_deps + force = self.options.force + + roles_left = [] + if role_file: + try: + f = open(role_file, 'r') + if role_file.endswith('.yaml') or role_file.endswith('.yml'): + try: + required_roles = yaml.safe_load(f.read()) + except Exception as e: + raise AnsibleError("Unable to load data from the requirements file: %s" % role_file) + + if required_roles is None: + raise AnsibleError("No roles found in file: %s" % role_file) + + for role in required_roles: + if "include" not in role: + role = RoleRequirement.role_yaml_parse(role) + display.vvv("found role %s in yaml file" % str(role)) + if "name" not in role and "scm" not in role: + raise AnsibleError("Must specify name or src for role") + roles_left.append(GalaxyRole(self.galaxy, **role)) + else: + with open(role["include"]) as f_include: + try: + roles_left += [ + GalaxyRole(self.galaxy, **r) for r in + (RoleRequirement.role_yaml_parse(i) for i in yaml.safe_load(f_include)) + ] + except Exception as e: + msg = "Unable to load data from the include requirements file: %s %s" + raise AnsibleError(msg % (role_file, e)) + else: + raise AnsibleError("Invalid role requirements file") + f.close() + except (IOError, OSError) as e: + raise AnsibleError('Unable to open %s: %s' % (role_file, str(e))) + else: + # roles were specified directly, so we'll just go out grab them + # (and their dependencies, unless the user doesn't want us to). + for rname in self.args: + role = RoleRequirement.role_yaml_parse(rname.strip()) + roles_left.append(GalaxyRole(self.galaxy, **role)) + + for role in roles_left: + # only process roles in roles files when names matches if given + if role_file and self.args and role.name not in self.args: + display.vvv('Skipping role %s' % role.name) + continue + + display.vvv('Processing role %s ' % role.name) + + # query the galaxy API for the role data + + if role.install_info is not None: + if role.install_info['version'] != role.version or force: + if force: + display.display('- changing role %s from %s to %s' % + (role.name, role.install_info['version'], role.version or "unspecified")) + role.remove() + else: + display.warning('- %s (%s) is already installed - use --force to change version to %s' % + (role.name, role.install_info['version'], role.version or "unspecified")) + continue + else: + if not force: + display.display('- %s is already installed, skipping.' % str(role)) + continue + + try: + installed = role.install() + except AnsibleError as e: + display.warning("- %s was NOT installed successfully: %s " % (role.name, str(e))) + self.exit_without_ignore() + continue + + # install dependencies, if we want them + if not no_deps and installed: + if not role.metadata: + display.warning("Meta file %s is empty. Skipping dependencies." % role.path) + else: + role_dependencies = role.metadata.get('dependencies') or [] + for dep in role_dependencies: + display.debug('Installing dep %s' % dep) + dep_req = RoleRequirement() + dep_info = dep_req.role_yaml_parse(dep) + dep_role = GalaxyRole(self.galaxy, **dep_info) + if '.' not in dep_role.name and '.' not in dep_role.src and dep_role.scm is None: + # we know we can skip this, as it's not going to + # be found on galaxy.ansible.com + continue + if dep_role.install_info is None: + if dep_role not in roles_left: + display.display('- adding dependency: %s' % str(dep_role)) + roles_left.append(dep_role) + else: + display.display('- dependency %s already pending installation.' % dep_role.name) + else: + if dep_role.install_info['version'] != dep_role.version: + display.warning('- dependency %s from role %s differs from already installed version (%s), skipping' % + (str(dep_role), role.name, dep_role.install_info['version'])) + else: + display.display('- dependency %s is already installed, skipping.' % dep_role.name) + + if not installed: + display.warning("- %s was NOT installed successfully." % role.name) + self.exit_without_ignore() + + return 0 + + def execute_remove(self): + """ + removes the list of roles passed as arguments from the local system. + """ + + if len(self.args) == 0: + raise AnsibleOptionsError('- you must specify at least one role to remove.') + + for role_name in self.args: + role = GalaxyRole(self.galaxy, role_name) + try: + if role.remove(): + display.display('- successfully removed %s' % role_name) + else: + display.display('- %s is not installed, skipping.' % role_name) + except Exception as e: + raise AnsibleError("Failed to remove role %s: %s" % (role_name, str(e))) + + return 0 + + def execute_list(self): + """ + lists the roles installed on the local system or matches a single role passed as an argument. + """ + + if len(self.args) > 1: + raise AnsibleOptionsError("- please specify only one role to list, or specify no roles to see a full list") + + if len(self.args) == 1: + # show only the request role, if it exists + name = self.args.pop() + gr = GalaxyRole(self.galaxy, name) + if gr.metadata: + install_info = gr.install_info + version = None + if install_info: + version = install_info.get("version", None) + if not version: + version = "(unknown version)" + # show some more info about single roles here + display.display("- %s, %s" % (name, version)) + else: + display.display("- the role %s was not found" % name) + else: + # show all valid roles in the roles_path directory + roles_path = self.options.roles_path + path_found = False + for path in roles_path: + role_path = os.path.expanduser(path) + if not os.path.exists(role_path): + display.warning("- the configured path %s does not exist." % role_path) + continue + elif not os.path.isdir(role_path): + display.warning("- the configured path %s, exists, but it is not a directory." % role_path) + continue + path_files = os.listdir(role_path) + path_found = True + for path_file in path_files: + gr = GalaxyRole(self.galaxy, path_file, path=path) + if gr.metadata: + install_info = gr.install_info + version = None + if install_info: + version = install_info.get("version", None) + if not version: + version = "(unknown version)" + display.display("- %s, %s" % (path_file, version)) + if not path_found: + raise AnsibleOptionsError("- None of the provided paths was usable. Please specify a valid path with --roles-path") + return 0 + + def execute_search(self): + ''' searches for roles on the Ansible Galaxy server''' + page_size = 1000 + search = None + + if len(self.args): + terms = [] + for i in range(len(self.args)): + terms.append(self.args.pop()) + search = '+'.join(terms[::-1]) + + if not search and not self.options.platforms and not self.options.galaxy_tags and not self.options.author: + raise AnsibleError("Invalid query. At least one search term, platform, galaxy tag or author must be provided.") + + response = self.api.search_roles(search, platforms=self.options.platforms, + tags=self.options.galaxy_tags, author=self.options.author, page_size=page_size) + + if response['count'] == 0: + display.display("No roles match your search.", color=C.COLOR_ERROR) + return True + + data = [u''] + + if response['count'] > page_size: + data.append(u"Found %d roles matching your search. Showing first %s." % (response['count'], page_size)) + else: + data.append(u"Found %d roles matching your search:" % response['count']) + + max_len = [] + for role in response['results']: + max_len.append(len(role['username'] + '.' + role['name'])) + name_len = max(max_len) + format_str = u" %%-%ds %%s" % name_len + data.append(u'') + data.append(format_str % (u"Name", u"Description")) + data.append(format_str % (u"----", u"-----------")) + for role in response['results']: + data.append(format_str % (u'%s.%s' % (role['username'], role['name']), role['description'])) + + data = u'\n'.join(data) + self.pager(data) + + return True + + def execute_login(self): + """ + verify user's identify via Github and retrieve an auth token from Ansible Galaxy. + """ + # Authenticate with github and retrieve a token + if self.options.token is None: + if C.GALAXY_TOKEN: + github_token = C.GALAXY_TOKEN + else: + login = GalaxyLogin(self.galaxy) + github_token = login.create_github_token() + else: + github_token = self.options.token + + galaxy_response = self.api.authenticate(github_token) + + if self.options.token is None and C.GALAXY_TOKEN is None: + # Remove the token we created + login.remove_github_token() + + # Store the Galaxy token + token = GalaxyToken() + token.set(galaxy_response['token']) + + display.display("Successfully logged into Galaxy as %s" % galaxy_response['username']) + return 0 + + def execute_import(self): + """ used to import a role into Ansible Galaxy """ + + colors = { + 'INFO': 'normal', + 'WARNING': C.COLOR_WARN, + 'ERROR': C.COLOR_ERROR, + 'SUCCESS': C.COLOR_OK, + 'FAILED': C.COLOR_ERROR, + } + + if len(self.args) < 2: + raise AnsibleError("Expected a github_username and github_repository. Use --help.") + + github_repo = to_text(self.args.pop(), errors='surrogate_or_strict') + github_user = to_text(self.args.pop(), errors='surrogate_or_strict') + + if self.options.check_status: + task = self.api.get_import_task(github_user=github_user, github_repo=github_repo) + else: + # Submit an import request + task = self.api.create_import_task(github_user, github_repo, reference=self.options.reference, role_name=self.options.role_name) + + if len(task) > 1: + # found multiple roles associated with github_user/github_repo + display.display("WARNING: More than one Galaxy role associated with Github repo %s/%s." % (github_user, github_repo), + color='yellow') + display.display("The following Galaxy roles are being updated:" + u'\n', color=C.COLOR_CHANGED) + for t in task: + display.display('%s.%s' % (t['summary_fields']['role']['namespace'], t['summary_fields']['role']['name']), color=C.COLOR_CHANGED) + display.display(u'\nTo properly namespace this role, remove each of the above and re-import %s/%s from scratch' % (github_user, github_repo), + color=C.COLOR_CHANGED) + return 0 + # found a single role as expected + display.display("Successfully submitted import request %d" % task[0]['id']) + if not self.options.wait: + display.display("Role name: %s" % task[0]['summary_fields']['role']['name']) + display.display("Repo: %s/%s" % (task[0]['github_user'], task[0]['github_repo'])) + + if self.options.check_status or self.options.wait: + # Get the status of the import + msg_list = [] + finished = False + while not finished: + task = self.api.get_import_task(task_id=task[0]['id']) + for msg in task[0]['summary_fields']['task_messages']: + if msg['id'] not in msg_list: + display.display(msg['message_text'], color=colors[msg['message_type']]) + msg_list.append(msg['id']) + if task[0]['state'] in ['SUCCESS', 'FAILED']: + finished = True + else: + time.sleep(10) + + return 0 + + def execute_setup(self): + """ Setup an integration from Github or Travis for Ansible Galaxy roles""" + + if self.options.setup_list: + # List existing integration secrets + secrets = self.api.list_secrets() + if len(secrets) == 0: + # None found + display.display("No integrations found.") + return 0 + display.display(u'\n' + "ID Source Repo", color=C.COLOR_OK) + display.display("---------- ---------- ----------", color=C.COLOR_OK) + for secret in secrets: + display.display("%-10s %-10s %s/%s" % (secret['id'], secret['source'], secret['github_user'], + secret['github_repo']), color=C.COLOR_OK) + return 0 + + if self.options.remove_id: + # Remove a secret + self.api.remove_secret(self.options.remove_id) + display.display("Secret removed. Integrations using this secret will not longer work.", color=C.COLOR_OK) + return 0 + + if len(self.args) < 4: + raise AnsibleError("Missing one or more arguments. Expecting: source github_user github_repo secret") + + secret = self.args.pop() + github_repo = self.args.pop() + github_user = self.args.pop() + source = self.args.pop() + + resp = self.api.add_secret(source, github_user, github_repo, secret) + display.display("Added integration for %s %s/%s" % (resp['source'], resp['github_user'], resp['github_repo'])) + + return 0 + + def execute_delete(self): + """ Delete a role from Ansible Galaxy. """ + + if len(self.args) < 2: + raise AnsibleError("Missing one or more arguments. Expected: github_user github_repo") + + github_repo = self.args.pop() + github_user = self.args.pop() + resp = self.api.delete_role(github_user, github_repo) + + if len(resp['deleted_roles']) > 1: + display.display("Deleted the following roles:") + display.display("ID User Name") + display.display("------ --------------- ----------") + for role in resp['deleted_roles']: + display.display("%-8s %-15s %s" % (role.id, role.namespace, role.name)) + + display.display(resp['status']) + + return True diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/inventory.py b/env_27/lib/python2.7/site-packages/ansible/cli/inventory.py new file mode 100644 index 0000000..788a9fa --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/inventory.py @@ -0,0 +1,385 @@ +# (c) 2017, Brian Coca +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . +# + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import optparse +from operator import attrgetter + +from ansible import constants as C +from ansible.cli import CLI +from ansible.errors import AnsibleError, AnsibleOptionsError +from ansible.inventory.host import Host +from ansible.plugins.loader import vars_loader +from ansible.parsing.dataloader import DataLoader +from ansible.utils.vars import combine_vars + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + +INTERNAL_VARS = frozenset(['ansible_diff_mode', + 'ansible_facts', + 'ansible_forks', + 'ansible_inventory_sources', + 'ansible_limit', + 'ansible_playbook_python', + 'ansible_run_tags', + 'ansible_skip_tags', + 'ansible_verbosity', + 'ansible_version', + 'inventory_dir', + 'inventory_file', + 'inventory_hostname', + 'inventory_hostname_short', + 'groups', + 'group_names', + 'omit', + 'playbook_dir', ]) + + +class InventoryCLI(CLI): + ''' used to display or dump the configured inventory as Ansible sees it ''' + + ARGUMENTS = {'host': 'The name of a host to match in the inventory, relevant when using --list', + 'group': 'The name of a group in the inventory, relevant when using --graph', } + + def __init__(self, args): + + super(InventoryCLI, self).__init__(args) + self.vm = None + self.loader = None + self.inventory = None + + self._new_api = True + + def parse(self): + + self.parser = CLI.base_parser( + usage='usage: %prog [options] [host|group]', + epilog='Show Ansible inventory information, by default it uses the inventory script JSON format', + inventory_opts=True, + vault_opts=True, + basedir_opts=True, + ) + + # remove unused default options + self.parser.remove_option('--limit') + self.parser.remove_option('--list-hosts') + + # Actions + action_group = optparse.OptionGroup(self.parser, "Actions", "One of following must be used on invocation, ONLY ONE!") + action_group.add_option("--list", action="store_true", default=False, dest='list', help='Output all hosts info, works as inventory script') + action_group.add_option("--host", action="store", default=None, dest='host', help='Output specific host info, works as inventory script') + action_group.add_option("--graph", action="store_true", default=False, dest='graph', + help='create inventory graph, if supplying pattern it must be a valid group name') + self.parser.add_option_group(action_group) + + # graph + self.parser.add_option("-y", "--yaml", action="store_true", default=False, dest='yaml', + help='Use YAML format instead of default JSON, ignored for --graph') + self.parser.add_option("--vars", action="store_true", default=False, dest='show_vars', + help='Add vars to graph display, ignored unless used with --graph') + + # list + self.parser.add_option("--export", action="store_true", default=C.INVENTORY_EXPORT, dest='export', + help="When doing an --list, represent in a way that is optimized for export," + "not as an accurate representation of how Ansible has processed it") + # self.parser.add_option("--ignore-vars-plugins", action="store_true", default=False, dest='ignore_vars_plugins', + # help="When doing an --list, skip vars data from vars plugins, by default, this would include group_vars/ and host_vars/") + + super(InventoryCLI, self).parse() + + display.verbosity = self.options.verbosity + + self.validate_conflicts(vault_opts=True) + + # there can be only one! and, at least, one! + used = 0 + for opt in (self.options.list, self.options.host, self.options.graph): + if opt: + used += 1 + if used == 0: + raise AnsibleOptionsError("No action selected, at least one of --host, --graph or --list needs to be specified.") + elif used > 1: + raise AnsibleOptionsError("Conflicting options used, only one of --host, --graph or --list can be used at the same time.") + + # set host pattern to default if not supplied + if len(self.args) > 0: + self.options.pattern = self.args[0] + else: + self.options.pattern = 'all' + + def run(self): + + results = None + + super(InventoryCLI, self).run() + + # Initialize needed objects + if getattr(self, '_play_prereqs', False): + self.loader, self.inventory, self.vm = self._play_prereqs(self.options) + else: + # fallback to pre 2.4 way of initialzing + from ansible.vars import VariableManager + from ansible.inventory import Inventory + + self._new_api = False + self.loader = DataLoader() + self.vm = VariableManager() + + # use vault if needed + if self.options.vault_password_file: + vault_pass = CLI.read_vault_password_file(self.options.vault_password_file, loader=self.loader) + elif self.options.ask_vault_pass: + vault_pass = self.ask_vault_passwords() + else: + vault_pass = None + + if vault_pass: + self.loader.set_vault_password(vault_pass) + # actually get inventory and vars + + self.inventory = Inventory(loader=self.loader, variable_manager=self.vm, host_list=self.options.inventory) + self.vm.set_inventory(self.inventory) + + if self.options.host: + hosts = self.inventory.get_hosts(self.options.host) + if len(hosts) != 1: + raise AnsibleOptionsError("You must pass a single valid host to --host parameter") + + myvars = self._get_host_variables(host=hosts[0]) + self._remove_internal(myvars) + + # FIXME: should we template first? + results = self.dump(myvars) + + elif self.options.graph: + results = self.inventory_graph() + elif self.options.list: + top = self._get_group('all') + if self.options.yaml: + results = self.yaml_inventory(top) + else: + results = self.json_inventory(top) + results = self.dump(results) + + if results: + # FIXME: pager? + display.display(results) + exit(0) + + exit(1) + + def dump(self, stuff): + + if self.options.yaml: + import yaml + from ansible.parsing.yaml.dumper import AnsibleDumper + results = yaml.dump(stuff, Dumper=AnsibleDumper, default_flow_style=False) + else: + import json + from ansible.parsing.ajson import AnsibleJSONEncoder + results = json.dumps(stuff, cls=AnsibleJSONEncoder, sort_keys=True, indent=4) + + return results + + # FIXME: refactor to use same for VM + def get_plugin_vars(self, path, entity): + + data = {} + + def _get_plugin_vars(plugin, path, entities): + data = {} + try: + data = plugin.get_vars(self.loader, path, entity) + except AttributeError: + try: + if isinstance(entity, Host): + data = combine_vars(data, plugin.get_host_vars(entity.name)) + else: + data = combine_vars(data, plugin.get_group_vars(entity.name)) + except AttributeError: + if hasattr(plugin, 'run'): + raise AnsibleError("Cannot use v1 type vars plugin %s from %s" % (plugin._load_name, plugin._original_path)) + else: + raise AnsibleError("Invalid vars plugin %s from %s" % (plugin._load_name, plugin._original_path)) + return data + + for plugin in vars_loader.all(): + data = combine_vars(data, _get_plugin_vars(plugin, path, entity)) + + return data + + def _get_group_variables(self, group): + + # get info from inventory source + res = group.get_vars() + + # FIXME: add switch to skip vars plugins, add vars plugin info + for inventory_dir in self.inventory._sources: + res = combine_vars(res, self.get_plugin_vars(inventory_dir, group)) + + if group.priority != 1: + res['ansible_group_priority'] = group.priority + + return res + + def _get_host_variables(self, host): + + if self.options.export: + hostvars = host.get_vars() + + # FIXME: add switch to skip vars plugins + # add vars plugin info + for inventory_dir in self.inventory._sources: + hostvars = combine_vars(hostvars, self.get_plugin_vars(inventory_dir, host)) + else: + if self._new_api: + hostvars = self.vm.get_vars(host=host, include_hostvars=False) + else: + hostvars = self.vm.get_vars(self.loader, host=host, include_hostvars=False) + + return hostvars + + def _get_group(self, gname): + if self._new_api: + group = self.inventory.groups.get(gname) + else: + group = self.inventory.get_group(gname) + return group + + def _remove_internal(self, dump): + + for internal in INTERNAL_VARS: + if internal in dump: + del dump[internal] + + def _remove_empty(self, dump): + # remove empty keys + for x in ('hosts', 'vars', 'children'): + if x in dump and not dump[x]: + del dump[x] + + def _show_vars(self, dump, depth): + result = [] + self._remove_internal(dump) + if self.options.show_vars: + for (name, val) in sorted(dump.items()): + result.append(self._graph_name('{%s = %s}' % (name, val), depth)) + return result + + def _graph_name(self, name, depth=0): + if depth: + name = " |" * (depth) + "--%s" % name + return name + + def _graph_group(self, group, depth=0): + + result = [self._graph_name('@%s:' % group.name, depth)] + depth = depth + 1 + for kid in sorted(group.child_groups, key=attrgetter('name')): + result.extend(self._graph_group(kid, depth)) + + if group.name != 'all': + for host in sorted(group.hosts, key=attrgetter('name')): + result.append(self._graph_name(host.name, depth)) + result.extend(self._show_vars(host.get_vars(), depth + 1)) + + result.extend(self._show_vars(self._get_group_variables(group), depth)) + + return result + + def inventory_graph(self): + + start_at = self._get_group(self.options.pattern) + if start_at: + return '\n'.join(self._graph_group(start_at)) + else: + raise AnsibleOptionsError("Pattern must be valid group name when using --graph") + + def json_inventory(self, top): + + def format_group(group): + results = {} + results[group.name] = {} + if group.name != 'all': + results[group.name]['hosts'] = [h.name for h in sorted(group.hosts, key=attrgetter('name'))] + results[group.name]['children'] = [] + for subgroup in sorted(group.child_groups, key=attrgetter('name')): + results[group.name]['children'].append(subgroup.name) + results.update(format_group(subgroup)) + if self.options.export: + results[group.name]['vars'] = self._get_group_variables(group) + + self._remove_empty(results[group.name]) + + return results + + results = format_group(top) + + # populate meta + results['_meta'] = {'hostvars': {}} + hosts = self.inventory.get_hosts() + for host in hosts: + hvars = self._get_host_variables(host) + if hvars: + self._remove_internal(hvars) + results['_meta']['hostvars'][host.name] = hvars + + return results + + def yaml_inventory(self, top): + + seen = [] + + def format_group(group): + results = {} + + # initialize group + vars + results[group.name] = {} + + # subgroups + results[group.name]['children'] = {} + for subgroup in sorted(group.child_groups, key=attrgetter('name')): + if subgroup.name != 'all': + results[group.name]['children'].update(format_group(subgroup)) + + # hosts for group + results[group.name]['hosts'] = {} + if group.name != 'all': + for h in sorted(group.hosts, key=attrgetter('name')): + myvars = {} + if h.name not in seen: # avoid defining host vars more than once + seen.append(h.name) + myvars = self._get_host_variables(host=h) + self._remove_internal(myvars) + results[group.name]['hosts'][h.name] = myvars + + if self.options.export: + + gvars = self._get_group_variables(group) + if gvars: + results[group.name]['vars'] = gvars + + self._remove_empty(results[group.name]) + + return results + + return format_group(top) diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/playbook.py b/env_27/lib/python2.7/site-packages/ansible/cli/playbook.py new file mode 100644 index 0000000..1cbf3e8 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/playbook.py @@ -0,0 +1,196 @@ +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +######################################################## + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import os +import stat + +from ansible.cli import CLI +from ansible.errors import AnsibleError, AnsibleOptionsError +from ansible.executor.playbook_executor import PlaybookExecutor +from ansible.playbook.block import Block +from ansible.playbook.play_context import PlayContext + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class PlaybookCLI(CLI): + ''' the tool to run *Ansible playbooks*, which are a configuration and multinode deployment system. + See the project home page (https://docs.ansible.com) for more information. ''' + + def parse(self): + + # create parser for CLI options + parser = CLI.base_parser( + usage="%prog [options] playbook.yml [playbook2 ...]", + connect_opts=True, + meta_opts=True, + runas_opts=True, + subset_opts=True, + check_opts=True, + inventory_opts=True, + runtask_opts=True, + vault_opts=True, + fork_opts=True, + module_opts=True, + desc="Runs Ansible playbooks, executing the defined tasks on the targeted hosts.", + ) + + # ansible playbook specific opts + parser.add_option('--list-tasks', dest='listtasks', action='store_true', + help="list all tasks that would be executed") + parser.add_option('--list-tags', dest='listtags', action='store_true', + help="list all available tags") + parser.add_option('--step', dest='step', action='store_true', + help="one-step-at-a-time: confirm each task before running") + parser.add_option('--start-at-task', dest='start_at_task', + help="start the playbook at the task matching this name") + + self.parser = parser + super(PlaybookCLI, self).parse() + + if len(self.args) == 0: + raise AnsibleOptionsError("You must specify a playbook file to run") + + display.verbosity = self.options.verbosity + self.validate_conflicts(runas_opts=True, vault_opts=True, fork_opts=True) + + def run(self): + + super(PlaybookCLI, self).run() + + # Note: slightly wrong, this is written so that implicit localhost + # Manage passwords + sshpass = None + becomepass = None + passwords = {} + + # initial error check, to make sure all specified playbooks are accessible + # before we start running anything through the playbook executor + for playbook in self.args: + if not os.path.exists(playbook): + raise AnsibleError("the playbook: %s could not be found" % playbook) + if not (os.path.isfile(playbook) or stat.S_ISFIFO(os.stat(playbook).st_mode)): + raise AnsibleError("the playbook: %s does not appear to be a file" % playbook) + + # don't deal with privilege escalation or passwords when we don't need to + if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax: + self.normalize_become_options() + (sshpass, becomepass) = self.ask_passwords() + passwords = {'conn_pass': sshpass, 'become_pass': becomepass} + + loader, inventory, variable_manager = self._play_prereqs(self.options) + + # (which is not returned in list_hosts()) is taken into account for + # warning if inventory is empty. But it can't be taken into account for + # checking if limit doesn't match any hosts. Instead we don't worry about + # limit if only implicit localhost was in inventory to start with. + # + # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts()) + hosts = CLI.get_host_list(inventory, self.options.subset) + + # flush fact cache if requested + if self.options.flush_cache: + self._flush_cache(inventory, variable_manager) + + # create the playbook executor, which manages running the plays via a task queue manager + pbex = PlaybookExecutor(playbooks=self.args, inventory=inventory, variable_manager=variable_manager, loader=loader, options=self.options, + passwords=passwords) + + results = pbex.run() + + if isinstance(results, list): + for p in results: + + display.display('\nplaybook: %s' % p['playbook']) + for idx, play in enumerate(p['plays']): + if play._included_path is not None: + loader.set_basedir(play._included_path) + else: + pb_dir = os.path.realpath(os.path.dirname(p['playbook'])) + loader.set_basedir(pb_dir) + + msg = "\n play #%d (%s): %s" % (idx + 1, ','.join(play.hosts), play.name) + mytags = set(play.tags) + msg += '\tTAGS: [%s]' % (','.join(mytags)) + + if self.options.listhosts: + playhosts = set(inventory.get_hosts(play.hosts)) + msg += "\n pattern: %s\n hosts (%d):" % (play.hosts, len(playhosts)) + for host in playhosts: + msg += "\n %s" % host + + display.display(msg) + + all_tags = set() + if self.options.listtags or self.options.listtasks: + taskmsg = '' + if self.options.listtasks: + taskmsg = ' tasks:\n' + + def _process_block(b): + taskmsg = '' + for task in b.block: + if isinstance(task, Block): + taskmsg += _process_block(task) + else: + if task.action == 'meta': + continue + + all_tags.update(task.tags) + if self.options.listtasks: + cur_tags = list(mytags.union(set(task.tags))) + cur_tags.sort() + if task.name: + taskmsg += " %s" % task.get_name() + else: + taskmsg += " %s" % task.action + taskmsg += "\tTAGS: [%s]\n" % ', '.join(cur_tags) + + return taskmsg + + all_vars = variable_manager.get_vars(play=play) + play_context = PlayContext(play=play, options=self.options) + for block in play.compile(): + block = block.filter_tagged_tasks(play_context, all_vars) + if not block.has_tasks(): + continue + taskmsg += _process_block(block) + + if self.options.listtags: + cur_tags = list(mytags.union(all_tags)) + cur_tags.sort() + taskmsg += " TASK TAGS: [%s]\n" % ', '.join(cur_tags) + + display.display(taskmsg) + + return 0 + else: + return results + + def _flush_cache(self, inventory, variable_manager): + for host in inventory.list_hosts(): + hostname = host.get_name() + variable_manager.clear_facts(hostname) diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/pull.py b/env_27/lib/python2.7/site-packages/ansible/cli/pull.py new file mode 100644 index 0000000..40b9150 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/pull.py @@ -0,0 +1,341 @@ +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +######################################################## +import datetime +import os +import platform +import random +import shutil +import socket +import sys +import time + +from ansible.cli import CLI +from ansible import constants as C +from ansible.errors import AnsibleOptionsError +from ansible.module_utils._text import to_native, to_text +from ansible.module_utils.six.moves import shlex_quote +from ansible.plugins.loader import module_loader +from ansible.utils.cmd_functions import run_cmd + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +######################################################## + +class PullCLI(CLI): + ''' is used to up a remote copy of ansible on each managed node, + each set to run via cron and update playbook source via a source repository. + This inverts the default *push* architecture of ansible into a *pull* architecture, + which has near-limitless scaling potential. + + The setup playbook can be tuned to change the cron frequency, logging locations, and parameters to ansible-pull. + This is useful both for extreme scale-out as well as periodic remediation. + Usage of the 'fetch' module to retrieve logs from ansible-pull runs would be an + excellent way to gather and analyze remote logs from ansible-pull. + ''' + + DEFAULT_REPO_TYPE = 'git' + DEFAULT_PLAYBOOK = 'local.yml' + REPO_CHOICES = ('git', 'subversion', 'hg', 'bzr') + PLAYBOOK_ERRORS = { + 1: 'File does not exist', + 2: 'File is not readable', + } + SUPPORTED_REPO_MODULES = ['git'] + ARGUMENTS = {'playbook.yml': 'The name of one the YAML format files to run as an Ansible playbook.' + 'This can be a relative path within the checkout. By default, Ansible will' + "look for a playbook based on the host's fully-qualified domain name," + 'on the host hostname and finally a playbook named *local.yml*.', } + + SKIP_INVENTORY_DEFAULTS = True + + def _get_inv_cli(self): + + inv_opts = '' + if getattr(self.options, 'inventory'): + for inv in self.options.inventory: + if isinstance(inv, list): + inv_opts += " -i '%s' " % ','.join(inv) + elif ',' in inv or os.path.exists(inv): + inv_opts += ' -i %s ' % inv + + return inv_opts + + def parse(self): + ''' create an options parser for bin/ansible ''' + + self.parser = CLI.base_parser( + usage='%prog -U [options] []', + connect_opts=True, + vault_opts=True, + runtask_opts=True, + subset_opts=True, + check_opts=False, # prevents conflict of --checkout/-C and --check/-C + inventory_opts=True, + module_opts=True, + runas_prompt_opts=True, + desc="pulls playbooks from a VCS repo and executes them for the local host", + ) + + # options unique to pull + self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run') + self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true', + help='only run the playbook if the repository has been updated') + self.parser.add_option('-s', '--sleep', dest='sleep', default=None, + help='sleep for random interval (between 0 and n number of seconds) before starting. ' + 'This is a useful way to disperse git requests') + self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true', + help='run the playbook even if the repository could not be updated') + self.parser.add_option('-d', '--directory', dest='dest', default=None, help='directory to checkout repository to') + self.parser.add_option('-U', '--url', dest='url', default=None, help='URL of the playbook repository') + self.parser.add_option('--full', dest='fullclone', action='store_true', help='Do a full clone, instead of a shallow one.') + self.parser.add_option('-C', '--checkout', dest='checkout', + help='branch/tag/commit to checkout. Defaults to behavior of repository module.') + self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true', + help='adds the hostkey for the repo url if not already added') + self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE, + help='Repository module name, which ansible will use to check out the repo. Choices are %s. Default is %s.' + % (self.REPO_CHOICES, self.DEFAULT_REPO_TYPE)) + self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true', + help='verify GPG signature of checked out commit, if it fails abort running the playbook. ' + 'This needs the corresponding VCS module to support such an operation') + self.parser.add_option('--clean', dest='clean', default=False, action='store_true', + help='modified files in the working repository will be discarded') + self.parser.add_option('--track-subs', dest='tracksubs', default=False, action='store_true', + help='submodules will track the latest changes. This is equivalent to specifying the --remote flag to git submodule update') + # add a subset of the check_opts flag group manually, as the full set's + # shortcodes conflict with above --checkout/-C + self.parser.add_option("--check", default=False, dest='check', action='store_true', + help="don't make any changes; instead, try to predict some of the changes that may occur") + self.parser.add_option("--diff", default=C.DIFF_ALWAYS, dest='diff', action='store_true', + help="when changing (small) files and templates, show the differences in those files; works great with --check") + + super(PullCLI, self).parse() + + if not self.options.dest: + hostname = socket.getfqdn() + # use a hostname dependent directory, in case of $HOME on nfs + self.options.dest = os.path.join('~/.ansible/pull', hostname) + self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest)) + + if os.path.exists(self.options.dest) and not os.path.isdir(self.options.dest): + raise AnsibleOptionsError("%s is not a valid or accessible directory." % self.options.dest) + + if self.options.sleep: + try: + secs = random.randint(0, int(self.options.sleep)) + self.options.sleep = secs + except ValueError: + raise AnsibleOptionsError("%s is not a number." % self.options.sleep) + + if not self.options.url: + raise AnsibleOptionsError("URL for repository not specified, use -h for help") + + if self.options.module_name not in self.SUPPORTED_REPO_MODULES: + raise AnsibleOptionsError("Unsupported repo module %s, choices are %s" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES))) + + display.verbosity = self.options.verbosity + self.validate_conflicts(vault_opts=True) + + def run(self): + ''' use Runner lib to do SSH things ''' + + super(PullCLI, self).run() + + # log command line + now = datetime.datetime.now() + display.display(now.strftime("Starting Ansible Pull at %F %T")) + display.display(' '.join(sys.argv)) + + # Build Checkout command + # Now construct the ansible command + node = platform.node() + host = socket.getfqdn() + limit_opts = 'localhost,%s,127.0.0.1' % ','.join(set([host, node, host.split('.')[0], node.split('.')[0]])) + base_opts = '-c local ' + if self.options.verbosity > 0: + base_opts += ' -%s' % ''.join(["v" for x in range(0, self.options.verbosity)]) + + # Attempt to use the inventory passed in as an argument + # It might not yet have been downloaded so use localhost as default + inv_opts = self._get_inv_cli() + if not inv_opts: + inv_opts = " -i localhost, " + + # SCM specific options + if self.options.module_name == 'git': + repo_opts = "name=%s dest=%s" % (self.options.url, self.options.dest) + if self.options.checkout: + repo_opts += ' version=%s' % self.options.checkout + + if self.options.accept_host_key: + repo_opts += ' accept_hostkey=yes' + + if self.options.private_key_file: + repo_opts += ' key_file=%s' % self.options.private_key_file + + if self.options.verify: + repo_opts += ' verify_commit=yes' + + if self.options.tracksubs: + repo_opts += ' track_submodules=yes' + + if not self.options.fullclone: + repo_opts += ' depth=1' + elif self.options.module_name == 'subversion': + repo_opts = "repo=%s dest=%s" % (self.options.url, self.options.dest) + if self.options.checkout: + repo_opts += ' revision=%s' % self.options.checkout + if not self.options.fullclone: + repo_opts += ' export=yes' + elif self.options.module_name == 'hg': + repo_opts = "repo=%s dest=%s" % (self.options.url, self.options.dest) + if self.options.checkout: + repo_opts += ' revision=%s' % self.options.checkout + elif self.options.module_name == 'bzr': + repo_opts = "name=%s dest=%s" % (self.options.url, self.options.dest) + if self.options.checkout: + repo_opts += ' version=%s' % self.options.checkout + else: + raise AnsibleOptionsError('Unsupported (%s) SCM module for pull, choices are: %s' % (self.options.module_name, ','.join(self.REPO_CHOICES))) + + # options common to all supported SCMS + if self.options.clean: + repo_opts += ' force=yes' + + path = module_loader.find_plugin(self.options.module_name) + if path is None: + raise AnsibleOptionsError(("module '%s' not found.\n" % self.options.module_name)) + + bin_path = os.path.dirname(os.path.abspath(sys.argv[0])) + # hardcode local and inventory/host as this is just meant to fetch the repo + cmd = '%s/ansible %s %s -m %s -a "%s" all -l "%s"' % (bin_path, inv_opts, base_opts, self.options.module_name, repo_opts, limit_opts) + + for ev in self.options.extra_vars: + cmd += ' -e %s' % shlex_quote(ev) + + # Nap? + if self.options.sleep: + display.display("Sleeping for %d seconds..." % self.options.sleep) + time.sleep(self.options.sleep) + + # RUN the Checkout command + display.debug("running ansible with VCS module to checkout repo") + display.vvvv('EXEC: %s' % cmd) + rc, b_out, b_err = run_cmd(cmd, live=True) + + if rc != 0: + if self.options.force: + display.warning("Unable to update repository. Continuing with (forced) run of playbook.") + else: + return rc + elif self.options.ifchanged and b'"changed": true' not in b_out: + display.display("Repository has not changed, quitting.") + return 0 + + playbook = self.select_playbook(self.options.dest) + if playbook is None: + raise AnsibleOptionsError("Could not find a playbook to run.") + + # Build playbook command + cmd = '%s/ansible-playbook %s %s' % (bin_path, base_opts, playbook) + if self.options.vault_password_files: + for vault_password_file in self.options.vault_password_files: + cmd += " --vault-password-file=%s" % vault_password_file + if self.options.vault_ids: + for vault_id in self.options.vault_ids: + cmd += " --vault-id=%s" % vault_id + + for ev in self.options.extra_vars: + cmd += ' -e %s' % shlex_quote(ev) + if self.options.ask_sudo_pass or self.options.ask_su_pass or self.options.become_ask_pass: + cmd += ' --ask-become-pass' + if self.options.skip_tags: + cmd += ' --skip-tags "%s"' % to_native(u','.join(self.options.skip_tags)) + if self.options.tags: + cmd += ' -t "%s"' % to_native(u','.join(self.options.tags)) + if self.options.subset: + cmd += ' -l "%s"' % self.options.subset + else: + cmd += ' -l "%s"' % limit_opts + if self.options.check: + cmd += ' -C' + if self.options.diff: + cmd += ' -D' + + os.chdir(self.options.dest) + + # redo inventory options as new files might exist now + inv_opts = self._get_inv_cli() + if inv_opts: + cmd += inv_opts + + # RUN THE PLAYBOOK COMMAND + display.debug("running ansible-playbook to do actual work") + display.debug('EXEC: %s' % cmd) + rc, b_out, b_err = run_cmd(cmd, live=True) + + if self.options.purge: + os.chdir('/') + try: + shutil.rmtree(self.options.dest) + except Exception as e: + display.error(u"Failed to remove %s: %s" % (self.options.dest, to_text(e))) + + return rc + + def try_playbook(self, path): + if not os.path.exists(path): + return 1 + if not os.access(path, os.R_OK): + return 2 + return 0 + + def select_playbook(self, path): + playbook = None + if len(self.args) > 0 and self.args[0] is not None: + playbook = os.path.join(path, self.args[0]) + rc = self.try_playbook(playbook) + if rc != 0: + display.warning("%s: %s" % (playbook, self.PLAYBOOK_ERRORS[rc])) + return None + return playbook + else: + fqdn = socket.getfqdn() + hostpb = os.path.join(path, fqdn + '.yml') + shorthostpb = os.path.join(path, fqdn.split('.')[0] + '.yml') + localpb = os.path.join(path, self.DEFAULT_PLAYBOOK) + errors = [] + for pb in [hostpb, shorthostpb, localpb]: + rc = self.try_playbook(pb) + if rc == 0: + playbook = pb + break + else: + errors.append("%s: %s" % (pb, self.PLAYBOOK_ERRORS[rc])) + if playbook is None: + display.warning("\n".join(errors)) + return playbook diff --git a/env_27/lib/python2.7/site-packages/ansible/cli/vault.py b/env_27/lib/python2.7/site-packages/ansible/cli/vault.py new file mode 100644 index 0000000..dcc6177 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/cli/vault.py @@ -0,0 +1,467 @@ +# (c) 2014, James Tanner +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . +# +# ansible-vault is a script that encrypts/decrypts YAML files. See +# https://docs.ansible.com/playbooks_vault.html for more details. + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import os +import sys + +from ansible.cli import CLI +from ansible import constants as C +from ansible.errors import AnsibleOptionsError +from ansible.module_utils._text import to_text, to_bytes +from ansible.parsing.dataloader import DataLoader +from ansible.parsing.vault import VaultEditor, VaultLib, match_encrypt_secret + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class VaultCLI(CLI): + ''' can encrypt any structured data file used by Ansible. + This can include *group_vars/* or *host_vars/* inventory variables, + variables loaded by *include_vars* or *vars_files*, or variable files + passed on the ansible-playbook command line with *-e @file.yml* or *-e @file.json*. + Role variables and defaults are also included! + + Because Ansible tasks, handlers, and other objects are data, these can also be encrypted with vault. + If you'd like to not expose what variables you are using, you can keep an individual task file entirely encrypted. + + The password used with vault currently must be the same for all files you wish to use together at the same time. + ''' + + VALID_ACTIONS = ("create", "decrypt", "edit", "encrypt", "encrypt_string", "rekey", "view") + + FROM_STDIN = "stdin" + FROM_ARGS = "the command line args" + FROM_PROMPT = "the interactive prompt" + + def __init__(self, args): + + self.b_vault_pass = None + self.b_new_vault_pass = None + self.encrypt_string_read_stdin = False + + self.encrypt_secret = None + self.encrypt_vault_id = None + self.new_encrypt_secret = None + self.new_encrypt_vault_id = None + + self.can_output = ['encrypt', 'decrypt', 'encrypt_string'] + + super(VaultCLI, self).__init__(args) + + def set_action(self): + + super(VaultCLI, self).set_action() + + # add output if needed + if self.action in self.can_output: + self.parser.add_option('--output', default=None, dest='output_file', + help='output file name for encrypt or decrypt; use - for stdout', + action="callback", callback=CLI.unfrack_path, type='string') + + # options specific to self.actions + if self.action == "create": + self.parser.set_usage("usage: %prog create [options] file_name") + elif self.action == "decrypt": + self.parser.set_usage("usage: %prog decrypt [options] file_name") + elif self.action == "edit": + self.parser.set_usage("usage: %prog edit [options] file_name") + elif self.action == "view": + self.parser.set_usage("usage: %prog view [options] file_name") + elif self.action == "encrypt": + self.parser.set_usage("usage: %prog encrypt [options] file_name") + # I have no prefence for either dash or underscore + elif self.action == "encrypt_string": + self.parser.add_option('-p', '--prompt', dest='encrypt_string_prompt', + action='store_true', + help="Prompt for the string to encrypt") + self.parser.add_option('-n', '--name', dest='encrypt_string_names', + action='append', + help="Specify the variable name") + self.parser.add_option('--stdin-name', dest='encrypt_string_stdin_name', + default=None, + help="Specify the variable name for stdin") + self.parser.set_usage("usage: %prog encrypt_string [--prompt] [options] string_to_encrypt") + elif self.action == "rekey": + self.parser.set_usage("usage: %prog rekey [options] file_name") + + # For encrypting actions, we can also specify which of multiple vault ids should be used for encrypting + if self.action in ['create', 'encrypt', 'encrypt_string', 'rekey', 'edit']: + self.parser.add_option('--encrypt-vault-id', default=[], dest='encrypt_vault_id', + action='store', type='string', + help='the vault id used to encrypt (required if more than vault-id is provided)') + + def parse(self): + + self.parser = CLI.base_parser( + vault_opts=True, + vault_rekey_opts=True, + usage="usage: %%prog [%s] [options] [vaultfile.yml]" % "|".join(self.VALID_ACTIONS), + desc="encryption/decryption utility for Ansible data files", + epilog="\nSee '%s --help' for more information on a specific command.\n\n" % os.path.basename(sys.argv[0]) + ) + + self.set_action() + + super(VaultCLI, self).parse() + self.validate_conflicts(vault_opts=True, vault_rekey_opts=True) + + display.verbosity = self.options.verbosity + + if self.options.vault_ids: + for vault_id in self.options.vault_ids: + if u';' in vault_id: + raise AnsibleOptionsError("'%s' is not a valid vault id. The character ';' is not allowed in vault ids" % vault_id) + + if self.action not in self.can_output: + if len(self.args) == 0: + raise AnsibleOptionsError("Vault requires at least one filename as a parameter") + else: + # This restriction should remain in place until it's possible to + # load multiple YAML records from a single file, or it's too easy + # to create an encrypted file that can't be read back in. But in + # the meanwhile, "cat a b c|ansible-vault encrypt --output x" is + # a workaround. + if self.options.output_file and len(self.args) > 1: + raise AnsibleOptionsError("At most one input file may be used with the --output option") + + if self.action == 'encrypt_string': + if '-' in self.args or len(self.args) == 0 or self.options.encrypt_string_stdin_name: + self.encrypt_string_read_stdin = True + + # TODO: prompting from stdin and reading from stdin seem mutually exclusive, but verify that. + if self.options.encrypt_string_prompt and self.encrypt_string_read_stdin: + raise AnsibleOptionsError('The --prompt option is not supported if also reading input from stdin') + + def run(self): + super(VaultCLI, self).run() + loader = DataLoader() + + # set default restrictive umask + old_umask = os.umask(0o077) + + vault_ids = self.options.vault_ids + + # there are 3 types of actions, those that just 'read' (decrypt, view) and only + # need to ask for a password once, and those that 'write' (create, encrypt) that + # ask for a new password and confirm it, and 'read/write (rekey) that asks for the + # old password, then asks for a new one and confirms it. + + default_vault_ids = C.DEFAULT_VAULT_IDENTITY_LIST + vault_ids = default_vault_ids + vault_ids + + # TODO: instead of prompting for these before, we could let VaultEditor + # call a callback when it needs it. + if self.action in ['decrypt', 'view', 'rekey', 'edit']: + vault_secrets = self.setup_vault_secrets(loader, + vault_ids=vault_ids, + vault_password_files=self.options.vault_password_files, + ask_vault_pass=self.options.ask_vault_pass) + if not vault_secrets: + raise AnsibleOptionsError("A vault password is required to use Ansible's Vault") + + if self.action in ['encrypt', 'encrypt_string', 'create']: + + encrypt_vault_id = None + # no --encrypt-vault-id self.options.encrypt_vault_id for 'edit' + if self.action not in ['edit']: + encrypt_vault_id = self.options.encrypt_vault_id or C.DEFAULT_VAULT_ENCRYPT_IDENTITY + + vault_secrets = None + vault_secrets = \ + self.setup_vault_secrets(loader, + vault_ids=vault_ids, + vault_password_files=self.options.vault_password_files, + ask_vault_pass=self.options.ask_vault_pass, + create_new_password=True) + + if len(vault_secrets) > 1 and not encrypt_vault_id: + raise AnsibleOptionsError("The vault-ids %s are available to encrypt. Specify the vault-id to encrypt with --encrypt-vault-id" % + ','.join([x[0] for x in vault_secrets])) + + if not vault_secrets: + raise AnsibleOptionsError("A vault password is required to use Ansible's Vault") + + encrypt_secret = match_encrypt_secret(vault_secrets, + encrypt_vault_id=encrypt_vault_id) + + # only one secret for encrypt for now, use the first vault_id and use its first secret + # TODO: exception if more than one? + self.encrypt_vault_id = encrypt_secret[0] + self.encrypt_secret = encrypt_secret[1] + + if self.action in ['rekey']: + encrypt_vault_id = self.options.encrypt_vault_id or C.DEFAULT_VAULT_ENCRYPT_IDENTITY + # print('encrypt_vault_id: %s' % encrypt_vault_id) + # print('default_encrypt_vault_id: %s' % default_encrypt_vault_id) + + # new_vault_ids should only ever be one item, from + # load the default vault ids if we are using encrypt-vault-id + new_vault_ids = [] + if encrypt_vault_id: + new_vault_ids = default_vault_ids + if self.options.new_vault_id: + new_vault_ids.append(self.options.new_vault_id) + + new_vault_password_files = [] + if self.options.new_vault_password_file: + new_vault_password_files.append(self.options.new_vault_password_file) + + new_vault_secrets = \ + self.setup_vault_secrets(loader, + vault_ids=new_vault_ids, + vault_password_files=new_vault_password_files, + ask_vault_pass=self.options.ask_vault_pass, + create_new_password=True) + + if not new_vault_secrets: + raise AnsibleOptionsError("A new vault password is required to use Ansible's Vault rekey") + + # There is only one new_vault_id currently and one new_vault_secret, or we + # use the id specified in --encrypt-vault-id + new_encrypt_secret = match_encrypt_secret(new_vault_secrets, + encrypt_vault_id=encrypt_vault_id) + + self.new_encrypt_vault_id = new_encrypt_secret[0] + self.new_encrypt_secret = new_encrypt_secret[1] + + loader.set_vault_secrets(vault_secrets) + + # FIXME: do we need to create VaultEditor here? its not reused + vault = VaultLib(vault_secrets) + self.editor = VaultEditor(vault) + + self.execute() + + # and restore umask + os.umask(old_umask) + + def execute_encrypt(self): + ''' encrypt the supplied file using the provided vault secret ''' + + if len(self.args) == 0 and sys.stdin.isatty(): + display.display("Reading plaintext input from stdin", stderr=True) + + for f in self.args or ['-']: + # Fixme: use the correct vau + self.editor.encrypt_file(f, self.encrypt_secret, + vault_id=self.encrypt_vault_id, + output_file=self.options.output_file) + + if sys.stdout.isatty(): + display.display("Encryption successful", stderr=True) + + def format_ciphertext_yaml(self, b_ciphertext, indent=None, name=None): + indent = indent or 10 + + block_format_var_name = "" + if name: + block_format_var_name = "%s: " % name + + block_format_header = "%s!vault |" % block_format_var_name + lines = [] + vault_ciphertext = to_text(b_ciphertext) + + lines.append(block_format_header) + for line in vault_ciphertext.splitlines(): + lines.append('%s%s' % (' ' * indent, line)) + + yaml_ciphertext = '\n'.join(lines) + return yaml_ciphertext + + def execute_encrypt_string(self): + ''' encrypt the supplied string using the provided vault secret ''' + b_plaintext = None + + # Holds tuples (the_text, the_source_of_the_string, the variable name if its provided). + b_plaintext_list = [] + + # remove the non-option '-' arg (used to indicate 'read from stdin') from the candidate args so + # we don't add it to the plaintext list + args = [x for x in self.args if x != '-'] + + # We can prompt and read input, or read from stdin, but not both. + if self.options.encrypt_string_prompt: + msg = "String to encrypt: " + + name = None + name_prompt_response = display.prompt('Variable name (enter for no name): ') + + # TODO: enforce var naming rules? + if name_prompt_response != "": + name = name_prompt_response + + # TODO: could prompt for which vault_id to use for each plaintext string + # currently, it will just be the default + # could use private=True for shadowed input if useful + prompt_response = display.prompt(msg) + + if prompt_response == '': + raise AnsibleOptionsError('The plaintext provided from the prompt was empty, not encrypting') + + b_plaintext = to_bytes(prompt_response) + b_plaintext_list.append((b_plaintext, self.FROM_PROMPT, name)) + + # read from stdin + if self.encrypt_string_read_stdin: + if sys.stdout.isatty(): + display.display("Reading plaintext input from stdin. (ctrl-d to end input)", stderr=True) + + stdin_text = sys.stdin.read() + if stdin_text == '': + raise AnsibleOptionsError('stdin was empty, not encrypting') + + b_plaintext = to_bytes(stdin_text) + + # defaults to None + name = self.options.encrypt_string_stdin_name + b_plaintext_list.append((b_plaintext, self.FROM_STDIN, name)) + + # use any leftover args as strings to encrypt + # Try to match args up to --name options + if hasattr(self.options, 'encrypt_string_names') and self.options.encrypt_string_names: + name_and_text_list = list(zip(self.options.encrypt_string_names, args)) + + # Some but not enough --name's to name each var + if len(args) > len(name_and_text_list): + # Trying to avoid ever showing the plaintext in the output, so this warning is vague to avoid that. + display.display('The number of --name options do not match the number of args.', + stderr=True) + display.display('The last named variable will be "%s". The rest will not have names.' % self.options.encrypt_string_names[-1], + stderr=True) + + # Add the rest of the args without specifying a name + for extra_arg in args[len(name_and_text_list):]: + name_and_text_list.append((None, extra_arg)) + + # if no --names are provided, just use the args without a name. + else: + name_and_text_list = [(None, x) for x in args] + + # Convert the plaintext text objects to bytestrings and collect + for name_and_text in name_and_text_list: + name, plaintext = name_and_text + + if plaintext == '': + raise AnsibleOptionsError('The plaintext provided from the command line args was empty, not encrypting') + + b_plaintext = to_bytes(plaintext) + b_plaintext_list.append((b_plaintext, self.FROM_ARGS, name)) + + # TODO: specify vault_id per string? + # Format the encrypted strings and any corresponding stderr output + outputs = self._format_output_vault_strings(b_plaintext_list, vault_id=self.encrypt_vault_id) + + for output in outputs: + err = output.get('err', None) + out = output.get('out', '') + if err: + sys.stderr.write(err) + print(out) + + if sys.stdout.isatty(): + display.display("Encryption successful", stderr=True) + + # TODO: offer block or string ala eyaml + + def _format_output_vault_strings(self, b_plaintext_list, vault_id=None): + # If we are only showing one item in the output, we don't need to included commented + # delimiters in the text + show_delimiter = False + if len(b_plaintext_list) > 1: + show_delimiter = True + + # list of dicts {'out': '', 'err': ''} + output = [] + + # Encrypt the plaintext, and format it into a yaml block that can be pasted into a playbook. + # For more than one input, show some differentiating info in the stderr output so we can tell them + # apart. If we have a var name, we include that in the yaml + for index, b_plaintext_info in enumerate(b_plaintext_list): + # (the text itself, which input it came from, its name) + b_plaintext, src, name = b_plaintext_info + + b_ciphertext = self.editor.encrypt_bytes(b_plaintext, self.encrypt_secret, + vault_id=vault_id) + + # block formatting + yaml_text = self.format_ciphertext_yaml(b_ciphertext, name=name) + + err_msg = None + if show_delimiter: + human_index = index + 1 + if name: + err_msg = '# The encrypted version of variable ("%s", the string #%d from %s).\n' % (name, human_index, src) + else: + err_msg = '# The encrypted version of the string #%d from %s.)\n' % (human_index, src) + output.append({'out': yaml_text, 'err': err_msg}) + + return output + + def execute_decrypt(self): + ''' decrypt the supplied file using the provided vault secret ''' + + if len(self.args) == 0 and sys.stdin.isatty(): + display.display("Reading ciphertext input from stdin", stderr=True) + + for f in self.args or ['-']: + self.editor.decrypt_file(f, output_file=self.options.output_file) + + if sys.stdout.isatty(): + display.display("Decryption successful", stderr=True) + + def execute_create(self): + ''' create and open a file in an editor that will be encryped with the provided vault secret when closed''' + + if len(self.args) > 1: + raise AnsibleOptionsError("ansible-vault create can take only one filename argument") + + self.editor.create_file(self.args[0], self.encrypt_secret, + vault_id=self.encrypt_vault_id) + + def execute_edit(self): + ''' open and decrypt an existing vaulted file in an editor, that will be encryped again when closed''' + for f in self.args: + self.editor.edit_file(f) + + def execute_view(self): + ''' open, decrypt and view an existing vaulted file using a pager using the supplied vault secret ''' + + for f in self.args: + # Note: vault should return byte strings because it could encrypt + # and decrypt binary files. We are responsible for changing it to + # unicode here because we are displaying it and therefore can make + # the decision that the display doesn't have to be precisely what + # the input was (leave that to decrypt instead) + plaintext = self.editor.plaintext(f) + self.pager(to_text(plaintext)) + + def execute_rekey(self): + ''' re-encrypt a vaulted file with a new secret, the previous secret is required ''' + for f in self.args: + # FIXME: plumb in vault_id, use the default new_vault_secret for now + self.editor.rekey_file(f, self.new_encrypt_secret, + self.new_encrypt_vault_id) + + display.display("Rekey successful", stderr=True) diff --git a/env_27/lib/python2.7/site-packages/ansible/compat/__init__.py b/env_27/lib/python2.7/site-packages/ansible/compat/__init__.py new file mode 100644 index 0000000..2990c6f --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/compat/__init__.py @@ -0,0 +1,26 @@ +# (c) 2014, Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +''' +Compat library for ansible. This contains compatibility definitions for older python +When we need to import a module differently depending on python version, do it +here. Then in the code we can simply import from compat in order to get what we want. +''' diff --git a/env_27/lib/python2.7/site-packages/ansible/compat/selectors/__init__.py b/env_27/lib/python2.7/site-packages/ansible/compat/selectors/__init__.py new file mode 100644 index 0000000..8d45ea5 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/compat/selectors/__init__.py @@ -0,0 +1,55 @@ +# (c) 2014, 2017 Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +''' +Compat selectors library. Python-3.5 has this builtin. The selectors2 +package exists on pypi to backport the functionality as far as python-2.6. +''' +# The following makes it easier for us to script updates of the bundled code +_BUNDLED_METADATA = {"pypi_name": "selectors2", "version": "1.1.0"} +# Added these bugfix commits from 2.1.0: +# * https://github.com/SethMichaelLarson/selectors2/commit/3bd74f2033363b606e1e849528ccaa76f5067590 +# Wrap kqueue.control so that timeout is a keyword arg +# * https://github.com/SethMichaelLarson/selectors2/commit/6f6a26f42086d8aab273b30be492beecb373646b +# Fix formatting of the kqueue.control patch for pylint +# * https://github.com/SethMichaelLarson/selectors2/commit/f0c2c6c66cfa7662bc52beaf4e2d65adfa25e189 +# Fix use of OSError exception for py3 and use the wrapper of kqueue.control so retries of +# interrupted syscalls work with kqueue + +import os.path +import sys + +try: + # Python 3.4+ + import selectors as _system_selectors +except ImportError: + try: + # backport package installed in the system + import selectors2 as _system_selectors + except ImportError: + _system_selectors = None + +if _system_selectors: + selectors = _system_selectors +else: + # Our bundled copy + from . import _selectors2 as selectors +sys.modules['ansible.compat.selectors'] = selectors diff --git a/env_27/lib/python2.7/site-packages/ansible/compat/selectors/_selectors2.py b/env_27/lib/python2.7/site-packages/ansible/compat/selectors/_selectors2.py new file mode 100644 index 0000000..d935576 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/compat/selectors/_selectors2.py @@ -0,0 +1,654 @@ +# This file is from the selectors2.py package. It backports the PSF Licensed +# selectors module from the Python-3.5 stdlib to older versions of Python. +# The author, Seth Michael Larson, dual licenses his modifications under the +# PSF License and MIT License: +# https://github.com/SethMichaelLarson/selectors2#license +# +# Copyright (c) 2016 Seth Michael Larson +# +# PSF License (see licenses/PSF-license.txt or https://opensource.org/licenses/Python-2.0) +# MIT License (see licenses/MIT-license.txt or https://opensource.org/licenses/MIT) +# + + +# Backport of selectors.py from Python 3.5+ to support Python < 3.4 +# Also has the behavior specified in PEP 475 which is to retry syscalls +# in the case of an EINTR error. This module is required because selectors34 +# does not follow this behavior and instead returns that no dile descriptor +# events have occurred rather than retry the syscall. The decision to drop +# support for select.devpoll is made to maintain 100% test coverage. + +import errno +import math +import select +import socket +import sys +import time +from collections import namedtuple, Mapping + +try: + monotonic = time.monotonic +except (AttributeError, ImportError): # Python 3.3< + monotonic = time.time + +__author__ = 'Seth Michael Larson' +__email__ = 'sethmichaellarson@protonmail.com' +__version__ = '1.1.0' +__license__ = 'MIT' + +__all__ = [ + 'EVENT_READ', + 'EVENT_WRITE', + 'SelectorError', + 'SelectorKey', + 'DefaultSelector' +] + +EVENT_READ = (1 << 0) +EVENT_WRITE = (1 << 1) + +HAS_SELECT = True # Variable that shows whether the platform has a selector. +_SYSCALL_SENTINEL = object() # Sentinel in case a system call returns None. + + +class SelectorError(Exception): + def __init__(self, errcode): + super(SelectorError, self).__init__() + self.errno = errcode + + def __repr__(self): + return "".format(self.errno) + + def __str__(self): + return self.__repr__() + + +def _fileobj_to_fd(fileobj): + """ Return a file descriptor from a file object. If + given an integer will simply return that integer back. """ + if isinstance(fileobj, int): + fd = fileobj + else: + try: + fd = int(fileobj.fileno()) + except (AttributeError, TypeError, ValueError): + raise ValueError("Invalid file object: {0!r}".format(fileobj)) + if fd < 0: + raise ValueError("Invalid file descriptor: {0}".format(fd)) + return fd + + +# Python 3.5 uses a more direct route to wrap system calls to increase speed. +if sys.version_info >= (3, 5): + def _syscall_wrapper(func, _, *args, **kwargs): + """ This is the short-circuit version of the below logic + because in Python 3.5+ all selectors restart system calls. """ + try: + return func(*args, **kwargs) + except (OSError, IOError, select.error) as e: + errcode = None + if hasattr(e, "errno"): + errcode = e.errno + elif hasattr(e, "args"): + errcode = e.args[0] + raise SelectorError(errcode) +else: + def _syscall_wrapper(func, recalc_timeout, *args, **kwargs): + """ Wrapper function for syscalls that could fail due to EINTR. + All functions should be retried if there is time left in the timeout + in accordance with PEP 475. """ + timeout = kwargs.get("timeout", None) + if timeout is None: + expires = None + recalc_timeout = False + else: + timeout = float(timeout) + if timeout < 0.0: # Timeout less than 0 treated as no timeout. + expires = None + else: + expires = monotonic() + timeout + + args = list(args) + if recalc_timeout and "timeout" not in kwargs: + raise ValueError( + "Timeout must be in args or kwargs to be recalculated") + + result = _SYSCALL_SENTINEL + while result is _SYSCALL_SENTINEL: + try: + result = func(*args, **kwargs) + # OSError is thrown by select.select + # IOError is thrown by select.epoll.poll + # select.error is thrown by select.poll.poll + # Aren't we thankful for Python 3.x rework for exceptions? + except (OSError, IOError, select.error) as e: + # select.error wasn't a subclass of OSError in the past. + errcode = None + if hasattr(e, "errno"): + errcode = e.errno + elif hasattr(e, "args"): + errcode = e.args[0] + + # Also test for the Windows equivalent of EINTR. + is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and + errcode == errno.WSAEINTR)) + + if is_interrupt: + if expires is not None: + current_time = monotonic() + if current_time > expires: + raise OSError(errno.ETIMEDOUT) + if recalc_timeout: + if "timeout" in kwargs: + kwargs["timeout"] = expires - current_time + continue + if errcode: + raise SelectorError(errcode) + else: + raise + return result + + +SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data']) + + +class _SelectorMapping(Mapping): + """ Mapping of file objects to selector keys """ + + def __init__(self, selector): + self._selector = selector + + def __len__(self): + return len(self._selector._fd_to_key) + + def __getitem__(self, fileobj): + try: + fd = self._selector._fileobj_lookup(fileobj) + return self._selector._fd_to_key[fd] + except KeyError: + raise KeyError("{0!r} is not registered.".format(fileobj)) + + def __iter__(self): + return iter(self._selector._fd_to_key) + + +class BaseSelector(object): + """ Abstract Selector class + + A selector supports registering file objects to be monitored + for specific I/O events. + + A file object is a file descriptor or any object with a + `fileno()` method. An arbitrary object can be attached to the + file object which can be used for example to store context info, + a callback, etc. + + A selector can use various implementations (select(), poll(), epoll(), + and kqueue()) depending on the platform. The 'DefaultSelector' class uses + the most efficient implementation for the current platform. + """ + def __init__(self): + # Maps file descriptors to keys. + self._fd_to_key = {} + + # Read-only mapping returned by get_map() + self._map = _SelectorMapping(self) + + def _fileobj_lookup(self, fileobj): + """ Return a file descriptor from a file object. + This wraps _fileobj_to_fd() to do an exhaustive + search in case the object is invalid but we still + have it in our map. Used by unregister() so we can + unregister an object that was previously registered + even if it is closed. It is also used by _SelectorMapping + """ + try: + return _fileobj_to_fd(fileobj) + except ValueError: + + # Search through all our mapped keys. + for key in self._fd_to_key.values(): + if key.fileobj is fileobj: + return key.fd + + # Raise ValueError after all. + raise + + def register(self, fileobj, events, data=None): + """ Register a file object for a set of events to monitor. """ + if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)): + raise ValueError("Invalid events: {0!r}".format(events)) + + key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data) + + if key.fd in self._fd_to_key: + raise KeyError("{0!r} (FD {1}) is already registered" + .format(fileobj, key.fd)) + + self._fd_to_key[key.fd] = key + return key + + def unregister(self, fileobj): + """ Unregister a file object from being monitored. """ + try: + key = self._fd_to_key.pop(self._fileobj_lookup(fileobj)) + except KeyError: + raise KeyError("{0!r} is not registered".format(fileobj)) + + # Getting the fileno of a closed socket on Windows errors with EBADF. + except socket.error as err: + if err.errno != errno.EBADF: + raise + else: + for key in self._fd_to_key.values(): + if key.fileobj is fileobj: + self._fd_to_key.pop(key.fd) + break + else: + raise KeyError("{0!r} is not registered".format(fileobj)) + return key + + def modify(self, fileobj, events, data=None): + """ Change a registered file object monitored events and data. """ + # NOTE: Some subclasses optimize this operation even further. + try: + key = self._fd_to_key[self._fileobj_lookup(fileobj)] + except KeyError: + raise KeyError("{0!r} is not registered".format(fileobj)) + + if events != key.events: + self.unregister(fileobj) + key = self.register(fileobj, events, data) + + elif data != key.data: + # Use a shortcut to update the data. + key = key._replace(data=data) + self._fd_to_key[key.fd] = key + + return key + + def select(self, timeout=None): + """ Perform the actual selection until some monitored file objects + are ready or the timeout expires. """ + raise NotImplementedError() + + def close(self): + """ Close the selector. This must be called to ensure that all + underlying resources are freed. """ + self._fd_to_key.clear() + self._map = None + + def get_key(self, fileobj): + """ Return the key associated with a registered file object. """ + mapping = self.get_map() + if mapping is None: + raise RuntimeError("Selector is closed") + try: + return mapping[fileobj] + except KeyError: + raise KeyError("{0!r} is not registered".format(fileobj)) + + def get_map(self): + """ Return a mapping of file objects to selector keys """ + return self._map + + def _key_from_fd(self, fd): + """ Return the key associated to a given file descriptor + Return None if it is not found. """ + try: + return self._fd_to_key[fd] + except KeyError: + return None + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + +# Almost all platforms have select.select() +if hasattr(select, "select"): + class SelectSelector(BaseSelector): + """ Select-based selector. """ + def __init__(self): + super(SelectSelector, self).__init__() + self._readers = set() + self._writers = set() + + def register(self, fileobj, events, data=None): + key = super(SelectSelector, self).register(fileobj, events, data) + if events & EVENT_READ: + self._readers.add(key.fd) + if events & EVENT_WRITE: + self._writers.add(key.fd) + return key + + def unregister(self, fileobj): + key = super(SelectSelector, self).unregister(fileobj) + self._readers.discard(key.fd) + self._writers.discard(key.fd) + return key + + def _select(self, r, w, timeout=None): + """ Wrapper for select.select because timeout is a positional arg """ + return select.select(r, w, [], timeout) + + def select(self, timeout=None): + # Selecting on empty lists on Windows errors out. + if not len(self._readers) and not len(self._writers): + return [] + + timeout = None if timeout is None else max(timeout, 0.0) + ready = [] + r, w, _ = _syscall_wrapper(self._select, True, self._readers, + self._writers, timeout=timeout) + r = set(r) + w = set(w) + for fd in r | w: + events = 0 + if fd in r: + events |= EVENT_READ + if fd in w: + events |= EVENT_WRITE + + key = self._key_from_fd(fd) + if key: + ready.append((key, events & key.events)) + return ready + + __all__.append('SelectSelector') + + +if hasattr(select, "poll"): + class PollSelector(BaseSelector): + """ Poll-based selector """ + def __init__(self): + super(PollSelector, self).__init__() + self._poll = select.poll() + + def register(self, fileobj, events, data=None): + key = super(PollSelector, self).register(fileobj, events, data) + event_mask = 0 + if events & EVENT_READ: + event_mask |= select.POLLIN + if events & EVENT_WRITE: + event_mask |= select.POLLOUT + self._poll.register(key.fd, event_mask) + return key + + def unregister(self, fileobj): + key = super(PollSelector, self).unregister(fileobj) + self._poll.unregister(key.fd) + return key + + def _wrap_poll(self, timeout=None): + """ Wrapper function for select.poll.poll() so that + _syscall_wrapper can work with only seconds. """ + if timeout is not None: + if timeout <= 0: + timeout = 0 + else: + # select.poll.poll() has a resolution of 1 millisecond, + # round away from zero to wait *at least* timeout seconds. + timeout = math.ceil(timeout * 1e3) + + result = self._poll.poll(timeout) + return result + + def select(self, timeout=None): + ready = [] + fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout) + for fd, event_mask in fd_events: + events = 0 + if event_mask & ~select.POLLIN: + events |= EVENT_WRITE + if event_mask & ~select.POLLOUT: + events |= EVENT_READ + + key = self._key_from_fd(fd) + if key: + ready.append((key, events & key.events)) + + return ready + + __all__.append('PollSelector') + +if hasattr(select, "epoll"): + class EpollSelector(BaseSelector): + """ Epoll-based selector """ + def __init__(self): + super(EpollSelector, self).__init__() + self._epoll = select.epoll() + + def fileno(self): + return self._epoll.fileno() + + def register(self, fileobj, events, data=None): + key = super(EpollSelector, self).register(fileobj, events, data) + events_mask = 0 + if events & EVENT_READ: + events_mask |= select.EPOLLIN + if events & EVENT_WRITE: + events_mask |= select.EPOLLOUT + _syscall_wrapper(self._epoll.register, False, key.fd, events_mask) + return key + + def unregister(self, fileobj): + key = super(EpollSelector, self).unregister(fileobj) + try: + _syscall_wrapper(self._epoll.unregister, False, key.fd) + except SelectorError: + # This can occur when the fd was closed since registry. + pass + return key + + def select(self, timeout=None): + if timeout is not None: + if timeout <= 0: + timeout = 0.0 + else: + # select.epoll.poll() has a resolution of 1 millisecond + # but luckily takes seconds so we don't need a wrapper + # like PollSelector. Just for better rounding. + timeout = math.ceil(timeout * 1e3) * 1e-3 + timeout = float(timeout) + else: + timeout = -1.0 # epoll.poll() must have a float. + + # We always want at least 1 to ensure that select can be called + # with no file descriptors registered. Otherwise will fail. + max_events = max(len(self._fd_to_key), 1) + + ready = [] + fd_events = _syscall_wrapper(self._epoll.poll, True, + timeout=timeout, + maxevents=max_events) + for fd, event_mask in fd_events: + events = 0 + if event_mask & ~select.EPOLLIN: + events |= EVENT_WRITE + if event_mask & ~select.EPOLLOUT: + events |= EVENT_READ + + key = self._key_from_fd(fd) + if key: + ready.append((key, events & key.events)) + return ready + + def close(self): + self._epoll.close() + super(EpollSelector, self).close() + + __all__.append('EpollSelector') + + +if hasattr(select, "devpoll"): + class DevpollSelector(BaseSelector): + """Solaris /dev/poll selector.""" + + def __init__(self): + super(DevpollSelector, self).__init__() + self._devpoll = select.devpoll() + + def fileno(self): + return self._devpoll.fileno() + + def register(self, fileobj, events, data=None): + key = super(DevpollSelector, self).register(fileobj, events, data) + poll_events = 0 + if events & EVENT_READ: + poll_events |= select.POLLIN + if events & EVENT_WRITE: + poll_events |= select.POLLOUT + self._devpoll.register(key.fd, poll_events) + return key + + def unregister(self, fileobj): + key = super(DevpollSelector, self).unregister(fileobj) + self._devpoll.unregister(key.fd) + return key + + def _wrap_poll(self, timeout=None): + """ Wrapper function for select.poll.poll() so that + _syscall_wrapper can work with only seconds. """ + if timeout is not None: + if timeout <= 0: + timeout = 0 + else: + # select.devpoll.poll() has a resolution of 1 millisecond, + # round away from zero to wait *at least* timeout seconds. + timeout = math.ceil(timeout * 1e3) + + result = self._devpoll.poll(timeout) + return result + + def select(self, timeout=None): + ready = [] + fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout) + for fd, event_mask in fd_events: + events = 0 + if event_mask & ~select.POLLIN: + events |= EVENT_WRITE + if event_mask & ~select.POLLOUT: + events |= EVENT_READ + + key = self._key_from_fd(fd) + if key: + ready.append((key, events & key.events)) + + return ready + + def close(self): + self._devpoll.close() + super(DevpollSelector, self).close() + + __all__.append('DevpollSelector') + + +if hasattr(select, "kqueue"): + class KqueueSelector(BaseSelector): + """ Kqueue / Kevent-based selector """ + def __init__(self): + super(KqueueSelector, self).__init__() + self._kqueue = select.kqueue() + + def fileno(self): + return self._kqueue.fileno() + + def register(self, fileobj, events, data=None): + key = super(KqueueSelector, self).register(fileobj, events, data) + if events & EVENT_READ: + kevent = select.kevent(key.fd, + select.KQ_FILTER_READ, + select.KQ_EV_ADD) + + _syscall_wrapper(self._wrap_control, False, [kevent], 0, 0) + + if events & EVENT_WRITE: + kevent = select.kevent(key.fd, + select.KQ_FILTER_WRITE, + select.KQ_EV_ADD) + + _syscall_wrapper(self._wrap_control, False, [kevent], 0, 0) + + return key + + def unregister(self, fileobj): + key = super(KqueueSelector, self).unregister(fileobj) + if key.events & EVENT_READ: + kevent = select.kevent(key.fd, + select.KQ_FILTER_READ, + select.KQ_EV_DELETE) + try: + _syscall_wrapper(self._wrap_control, False, [kevent], 0, 0) + except SelectorError: + pass + if key.events & EVENT_WRITE: + kevent = select.kevent(key.fd, + select.KQ_FILTER_WRITE, + select.KQ_EV_DELETE) + try: + _syscall_wrapper(self._wrap_control, False, [kevent], 0, 0) + except SelectorError: + pass + + return key + + def select(self, timeout=None): + if timeout is not None: + timeout = max(timeout, 0) + + max_events = len(self._fd_to_key) * 2 + ready_fds = {} + + kevent_list = _syscall_wrapper(self._wrap_control, True, + None, max_events, timeout=timeout) + + for kevent in kevent_list: + fd = kevent.ident + event_mask = kevent.filter + events = 0 + if event_mask == select.KQ_FILTER_READ: + events |= EVENT_READ + if event_mask == select.KQ_FILTER_WRITE: + events |= EVENT_WRITE + + key = self._key_from_fd(fd) + if key: + if key.fd not in ready_fds: + ready_fds[key.fd] = (key, events & key.events) + else: + old_events = ready_fds[key.fd][1] + ready_fds[key.fd] = (key, (events | old_events) & key.events) + + return list(ready_fds.values()) + + def close(self): + self._kqueue.close() + super(KqueueSelector, self).close() + + def _wrap_control(self, changelist, max_events, timeout): + return self._kqueue.control(changelist, max_events, timeout) + + __all__.append('KqueueSelector') + + +# Choose the best implementation, roughly: +# kqueue == epoll == devpoll > poll > select. +# select() also can't accept a FD > FD_SETSIZE (usually around 1024) +if 'KqueueSelector' in globals(): # Platform-specific: Mac OS and BSD + DefaultSelector = KqueueSelector +elif 'DevpollSelector' in globals(): + DefaultSelector = DevpollSelector +elif 'EpollSelector' in globals(): # Platform-specific: Linux + DefaultSelector = EpollSelector +elif 'PollSelector' in globals(): # Platform-specific: Linux + DefaultSelector = PollSelector +elif 'SelectSelector' in globals(): # Platform-specific: Windows + DefaultSelector = SelectSelector +else: # Platform-specific: AppEngine + def no_selector(_): + raise ValueError("Platform does not have a selector") + DefaultSelector = no_selector + HAS_SELECT = False diff --git a/env_27/lib/python2.7/site-packages/ansible/compat/tests/__init__.py b/env_27/lib/python2.7/site-packages/ansible/compat/tests/__init__.py new file mode 100644 index 0000000..fe8fef5 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/compat/tests/__init__.py @@ -0,0 +1,39 @@ +# (c) 2014, Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +''' +This module contains things that are only needed for compat in the testsuites, +not in ansible itself. If you are not installing the test suite, you can +safely remove this subdirectory. +''' + +# +# Compat for python2.7 +# + +# One unittest needs to import builtins via __import__() so we need to have +# the string that represents it +try: + import __builtin__ +except ImportError: + BUILTINS = 'builtins' +else: + BUILTINS = '__builtin__' diff --git a/env_27/lib/python2.7/site-packages/ansible/compat/tests/mock.py b/env_27/lib/python2.7/site-packages/ansible/compat/tests/mock.py new file mode 100644 index 0000000..0972cd2 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/compat/tests/mock.py @@ -0,0 +1,122 @@ +# (c) 2014, Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +''' +Compat module for Python3.x's unittest.mock module +''' +import sys + +# Python 2.7 + +# Note: Could use the pypi mock library on python3.x as well as python2.x. It +# is the same as the python3 stdlib mock library + +try: + # Allow wildcard import because we really do want to import all of mock's + # symbols into this compat shim + # pylint: disable=wildcard-import,unused-wildcard-import + from unittest.mock import * +except ImportError: + # Python 2 + # pylint: disable=wildcard-import,unused-wildcard-import + try: + from mock import * + except ImportError: + print('You need the mock library installed on python2.x to run tests') + + +# Prior to 3.4.4, mock_open cannot handle binary read_data +if sys.version_info >= (3,) and sys.version_info < (3, 4, 4): + file_spec = None + + def _iterate_read_data(read_data): + # Helper for mock_open: + # Retrieve lines from read_data via a generator so that separate calls to + # readline, read, and readlines are properly interleaved + sep = b'\n' if isinstance(read_data, bytes) else '\n' + data_as_list = [l + sep for l in read_data.split(sep)] + + if data_as_list[-1] == sep: + # If the last line ended in a newline, the list comprehension will have an + # extra entry that's just a newline. Remove this. + data_as_list = data_as_list[:-1] + else: + # If there wasn't an extra newline by itself, then the file being + # emulated doesn't have a newline to end the last line remove the + # newline that our naive format() added + data_as_list[-1] = data_as_list[-1][:-1] + + for line in data_as_list: + yield line + + def mock_open(mock=None, read_data=''): + """ + A helper function to create a mock to replace the use of `open`. It works + for `open` called directly or used as a context manager. + + The `mock` argument is the mock object to configure. If `None` (the + default) then a `MagicMock` will be created for you, with the API limited + to methods or attributes available on standard file handles. + + `read_data` is a string for the `read` methoddline`, and `readlines` of the + file handle to return. This is an empty string by default. + """ + def _readlines_side_effect(*args, **kwargs): + if handle.readlines.return_value is not None: + return handle.readlines.return_value + return list(_data) + + def _read_side_effect(*args, **kwargs): + if handle.read.return_value is not None: + return handle.read.return_value + return type(read_data)().join(_data) + + def _readline_side_effect(): + if handle.readline.return_value is not None: + while True: + yield handle.readline.return_value + for line in _data: + yield line + + global file_spec + if file_spec is None: + import _io + file_spec = list(set(dir(_io.TextIOWrapper)).union(set(dir(_io.BytesIO)))) + + if mock is None: + mock = MagicMock(name='open', spec=open) + + handle = MagicMock(spec=file_spec) + handle.__enter__.return_value = handle + + _data = _iterate_read_data(read_data) + + handle.write.return_value = None + handle.read.return_value = None + handle.readline.return_value = None + handle.readlines.return_value = None + + handle.read.side_effect = _read_side_effect + handle.readline.side_effect = _readline_side_effect() + handle.readlines.side_effect = _readlines_side_effect + + mock.return_value = handle + return mock diff --git a/env_27/lib/python2.7/site-packages/ansible/compat/tests/unittest.py b/env_27/lib/python2.7/site-packages/ansible/compat/tests/unittest.py new file mode 100644 index 0000000..98f08ad --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/compat/tests/unittest.py @@ -0,0 +1,38 @@ +# (c) 2014, Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +''' +Compat module for Python2.7's unittest module +''' + +import sys + +# Allow wildcard import because we really do want to import all of +# unittests's symbols into this compat shim +# pylint: disable=wildcard-import,unused-wildcard-import +if sys.version_info < (2, 7): + try: + # Need unittest2 on python2.6 + from unittest2 import * + except ImportError: + print('You need unittest2 installed on python2.6.x to run tests') +else: + from unittest import * diff --git a/env_27/lib/python2.7/site-packages/ansible/config/__init__.py b/env_27/lib/python2.7/site-packages/ansible/config/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/env_27/lib/python2.7/site-packages/ansible/config/base.yml b/env_27/lib/python2.7/site-packages/ansible/config/base.yml new file mode 100644 index 0000000..6503693 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/config/base.yml @@ -0,0 +1,1660 @@ +# Copyright (c) 2017 Ansible Project +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) +--- +ALLOW_WORLD_READABLE_TMPFILES: + name: Allow world readable temporary files + default: False + description: + - This makes the temporary files created on the machine to be world readable and will issue a warning instead of failing the task. + - It is useful when becoming an unprivileged user. + env: [] + ini: + - {key: allow_world_readable_tmpfiles, section: defaults} + type: boolean + yaml: {key: defaults.allow_world_readable_tmpfiles} + version_added: "2.1" +ANSIBLE_COW_SELECTION: + name: Cowsay filter selection + default: default + description: This allows you to chose a specific cowsay stencil for the banners or use 'random' to cycle through them. + env: [{name: ANSIBLE_COW_SELECTION}] + ini: + - {key: cow_selection, section: defaults} +ANSIBLE_COW_WHITELIST: + name: Cowsay filter whitelist + default: ['bud-frogs', 'bunny', 'cheese', 'daemon', 'default', 'dragon', 'elephant-in-snake', 'elephant', 'eyes', 'hellokitty', 'kitty', 'luke-koala', 'meow', 'milk', 'moofasa', 'moose', 'ren', 'sheep', 'small', 'stegosaurus', 'stimpy', 'supermilker', 'three-eyes', 'turkey', 'turtle', 'tux', 'udder', 'vader-koala', 'vader', 'www'] + description: White list of cowsay templates that are 'safe' to use, set to empty list if you want to enable all installed templates. + env: [{name: ANSIBLE_COW_WHITELIST}] + ini: + - {key: cow_whitelist, section: defaults} + type: list + yaml: {key: display.cowsay_whitelist} +ANSIBLE_FORCE_COLOR: + name: Force color output + default: False + description: This options forces color mode even when running without a TTY or the "nocolor" setting is True. + env: [{name: ANSIBLE_FORCE_COLOR}] + ini: + - {key: force_color, section: defaults} + type: boolean + yaml: {key: display.force_color} +ANSIBLE_NOCOLOR: + name: Suppress color output + default: False + description: This setting allows suppressing colorizing output, which is used to give a better indication of failure and status information. + env: [{name: ANSIBLE_NOCOLOR}] + ini: + - {key: nocolor, section: defaults} + type: boolean + yaml: {key: display.nocolor} +ANSIBLE_NOCOWS: + name: Suppress cowsay output + default: False + description: If you have cowsay installed but want to avoid the 'cows' (why????), use this. + env: [{name: ANSIBLE_NOCOWS}] + ini: + - {key: nocows, section: defaults} + type: boolean + yaml: {key: display.i_am_no_fun} +ANSIBLE_COW_PATH: + name: Set path to cowsay command + default: null + description: Specify a custom cowsay path or swap in your cowsay implementation of choice + env: [{name: ANSIBLE_COW_PATH}] + ini: + - {key: cowpath, section: defaults} + type: string + yaml: {key: display.cowpath} +ANSIBLE_PIPELINING: + name: Connection pipelining + default: False + description: + - Pipelining, if supported by the connection plugin, reduces the number of network operations required to execute a module on the remote server, + by executing many Ansible modules without actual file transfer. + - This can result in a very significant performance improvement when enabled. + - "However this conflicts with privilege escalation (become). For example, when using 'sudo:' operations you must first + disable 'requiretty' in /etc/sudoers on all managed hosts, which is why it is disabled by default." + env: + - name: ANSIBLE_PIPELINING + - name: ANSIBLE_SSH_PIPELINING + ini: + - section: connection + key: pipelining + - section: ssh_connection + key: pipelining + type: boolean + yaml: {key: plugins.connection.pipelining} +ANSIBLE_SSH_ARGS: + # TODO: move to ssh plugin + default: -C -o ControlMaster=auto -o ControlPersist=60s + description: + - If set, this will override the Ansible default ssh arguments. + - In particular, users may wish to raise the ControlPersist time to encourage performance. A value of 30 minutes may be appropriate. + - Be aware that if `-o ControlPath` is set in ssh_args, the control path setting is not used. + env: [{name: ANSIBLE_SSH_ARGS}] + ini: + - {key: ssh_args, section: ssh_connection} + yaml: {key: ssh_connection.ssh_args} +ANSIBLE_SSH_CONTROL_PATH: + # TODO: move to ssh plugin + default: null + description: + - This is the location to save ssh's ControlPath sockets, it uses ssh's variable substitution. + - Since 2.3, if null, ansible will generate a unique hash. Use `%(directory)s` to indicate where to use the control dir path setting. + - Before 2.3 it defaulted to `control_path=%(directory)s/ansible-ssh-%%h-%%p-%%r`. + - Be aware that this setting is ignored if `-o ControlPath` is set in ssh args. + env: [{name: ANSIBLE_SSH_CONTROL_PATH}] + ini: + - {key: control_path, section: ssh_connection} + yaml: {key: ssh_connection.control_path} +ANSIBLE_SSH_CONTROL_PATH_DIR: + # TODO: move to ssh plugin + default: ~/.ansible/cp + description: + - This sets the directory to use for ssh control path if the control path setting is null. + - Also, provides the `%(directory)s` variable for the control path setting. + env: [{name: ANSIBLE_SSH_CONTROL_PATH_DIR}] + ini: + - {key: control_path_dir, section: ssh_connection} + yaml: {key: ssh_connection.control_path_dir} +ANSIBLE_SSH_EXECUTABLE: + # TODO: move to ssh plugin + default: ssh + description: + - This defines the location of the ssh binary. It defaults to `ssh` which will use the first ssh binary available in $PATH. + - This option is usually not required, it might be useful when access to system ssh is restricted, + or when using ssh wrappers to connect to remote hosts. + env: [{name: ANSIBLE_SSH_EXECUTABLE}] + ini: + - {key: ssh_executable, section: ssh_connection} + yaml: {key: ssh_connection.ssh_executable} + version_added: "2.2" +ANSIBLE_SSH_RETRIES: + # TODO: move to ssh plugin + default: 0 + description: Number of attempts to establish a connection before we give up and report the host as 'UNREACHABLE' + env: [{name: ANSIBLE_SSH_RETRIES}] + ini: + - {key: retries, section: ssh_connection} + type: integer + yaml: {key: ssh_connection.retries} +ANY_ERRORS_FATAL: + name: Make Task failures fatal + default: False + description: Sets the default value for the any_errors_fatal keyword, if True, Task failures will be considered fatal errors. + env: + - name: ANSIBLE_ANY_ERRORS_FATAL + ini: + - section: defaults + key: any_errors_fatal + type: boolean + yaml: {key: errors.any_task_errors_fatal} + version_added: "2.4" +BECOME_ALLOW_SAME_USER: + name: Allow becoming the same user + default: False + description: This setting controls if become is skipped when remote user and become user are the same. I.E root sudo to root. + env: [{name: ANSIBLE_BECOME_ALLOW_SAME_USER}] + ini: + - {key: become_allow_same_user, section: privilege_escalation} + type: boolean + yaml: {key: privilege_escalation.become_allow_same_user} +AGNOSTIC_BECOME_PROMPT: + # TODO: Switch the default to True in either the Ansible 2.6 release or the 2.7 release, whichever happens after the Tower 3.3 release + name: Display an agnostic become prompt + default: False + type: boolean + description: Display an agnostic become prompt instead of displaying a prompt containing the command line supplied become method + env: [{name: ANSIBLE_AGNOSTIC_BECOME_PROMPT}] + ini: + - {key: agnostic_become_prompt, section: privilege_escalation} + yaml: {key: privilege_escalation.agnostic_become_prompt} + version_added: "2.5" +CACHE_PLUGIN: + name: Persistent Cache plugin + default: memory + description: Chooses which cache plugin to use, the default 'memory' is ephimeral. + env: [{name: ANSIBLE_CACHE_PLUGIN}] + ini: + - {key: fact_caching, section: defaults} + yaml: {key: facts.cache.plugin} +CACHE_PLUGIN_CONNECTION: + name: Cache Plugin URI + default: ~ + description: Defines connection or path information for the cache plugin + env: [{name: ANSIBLE_CACHE_PLUGIN_CONNECTION}] + ini: + - {key: fact_caching_connection, section: defaults} + yaml: {key: facts.cache.uri} +CACHE_PLUGIN_PREFIX: + name: Cache Plugin table prefix + default: ansible_facts + description: Prefix to use for cache plugin files/tables + env: [{name: ANSIBLE_CACHE_PLUGIN_PREFIX}] + ini: + - {key: fact_caching_prefix, section: defaults} + yaml: {key: facts.cache.prefix} +CACHE_PLUGIN_TIMEOUT: + name: Cache Plugin expiration timeout + default: 86400 + description: Expiration timeout for the cache plugin data + env: [{name: ANSIBLE_CACHE_PLUGIN_TIMEOUT}] + ini: + - {key: fact_caching_timeout, section: defaults} + type: integer + yaml: {key: facts.cache.timeout} +COLOR_CHANGED: + name: Color for 'changed' task status + default: yellow + description: Defines the color to use on 'Changed' task status + env: [{name: ANSIBLE_COLOR_CHANGED}] + ini: + - {key: changed, section: colors} + yaml: {key: display.colors.changed} +COLOR_CONSOLE_PROMPT: + name: "Color for ansible-console's prompt task status" + default: white + description: Defines the default color to use for ansible-console + env: [{name: ANSIBLE_COLOR_CONSOLE_PROMPT}] + ini: + - {key: console_prompt, section: colors} + version_added: "2.7" +COLOR_DEBUG: + name: Color for debug statements + default: dark gray + description: Defines the color to use when emitting debug messages + env: [{name: ANSIBLE_COLOR_DEBUG}] + ini: + - {key: debug, section: colors} + yaml: {key: display.colors.debug} +COLOR_DEPRECATE: + name: Color for deprecation messages + default: purple + description: Defines the color to use when emitting deprecation messages + env: [{name: ANSIBLE_COLOR_DEPRECATE}] + ini: + - {key: deprecate, section: colors} + yaml: {key: display.colors.deprecate} +COLOR_DIFF_ADD: + name: Color for diff added display + default: green + description: Defines the color to use when showing added lines in diffs + env: [{name: ANSIBLE_COLOR_DIFF_ADD}] + ini: + - {key: diff_add, section: colors} + yaml: {key: display.colors.diff.add} +COLOR_DIFF_LINES: + name: Color for diff lines display + default: cyan + description: Defines the color to use when showing diffs + env: [{name: ANSIBLE_COLOR_DIFF_LINES}] + ini: + - {key: diff_lines, section: colors} +COLOR_DIFF_REMOVE: + name: Color for diff removed display + default: red + description: Defines the color to use when showing removed lines in diffs + env: [{name: ANSIBLE_COLOR_DIFF_REMOVE}] + ini: + - {key: diff_remove, section: colors} +COLOR_ERROR: + name: Color for error messages + default: red + description: Defines the color to use when emitting error messages + env: [{name: ANSIBLE_COLOR_ERROR}] + ini: + - {key: error, section: colors} + yaml: {key: colors.error} +COLOR_HIGHLIGHT: + name: Color for highlighting + default: white + description: Defines the color to use for highlighting + env: [{name: ANSIBLE_COLOR_HIGHLIGHT}] + ini: + - {key: highlight, section: colors} +COLOR_OK: + name: Color for 'ok' task status + default: green + description: Defines the color to use when showing 'OK' task status + env: [{name: ANSIBLE_COLOR_OK}] + ini: + - {key: ok, section: colors} +COLOR_SKIP: + name: Color for 'skip' task status + default: cyan + description: Defines the color to use when showing 'Skipped' task status + env: [{name: ANSIBLE_COLOR_SKIP}] + ini: + - {key: skip, section: colors} +COLOR_UNREACHABLE: + name: Color for 'unreachable' host state + default: bright red + description: Defines the color to use on 'Unreachable' status + env: [{name: ANSIBLE_COLOR_UNREACHABLE}] + ini: + - {key: unreachable, section: colors} +COLOR_VERBOSE: + name: Color for verbose messages + default: blue + description: Defines the color to use when emitting verbose messages. i.e those that show with '-v's. + env: [{name: ANSIBLE_COLOR_VERBOSE}] + ini: + - {key: verbose, section: colors} +COLOR_WARN: + name: Color for warning messages + default: bright purple + description: Defines the color to use when emitting warning messages + env: [{name: ANSIBLE_COLOR_WARN}] + ini: + - {key: warn, section: colors} +ACTION_WARNINGS: + name: Toggle action warnings + default: True + description: + - By default Ansible will issue a warning when received from a task action (module or action plugin) + - These warnings can be silenced by adjusting this setting to False. + env: [{name: ANSIBLE_ACTION_WARNINGS}] + ini: + - {key: action_warnings, section: defaults} + type: boolean + version_added: "2.5" +COMMAND_WARNINGS: + name: Command module warnings + default: True + description: + - By default Ansible will issue a warning when the shell or command module is used and the command appears to be similar to an existing Ansible module. + - These warnings can be silenced by adjusting this setting to False. You can also control this at the task level with the module option ``warn``. + env: [{name: ANSIBLE_COMMAND_WARNINGS}] + ini: + - {key: command_warnings, section: defaults} + type: boolean + version_added: "1.8" +LOCALHOST_WARNING: + name: Warning when using implicit inventory with only localhost + default: True + description: + - By default Ansible will issue a warning when there are no hosts in the + inventory. + - These warnings can be silenced by adjusting this setting to False. + env: [{name: ANSIBLE_LOCALHOST_WARNING}] + ini: + - {key: localhost_warning, section: defaults} + type: boolean + version_added: "2.6" +DEFAULT_ACTION_PLUGIN_PATH: + name: Action plugins path + default: ~/.ansible/plugins/action:/usr/share/ansible/plugins/action + description: Colon separated paths in which Ansible will search for Action Plugins. + env: [{name: ANSIBLE_ACTION_PLUGINS}] + ini: + - {key: action_plugins, section: defaults} + type: pathspec + yaml: {key: plugins.action.path} +DEFAULT_ALLOW_UNSAFE_LOOKUPS: + name: Allow unsafe lookups + default: False + description: + - "When enabled, this option allows lookup plugins (whether used in variables as ``{{lookup('foo')}}`` or as a loop as with_foo) + to return data that is not marked 'unsafe'." + - By default, such data is marked as unsafe to prevent the templating engine from evaluating any jinja2 templating language, + as this could represent a security risk. This option is provided to allow for backwards-compatibility, + however users should first consider adding allow_unsafe=True to any lookups which may be expected to contain data which may be run + through the templating engine late + env: [] + ini: + - {key: allow_unsafe_lookups, section: defaults} + type: boolean + version_added: "2.2.3" +DEFAULT_ASK_PASS: + name: Ask for the login password + default: False + description: + - This controls whether an Ansible playbook should prompt for a login password. + If using SSH keys for authentication, you probably do not needed to change this setting. + env: [{name: ANSIBLE_ASK_PASS}] + ini: + - {key: ask_pass, section: defaults} + type: boolean + yaml: {key: defaults.ask_pass} +DEFAULT_ASK_SUDO_PASS: + name: Ask for the sudo password + default: False + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_ask_pass. + version: "2.8" + alternatives: become + description: + - This controls whether an Ansible playbook should prompt for a sudo password. + env: [{name: ANSIBLE_ASK_SUDO_PASS}] + ini: + - {key: ask_sudo_pass, section: defaults} + type: boolean +DEFAULT_ASK_SU_PASS: + name: Ask for the su password + default: False + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_ask_pass. + version: "2.8" + alternatives: become + description: + - This controls whether an Ansible playbook should prompt for a su password. + env: [{name: ANSIBLE_ASK_SU_PASS}] + ini: + - {key: ask_su_pass, section: defaults} + type: boolean +DEFAULT_ASK_VAULT_PASS: + name: Ask for the vault password(s) + default: False + description: + - This controls whether an Ansible playbook should prompt for a vault password. + env: [{name: ANSIBLE_ASK_VAULT_PASS}] + ini: + - {key: ask_vault_pass, section: defaults} + type: boolean +DEFAULT_BECOME: + name: Enable privilege escalation (become) + default: False + description: Toggles the use of privilege escalation, allowing you to 'become' another user after login. + env: [{name: ANSIBLE_BECOME}] + ini: + - {key: become, section: privilege_escalation} + type: boolean +DEFAULT_BECOME_ASK_PASS: + name: Ask for the privilege escalation (become) password + default: False + description: Toggle to prompt for privilege escalation password. + env: [{name: ANSIBLE_BECOME_ASK_PASS}] + ini: + - {key: become_ask_pass, section: privilege_escalation} + type: boolean +DEFAULT_BECOME_METHOD: + name: Choose privilege escalation method + default: 'sudo' + description: Privilege escalation method to use when `become` is enabled. + env: [{name: ANSIBLE_BECOME_METHOD}] + ini: + - {section: privilege_escalation, key: become_method} +DEFAULT_BECOME_EXE: + name: Choose 'become' executable + default: ~ + description: 'executable to use for privilege escalation, otherwise Ansible will depend on PATH' + env: [{name: ANSIBLE_BECOME_EXE}] + ini: + - {key: become_exe, section: privilege_escalation} +DEFAULT_BECOME_FLAGS: + name: Set 'become' executable options + default: '' + description: Flags to pass to the privilege escalation executable. + env: [{name: ANSIBLE_BECOME_FLAGS}] + ini: + - {key: become_flags, section: privilege_escalation} +DEFAULT_BECOME_USER: + # FIXME: should really be blank and make -u passing optional depending on it + name: Set the user you 'become' via privlege escalation + default: root + description: The user your login/remote user 'becomes' when using privilege escalation, most systems will use 'root' when no user is specified. + env: [{name: ANSIBLE_BECOME_USER}] + ini: + - {key: become_user, section: privilege_escalation} + yaml: {key: become.user} +DEFAULT_CACHE_PLUGIN_PATH: + name: Cache Plugins Path + default: ~/.ansible/plugins/cache:/usr/share/ansible/plugins/cache + description: Colon separated paths in which Ansible will search for Cache Plugins. + env: [{name: ANSIBLE_CACHE_PLUGINS}] + ini: + - {key: cache_plugins, section: defaults} + type: pathspec +DEFAULT_CALLABLE_WHITELIST: + name: Template 'callable' whitelist + default: [] + description: Whitelist of callable methods to be made available to template evaluation + env: [{name: ANSIBLE_CALLABLE_WHITELIST}] + ini: + - {key: callable_whitelist, section: defaults} + type: list +DEFAULT_CALLBACK_PLUGIN_PATH: + name: Callback Plugins Path + default: ~/.ansible/plugins/callback:/usr/share/ansible/plugins/callback + description: Colon separated paths in which Ansible will search for Callback Plugins. + env: [{name: ANSIBLE_CALLBACK_PLUGINS}] + ini: + - {key: callback_plugins, section: defaults} + type: pathspec + yaml: {key: plugins.callback.path} +DEFAULT_CALLBACK_WHITELIST: + name: Callback Whitelist + default: [] + description: + - "List of whitelisted callbacks, not all callbacks need whitelisting, + but many of those shipped with Ansible do as we don't want them activated by default." + env: [{name: ANSIBLE_CALLBACK_WHITELIST}] + ini: + - {key: callback_whitelist, section: defaults} + type: list + yaml: {key: plugins.callback.whitelist} +DEFAULT_CLICONF_PLUGIN_PATH: + name: Cliconf Plugins Path + default: ~/.ansible/plugins/cliconf:/usr/share/ansible/plugins/cliconf + description: Colon separated paths in which Ansible will search for Cliconf Plugins. + env: [{name: ANSIBLE_CLICONF_PLUGINS}] + ini: + - {key: cliconf_plugins, section: defaults} + type: pathspec +DEFAULT_CONNECTION_PLUGIN_PATH: + name: Connection Plugins Path + default: ~/.ansible/plugins/connection:/usr/share/ansible/plugins/connection + description: Colon separated paths in which Ansible will search for Connection Plugins. + env: [{name: ANSIBLE_CONNECTION_PLUGINS}] + ini: + - {key: connection_plugins, section: defaults} + type: pathspec + yaml: {key: plugins.connection.path} +DEFAULT_DEBUG: + name: Debug mode + default: False + description: + - "Toggles debug output in Ansible. This is *very* verbose and can hinder + multiprocessing. Debug output can also include secret information + despite no_log settings being enabled, which means debug mode should not be used in + production." + env: [{name: ANSIBLE_DEBUG}] + ini: + - {key: debug, section: defaults} + type: boolean +DEFAULT_EXECUTABLE: + name: Target shell executable + default: /bin/sh + description: + - "This indicates the command to use to spawn a shell under for Ansible's execution needs on a target. + Users may need to change this in rare instances when shell usage is constrained, but in most cases it may be left as is." + env: [{name: ANSIBLE_EXECUTABLE}] + ini: + - {key: executable, section: defaults} +DEFAULT_FACT_PATH: + name: local fact path + default: ~ + description: + - "This option allows you to globally configure a custom path for 'local_facts' for the implied M(setup) task when using fact gathering." + - "If not set, it will fallback to the default from the M(setup) module: ``/etc/ansible/facts.d``." + - "This does **not** affect user defined tasks that use the M(setup) module." + env: [{name: ANSIBLE_FACT_PATH}] + ini: + - {key: fact_path, section: defaults} + type: path + yaml: {key: facts.gathering.fact_path} +DEFAULT_FILTER_PLUGIN_PATH: + name: Jinja2 Filter Plugins Path + default: ~/.ansible/plugins/filter:/usr/share/ansible/plugins/filter + description: Colon separated paths in which Ansible will search for Jinja2 Filter Plugins. + env: [{name: ANSIBLE_FILTER_PLUGINS}] + ini: + - {key: filter_plugins, section: defaults} + type: pathspec +DEFAULT_FORCE_HANDLERS: + name: Force handlers to run after failure + default: False + description: + - This option controls if notified handlers run on a host even if a failure occurs on that host. + - When false, the handlers will not run if a failure has occurred on a host. + - This can also be set per play or on the command line. See Handlers and Failure for more details. + env: [{name: ANSIBLE_FORCE_HANDLERS}] + ini: + - {key: force_handlers, section: defaults} + type: boolean + version_added: "1.9.1" +DEFAULT_FORKS: + name: Number of task forks + default: 5 + description: Maximum number of forks Ansible will use to execute tasks on target hosts. + env: [{name: ANSIBLE_FORKS}] + ini: + - {key: forks, section: defaults} + type: integer +DEFAULT_GATHERING: + name: Gathering behaviour + default: 'implicit' + description: + - This setting controls the default policy of fact gathering (facts discovered about remote systems). + - "When 'implicit' (the default), the cache plugin will be ignored and facts will be gathered per play unless 'gather_facts: False' is set." + - "When 'explicit' the inverse is true, facts will not be gathered unless directly requested in the play." + - "The 'smart' value means each new host that has no facts discovered will be scanned, + but if the same host is addressed in multiple plays it will not be contacted again in the playbook run." + - "This option can be useful for those wishing to save fact gathering time. Both 'smart' and 'explicit' will use the cache plugin." + env: [{name: ANSIBLE_GATHERING}] + ini: + - key: gathering + section: defaults + version_added: "1.6" + choices: ['smart', 'explicit', 'implicit'] +DEFAULT_GATHER_SUBSET: + name: Gather facts subset + default: ['all'] + description: + - Set the `gather_subset` option for the M(setup) task in the implicit fact gathering. + See the module documentation for specifics. + - "It does **not** apply to user defined M(setup) tasks." + env: [{name: ANSIBLE_GATHER_SUBSET}] + ini: + - key: gather_subset + section: defaults + version_added: "2.1" +DEFAULT_GATHER_TIMEOUT: + name: Gather facts timeout + default: 10 + description: + - Set the timeout in seconds for the implicit fact gathering. + - "It does **not** apply to user defined M(setup) tasks." + env: [{name: ANSIBLE_GATHER_TIMEOUT}] + ini: + - {key: gather_timeout, section: defaults} + type: integer + yaml: {key: defaults.gather_timeout} +DEFAULT_HANDLER_INCLUDES_STATIC: + name: Make handler M(include) static + default: False + description: + - "Since 2.0 M(include) can be 'dynamic', this setting (if True) forces that if the include appears in a ``handlers`` section to be 'static'." + env: [{name: ANSIBLE_HANDLER_INCLUDES_STATIC}] + ini: + - {key: handler_includes_static, section: defaults} + type: boolean + deprecated: + why: include itself is deprecated and this setting will not matter in the future + version: "2.8" + alternatives: none as its already built into the decision between include_tasks and import_tasks +DEFAULT_HASH_BEHAVIOUR: + name: Hash merge behaviour + default: replace + type: string + choices: ["replace", "merge"] + description: + - This setting controls how variables merge in Ansible. + By default Ansible will override variables in specific precedence orders, as described in Variables. + When a variable of higher precedence wins, it will replace the other value. + - "Some users prefer that variables that are hashes (aka 'dictionaries' in Python terms) are merged. + This setting is called 'merge'. This is not the default behavior and it does not affect variables whose values are scalars + (integers, strings) or arrays. We generally recommend not using this setting unless you think you have an absolute need for it, + and playbooks in the official examples repos do not use this setting" + - In version 2.0 a ``combine`` filter was added to allow doing this for a particular variable (described in Filters). + env: [{name: ANSIBLE_HASH_BEHAVIOUR}] + ini: + - {key: hash_behaviour, section: defaults} +DEFAULT_HOST_LIST: + name: Inventory Source + default: /etc/ansible/hosts + description: Comma separated list of Ansible inventory sources + env: + - name: ANSIBLE_HOSTS + deprecated: + why: The variable is misleading as it can be a list of hosts and/or paths to inventory sources + version: "2.8" + alternatives: ANSIBLE_INVENTORY + - name: ANSIBLE_INVENTORY + expand_relative_paths: True + ini: + - key: hostfile + section: defaults + deprecated: + why: The key is misleading as it can also be a list of hosts, a directory or a list of paths + version: "2.8" + alternatives: "[defaults]\ninventory=/path/to/file|dir" + - key: inventory + section: defaults + type: pathlist + yaml: {key: defaults.inventory} +DEFAULT_HTTPAPI_PLUGIN_PATH: + name: HttpApi Plugins Path + default: ~/.ansible/plugins/httpapi:/usr/share/ansible/plugins/httpapi + description: Colon separated paths in which Ansible will search for HttpApi Plugins. + env: [{name: ANSIBLE_HTTPAPI_PLUGINS}] + ini: + - {key: httpapi_plugins, section: defaults} + type: pathspec +DEFAULT_INTERNAL_POLL_INTERVAL: + name: Internal poll interval + default: 0.001 + env: [] + ini: + - {key: internal_poll_interval, section: defaults} + type: float + version_added: "2.2" + description: + - This sets the interval (in seconds) of Ansible internal processes polling each other. + Lower values improve performance with large playbooks at the expense of extra CPU load. + Higher values are more suitable for Ansible usage in automation scenarios, + when UI responsiveness is not required but CPU usage might be a concern. + - "The default corresponds to the value hardcoded in Ansible <= 2.1" +DEFAULT_INVENTORY_PLUGIN_PATH: + name: Inventory Plugins Path + default: ~/.ansible/plugins/inventory:/usr/share/ansible/plugins/inventory + description: Colon separated paths in which Ansible will search for Inventory Plugins. + env: [{name: ANSIBLE_INVENTORY_PLUGINS}] + ini: + - {key: inventory_plugins, section: defaults} + type: pathspec +DEFAULT_JINJA2_EXTENSIONS: + name: Enabled Jinja2 extensions + default: [] + description: + - This is a developer-specific feature that allows enabling additional Jinja2 extensions. + - "See the Jinja2 documentation for details. If you do not know what these do, you probably don't need to change this setting :)" + env: [{name: ANSIBLE_JINJA2_EXTENSIONS}] + ini: + - {key: jinja2_extensions, section: defaults} +DEFAULT_JINJA2_NATIVE: + name: Use Jinja2's NativeEnvironment for templating + default: False + description: This option preserves variable types during template operations. This requires Jinja2 >= 2.10. + env: [{name: ANSIBLE_JINJA2_NATIVE}] + ini: + - {key: jinja2_native, section: defaults} + type: boolean + yaml: {key: jinja2_native} + version_added: 2.7 +DEFAULT_KEEP_REMOTE_FILES: + name: Keep remote files + default: False + description: Enables/disables the cleaning up of the temporary files Ansible used to execute the tasks on the remote. + env: [{name: ANSIBLE_KEEP_REMOTE_FILES}] + ini: + - {key: keep_remote_files, section: defaults} + type: boolean +DEFAULT_LIBVIRT_LXC_NOSECLABEL: + # TODO: move to plugin + name: No security label on Lxc + default: False + description: + - "This setting causes libvirt to connect to lxc containers by passing --noseclabel to virsh. + This is necessary when running on systems which do not have SELinux." + env: [{name: LIBVIRT_LXC_NOSECLABEL}] + ini: + - {key: libvirt_lxc_noseclabel, section: selinux} + type: boolean + version_added: "2.1" +DEFAULT_LOAD_CALLBACK_PLUGINS: + name: Load callbacks for adhoc + default: False + description: + - Controls whether callback plugins are loaded when running /usr/bin/ansible. + This may be used to log activity from the command line, send notifications, and so on. + Callback plugins are always loaded for ``ansible-playbook``. + env: [{name: ANSIBLE_LOAD_CALLBACK_PLUGINS}] + ini: + - {key: bin_ansible_callbacks, section: defaults} + type: boolean + version_added: "1.8" +DEFAULT_LOCAL_TMP: + name: Controller temporary directory + default: ~/.ansible/tmp + description: Temporary directory for Ansible to use on the controller. + env: [{name: ANSIBLE_LOCAL_TEMP}] + ini: + - {key: local_tmp, section: defaults} + type: tmppath +DEFAULT_LOG_PATH: + name: Ansible log file path + default: ~ + description: File to which Ansible will log on the controller. When empty logging is disabled. + env: [{name: ANSIBLE_LOG_PATH}] + ini: + - {key: log_path, section: defaults} + type: path +DEFAULT_LOG_FILTER: + name: Name filters for python logger + default: [] + description: List of logger names to filter out of the log file + env: [{name: ANSIBLE_LOG_FILTER}] + ini: + - {key: log_filter, section: defaults} + type: list +DEFAULT_LOOKUP_PLUGIN_PATH: + name: Lookup Plugins Path + description: Colon separated paths in which Ansible will search for Lookup Plugins. + default: ~/.ansible/plugins/lookup:/usr/share/ansible/plugins/lookup + env: [{name: ANSIBLE_LOOKUP_PLUGINS}] + ini: + - {key: lookup_plugins, section: defaults} + type: pathspec + yaml: {key: defaults.lookup_plugins} +DEFAULT_MANAGED_STR: + name: Ansible managed + default: 'Ansible managed' + description: Sets the macro for the 'ansible_managed' variable available for M(template) and M(win_template) modules. This is only relevant for those two modules. + env: [] + ini: + - {key: ansible_managed, section: defaults} + yaml: {key: defaults.ansible_managed} +DEFAULT_MODULE_ARGS: + name: Adhoc default arguments + default: '' + description: + - This sets the default arguments to pass to the ``ansible`` adhoc binary if no ``-a`` is specified. + env: [{name: ANSIBLE_MODULE_ARGS}] + ini: + - {key: module_args, section: defaults} +DEFAULT_MODULE_COMPRESSION: + name: Python module compression + default: ZIP_DEFLATED + description: Compression scheme to use when transferring Python modules to the target. + env: [] + ini: + - {key: module_compression, section: defaults} +# vars: +# - name: ansible_module_compression +DEFAULT_MODULE_LANG: + name: Target language environment + default: "{{ CONTROLLER_LANG }}" + description: + - "Language locale setting to use for modules when they execute on the target." + - "If empty it tries to set itself to the LANG environment variable on the controller." + - "This is only used if DEFAULT_MODULE_SET_LOCALE is set to true" + env: [{name: ANSIBLE_MODULE_LANG}] + ini: + - {key: module_lang, section: defaults} + deprecated: + why: Modules are coded to set their own locale if needed for screenscraping + version: "2.9" +DEFAULT_MODULE_NAME: + name: Default adhoc module + default: command + description: "Module to use with the ``ansible`` AdHoc command, if none is specified via ``-m``." + env: [] + ini: + - {key: module_name, section: defaults} +DEFAULT_MODULE_PATH: + name: Modules Path + description: Colon separated paths in which Ansible will search for Modules. + default: ~/.ansible/plugins/modules:/usr/share/ansible/plugins/modules + env: [{name: ANSIBLE_LIBRARY}] + ini: + - {key: library, section: defaults} + type: pathspec +DEFAULT_MODULE_SET_LOCALE: + name: Target locale + default: False + description: + - Controls if we set locale for modules when executing on the target. + env: [{name: ANSIBLE_MODULE_SET_LOCALE}] + ini: + - {key: module_set_locale, section: defaults} + type: boolean + deprecated: + why: Modules are coded to set their own locale if needed for screenscraping + version: "2.9" +DEFAULT_MODULE_UTILS_PATH: + name: Module Utils Path + description: Colon separated paths in which Ansible will search for Module utils files, which are shared by modules. + default: ~/.ansible/plugins/module_utils:/usr/share/ansible/plugins/module_utils + env: [{name: ANSIBLE_MODULE_UTILS}] + ini: + - {key: module_utils, section: defaults} + type: pathspec +DEFAULT_NETCONF_PLUGIN_PATH: + name: Netconf Plugins Path + default: ~/.ansible/plugins/netconf:/usr/share/ansible/plugins/netconf + description: Colon separated paths in which Ansible will search for Netconf Plugins. + env: [{name: ANSIBLE_NETCONF_PLUGINS}] + ini: + - {key: netconf_plugins, section: defaults} + type: pathspec +DEFAULT_NO_LOG: + name: No log + default: False + description: "Toggle Ansible's display and logging of task details, mainly used to avoid security disclosures." + env: [{name: ANSIBLE_NO_LOG}] + ini: + - {key: no_log, section: defaults} + type: boolean +DEFAULT_NO_TARGET_SYSLOG: + name: No syslog on target + default: False + description: Toggle Ansible logging to syslog on the target when it executes tasks. + env: [{name: ANSIBLE_NO_TARGET_SYSLOG}] + ini: + - {key: no_target_syslog, section: defaults} + type: boolean + yaml: {key: defaults.no_target_syslog} +DEFAULT_NULL_REPRESENTATION: + name: Represent a null + default: ~ + description: What templating should return as a 'null' value. When not set it will let Jinja2 decide. + env: [{name: ANSIBLE_NULL_REPRESENTATION}] + ini: + - {key: null_representation, section: defaults} + type: none +DEFAULT_POLL_INTERVAL: + name: Async poll interval + default: 15 + description: + - For asynchronous tasks in Ansible (covered in Asynchronous Actions and Polling), + this is how often to check back on the status of those tasks when an explicit poll interval is not supplied. + The default is a reasonably moderate 15 seconds which is a tradeoff between checking in frequently and + providing a quick turnaround when something may have completed. + env: [{name: ANSIBLE_POLL_INTERVAL}] + ini: + - {key: poll_interval, section: defaults} + type: integer +DEFAULT_PRIVATE_KEY_FILE: + name: Private key file + default: ~ + description: + - Option for connections using a certificate or key file to authenticate, rather than an agent or passwords, + you can set the default value here to avoid re-specifying --private-key with every invocation. + env: [{name: ANSIBLE_PRIVATE_KEY_FILE}] + ini: + - {key: private_key_file, section: defaults} + type: path +DEFAULT_PRIVATE_ROLE_VARS: + name: Private role variables + default: False + description: + - Makes role variables inaccessible from other roles. + - This was introduced as a way to reset role variables to default values if + a role is used more than once in a playbook. + env: [{name: ANSIBLE_PRIVATE_ROLE_VARS}] + ini: + - {key: private_role_vars, section: defaults} + type: boolean + yaml: {key: defaults.private_role_vars} +DEFAULT_REMOTE_PORT: + name: Remote port + default: ~ + description: Port to use in remote connections, when blank it will use the connection plugin default. + env: [{name: ANSIBLE_REMOTE_PORT}] + ini: + - {key: remote_port, section: defaults} + type: integer + yaml: {key: defaults.remote_port} +DEFAULT_REMOTE_USER: + name: Login/Remote User + default: + description: + - Sets the login user for the target machines + - "When blank it uses the connection plugin's default, normally the user currently executing Ansible." + env: [{name: ANSIBLE_REMOTE_USER}] + ini: + - {key: remote_user, section: defaults} +DEFAULT_ROLES_PATH: + name: Roles path + default: ~/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles + description: Colon separated paths in which Ansible will search for Roles. + env: [{name: ANSIBLE_ROLES_PATH}] + expand_relative_paths: True + ini: + - {key: roles_path, section: defaults} + type: pathspec + yaml: {key: defaults.roles_path} +DEFAULT_SCP_IF_SSH: + # TODO: move to ssh plugin + default: smart + description: + - "Preferred method to use when transferring files over ssh." + - When set to smart, Ansible will try them until one succeeds or they all fail. + - If set to True, it will force 'scp', if False it will use 'sftp'. + env: [{name: ANSIBLE_SCP_IF_SSH}] + ini: + - {key: scp_if_ssh, section: ssh_connection} +DEFAULT_SELINUX_SPECIAL_FS: + name: Problematic file systems + default: fuse, nfs, vboxsf, ramfs, 9p + description: + - "Some filesystems do not support safe operations and/or return inconsistent errors, + this setting makes Ansible 'tolerate' those in the list w/o causing fatal errors." + - Data corruption may occur and writes are not always verified when a filesystem is in the list. + env: [] + ini: + - {key: special_context_filesystems, section: selinux} + type: list +DEFAULT_SFTP_BATCH_MODE: + # TODO: move to ssh plugin + default: True + description: 'TODO: write it' + env: [{name: ANSIBLE_SFTP_BATCH_MODE}] + ini: + - {key: sftp_batch_mode, section: ssh_connection} + type: boolean + yaml: {key: ssh_connection.sftp_batch_mode} +DEFAULT_SQUASH_ACTIONS: + name: Squashable actions + default: apk, apt, dnf, homebrew, openbsd_pkg, pacman, pip, pkgng, yum, zypper + description: + - Ansible can optimise actions that call modules that support list parameters when using ``with_`` looping. + Instead of calling the module once for each item, the module is called once with the full list. + - The default value for this setting is only for certain package managers, but it can be used for any module. + - Currently, this is only supported for modules that have a name or pkg parameter, and only when the item is the only thing being passed to the parameter. + env: [{name: ANSIBLE_SQUASH_ACTIONS}] + ini: + - {key: squash_actions, section: defaults} + type: list + version_added: "2.0" + deprecated: + why: Loop squashing is deprecated and this configuration will no longer be used + version: "2.11" + alternatives: a list directly with the module argument +DEFAULT_SSH_TRANSFER_METHOD: + # TODO: move to ssh plugin + default: + description: 'unused?' + # - "Preferred method to use when transferring files over ssh" + # - Setting to smart will try them until one succeeds or they all fail + #choices: ['sftp', 'scp', 'dd', 'smart'] + env: [{name: ANSIBLE_SSH_TRANSFER_METHOD}] + ini: + - {key: transfer_method, section: ssh_connection} +DEFAULT_STDOUT_CALLBACK: + name: Main display callback plugin + default: default + description: + - "Set the main callback used to display Ansible output, you can only have one at a time." + - You can have many other callbacks, but just one can be in charge of stdout. + env: [{name: ANSIBLE_STDOUT_CALLBACK}] + ini: + - {key: stdout_callback, section: defaults} +ENABLE_TASK_DEBUGGER: + name: Whether to enable the task debugger + default: False + description: + - Whether or not to enable the task debugger, this previously was done as a strategy plugin. + - Now all strategy plugins can inherit this behavior. The debugger defaults to activating when + - a task is failed on unreachable. Use the debugger keyword for more flexibility. + type: boolean + env: [{name: ANSIBLE_ENABLE_TASK_DEBUGGER}] + ini: + - {key: enable_task_debugger, section: defaults} + version_added: "2.5" +TASK_DEBUGGER_IGNORE_ERRORS: + name: Whether a failed task with ignore_errors=True will still invoke the debugger + default: True + description: + - This option defines whether the task debugger will be invoked on a failed task when ignore_errors=True + is specified. + - True specifies that the debugger will honor ignore_errors, False will not honor ignore_errors. + type: boolean + env: [{name: ANSIBLE_TASK_DEBUGGER_IGNORE_ERRORS}] + ini: + - {key: task_debugger_ignore_errors, section: defaults} + version_added: "2.7" +DEFAULT_STRATEGY: + name: Implied strategy + default: 'linear' + description: Set the default strategy used for plays. + env: [{name: ANSIBLE_STRATEGY}] + ini: + - {key: strategy, section: defaults} + version_added: "2.3" +DEFAULT_STRATEGY_PLUGIN_PATH: + name: Strategy Plugins Path + description: Colon separated paths in which Ansible will search for Strategy Plugins. + default: ~/.ansible/plugins/strategy:/usr/share/ansible/plugins/strategy + env: [{name: ANSIBLE_STRATEGY_PLUGINS}] + ini: + - {key: strategy_plugins, section: defaults} + type: pathspec +DEFAULT_SU: + default: False + description: 'Toggle the use of "su" for tasks.' + env: [{name: ANSIBLE_SU}] + ini: + - {key: su, section: defaults} + type: boolean + yaml: {key: defaults.su} +DEFAULT_SUDO: + default: False + deprecated: + why: In favor of Ansible Become, which is a generic framework + version: "2.8" + alternatives: become + description: 'Toggle the use of "sudo" for tasks.' + env: [{name: ANSIBLE_SUDO}] + ini: + - {key: sudo, section: defaults} + type: boolean +DEFAULT_SUDO_EXE: + name: sudo executable + default: sudo + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_exe. + version: "2.8" + alternatives: become + description: 'specify an "sudo" executable, otherwise it relies on PATH.' + env: [{name: ANSIBLE_SUDO_EXE}] + ini: + - {key: sudo_exe, section: defaults} +DEFAULT_SUDO_FLAGS: + name: sudo flags + default: '-H -S -n' + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_flags. + version: "2.8" + alternatives: become + description: 'Flags to pass to "sudo"' + env: [{name: ANSIBLE_SUDO_FLAGS}] + ini: + - {key: sudo_flags, section: defaults} +DEFAULT_SUDO_USER: + name: sudo user + default: + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_user. + version: "2.8" + alternatives: become + description: 'User you become when using "sudo", leaving it blank will use the default configured on the target (normally root)' + env: [{name: ANSIBLE_SUDO_USER}] + ini: + - {key: sudo_user, section: defaults} +DEFAULT_SU_EXE: + name: su executable + default: su + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_exe. + version: "2.8" + alternatives: become + description: 'specify an "su" executable, otherwise it relies on PATH.' + env: [{name: ANSIBLE_SU_EXE}] + ini: + - {key: su_exe, section: defaults} +DEFAULT_SU_FLAGS: + name: su flags + default: '' + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_flags. + version: "2.8" + alternatives: become + description: 'Flags to pass to su' + env: [{name: ANSIBLE_SU_FLAGS}] + ini: + - {key: su_flags, section: defaults} +DEFAULT_SU_USER: + name: su user + default: + description: 'User you become when using "su", leaving it blank will use the default configured on the target (normally root)' + env: [{name: ANSIBLE_SU_USER}] + ini: + - {key: su_user, section: defaults} + deprecated: + why: In favor of Ansible Become, which is a generic framework. See become_user. + version: "2.8" + alternatives: become +DEFAULT_SYSLOG_FACILITY: + name: syslog facility + default: LOG_USER + description: Syslog facility to use when Ansible logs to the remote target + env: [{name: ANSIBLE_SYSLOG_FACILITY}] + ini: + - {key: syslog_facility, section: defaults} +DEFAULT_TASK_INCLUDES_STATIC: + name: Task include static + default: False + description: + - The `include` tasks can be static or dynamic, this toggles the default expected behaviour if autodetection fails and it is not explicitly set in task. + env: [{name: ANSIBLE_TASK_INCLUDES_STATIC}] + ini: + - {key: task_includes_static, section: defaults} + type: boolean + version_added: "2.1" + deprecated: + why: include itself is deprecated and this setting will not matter in the future + version: "2.8" + alternatives: None, as its already built into the decision between include_tasks and import_tasks +DEFAULT_TERMINAL_PLUGIN_PATH: + name: Terminal Plugins Path + default: ~/.ansible/plugins/terminal:/usr/share/ansible/plugins/terminal + description: Colon separated paths in which Ansible will search for Terminal Plugins. + env: [{name: ANSIBLE_TERMINAL_PLUGINS}] + ini: + - {key: terminal_plugins, section: defaults} + type: pathspec +DEFAULT_TEST_PLUGIN_PATH: + name: Jinja2 Test Plugins Path + description: Colon separated paths in which Ansible will search for Jinja2 Test Plugins. + default: ~/.ansible/plugins/test:/usr/share/ansible/plugins/test + env: [{name: ANSIBLE_TEST_PLUGINS}] + ini: + - {key: test_plugins, section: defaults} + type: pathspec +DEFAULT_TIMEOUT: + name: Connection timeout + default: 10 + description: This is the default timeout for connection plugins to use. + env: [{name: ANSIBLE_TIMEOUT}] + ini: + - {key: timeout, section: defaults} + type: integer +DEFAULT_TRANSPORT: + name: Connection plugin + default: smart + description: "Default connection plugin to use, the 'smart' option will toggle between 'ssh' and 'paramiko' depending on controller OS and ssh versions" + env: [{name: ANSIBLE_TRANSPORT}] + ini: + - {key: transport, section: defaults} +DEFAULT_UNDEFINED_VAR_BEHAVIOR: + name: Jinja2 fail on undefined + default: True + version_added: "1.3" + description: + - When True, this causes ansible templating to fail steps that reference variable names that are likely typoed. + - "Otherwise, any '{{ template_expression }}' that contains undefined variables will be rendered in a template or ansible action line exactly as written." + env: [{name: ANSIBLE_ERROR_ON_UNDEFINED_VARS}] + ini: + - {key: error_on_undefined_vars, section: defaults} + type: boolean +DEFAULT_VARS_PLUGIN_PATH: + name: Vars Plugins Path + default: ~/.ansible/plugins/vars:/usr/share/ansible/plugins/vars + description: Colon separated paths in which Ansible will search for Vars Plugins. + env: [{name: ANSIBLE_VARS_PLUGINS}] + ini: + - {key: vars_plugins, section: defaults} + type: pathspec +# TODO: unused? +#DEFAULT_VAR_COMPRESSION_LEVEL: +# default: 0 +# description: 'TODO: write it' +# env: [{name: ANSIBLE_VAR_COMPRESSION_LEVEL}] +# ini: +# - {key: var_compression_level, section: defaults} +# type: integer +# yaml: {key: defaults.var_compression_level} +DEFAULT_VAULT_ID_MATCH: + name: Force vault id match + default: False + description: 'If true, decrypting vaults with a vault id will only try the password from the matching vault-id' + env: [{name: ANSIBLE_VAULT_ID_MATCH}] + ini: + - {key: vault_id_match, section: defaults} + yaml: {key: defaults.vault_id_match} +DEFAULT_VAULT_IDENTITY: + name: Vault id label + default: default + description: 'The label to use for the default vault id label in cases where a vault id label is not provided' + env: [{name: ANSIBLE_VAULT_IDENTITY}] + ini: + - {key: vault_identity, section: defaults} + yaml: {key: defaults.vault_identity} +DEFAULT_VAULT_ENCRYPT_IDENTITY: + name: Vault id to use for encryption + default: + description: 'The vault_id to use for encrypting by default. If multiple vault_ids are provided, this specifies which to use for encryption. The --encrypt-vault-id cli option overrides the configured value.' + env: [{name: ANSIBLE_VAULT_ENCRYPT_IDENTITY}] + ini: + - {key: vault_encrypt_identity, section: defaults} + yaml: {key: defaults.vault_encrypt_identity} +DEFAULT_VAULT_IDENTITY_LIST: + name: Default vault ids + default: [] + description: 'A list of vault-ids to use by default. Equivalent to multiple --vault-id args. Vault-ids are tried in order.' + env: [{name: ANSIBLE_VAULT_IDENTITY_LIST}] + ini: + - {key: vault_identity_list, section: defaults} + type: list + yaml: {key: defaults.vault_identity_list} +DEFAULT_VAULT_PASSWORD_FILE: + name: Vault password file + default: ~ + description: 'The vault password file to use. Equivalent to --vault-password-file or --vault-id' + env: [{name: ANSIBLE_VAULT_PASSWORD_FILE}] + ini: + - {key: vault_password_file, section: defaults} + type: path + yaml: {key: defaults.vault_password_file} +DEFAULT_VERBOSITY: + name: Verbosity + default: 0 + description: Sets the default verbosity, equivalent to the number of ``-v`` passed in the command line. + env: [{name: ANSIBLE_VERBOSITY}] + ini: + - {key: verbosity, section: defaults} + type: integer +DEPRECATION_WARNINGS: + name: Deprecation messages + default: True + description: "Toggle to control the showing of deprecation warnings" + env: [{name: ANSIBLE_DEPRECATION_WARNINGS}] + ini: + - {key: deprecation_warnings, section: defaults} + type: boolean +DIFF_ALWAYS: + name: Show differences + default: False + description: Configuration toggle to tell modules to show differences when in 'changed' status, equivalent to ``--diff``. + env: [{name: ANSIBLE_DIFF_ALWAYS}] + ini: + - {key: always, section: diff} + type: bool +DIFF_CONTEXT: + name: Difference context + default: 3 + description: How many lines of context to show when displaying the differences between files. + env: [{name: ANSIBLE_DIFF_CONTEXT}] + ini: + - {key: context, section: diff} + type: integer +DISPLAY_ARGS_TO_STDOUT: + name: Show task arguments + default: False + description: + - "Normally ``ansible-playbook`` will print a header for each task that is run. + These headers will contain the name: field from the task if you specified one. + If you didn't then ``ansible-playbook`` uses the task's action to help you tell which task is presently running. + Sometimes you run many of the same action and so you want more information about the task to differentiate it from others of the same action. + If you set this variable to True in the config then ``ansible-playbook`` will also include the task's arguments in the header." + - "This setting defaults to False because there is a chance that you have sensitive values in your parameters and + you do not want those to be printed." + - "If you set this to True you should be sure that you have secured your environment's stdout + (no one can shoulder surf your screen and you aren't saving stdout to an insecure file) or + made sure that all of your playbooks explicitly added the ``no_log: True`` parameter to tasks which have sensitive values + See How do I keep secret data in my playbook? for more information." + env: [{name: ANSIBLE_DISPLAY_ARGS_TO_STDOUT}] + ini: + - {key: display_args_to_stdout, section: defaults} + type: boolean + version_added: "2.1" +DISPLAY_SKIPPED_HOSTS: + name: Show skipped results + default: True + description: "Toggle to control displaying skipped task/host entries in a task in the default callback" + env: [{name: DISPLAY_SKIPPED_HOSTS}] + ini: + - {key: display_skipped_hosts, section: defaults} + type: boolean +ERROR_ON_MISSING_HANDLER: + name: Missing handler error + default: True + description: "Toggle to allow missing handlers to become a warning instead of an error when notifying." + env: [{name: ANSIBLE_ERROR_ON_MISSING_HANDLER}] + ini: + - {key: error_on_missing_handler, section: defaults} + type: boolean +GALAXY_IGNORE_CERTS: + name: Galaxy validate certs + default: False + description: + - If set to yes, ansible-galaxy will not validate TLS certificates. + This can be useful for testing against a server with a self-signed certificate. + env: [{name: ANSIBLE_GALAXY_IGNORE}] + ini: + - {key: ignore_certs, section: galaxy} + type: boolean +GALAXY_ROLE_SKELETON: + name: Galaxy skeleton direcotry + default: + description: Role skeleton directory to use as a template for the ``init`` action in ``ansible-galaxy``, same as ``--role-skeleton``. + env: [{name: ANSIBLE_GALAXY_ROLE_SKELETON}] + ini: + - {key: role_skeleton, section: galaxy} + type: path +GALAXY_ROLE_SKELETON_IGNORE: + name: Galaxy skeleton ignore + default: ["^.git$", "^.*/.git_keep$"] + description: patterns of files to ignore inside a galaxy role skeleton directory + env: [{name: ANSIBLE_GALAXY_ROLE_SKELETON_IGNORE}] + ini: + - {key: role_skeleton_ignore, section: galaxy} + type: list +# TODO: unused? +#GALAXY_SCMS: +# name: Galaxy SCMS +# default: git, hg +# description: Available galaxy source control management systems. +# env: [{name: ANSIBLE_GALAXY_SCMS}] +# ini: +# - {key: scms, section: galaxy} +# type: list +GALAXY_SERVER: + default: https://galaxy.ansible.com + description: "URL to prepend when roles don't specify the full URI, assume they are referencing this server as the source." + env: [{name: ANSIBLE_GALAXY_SERVER}] + ini: + - {key: server, section: galaxy} + yaml: {key: galaxy.server} +GALAXY_TOKEN: + default: null + description: "GitHub personal access token" + env: [{name: ANSIBLE_GALAXY_TOKEN}] + ini: + - {key: token, section: galaxy} + yaml: {key: galaxy.token} +HOST_KEY_CHECKING: + name: Check host keys + default: True + description: 'Set this to "False" if you want to avoid host key checking by the underlying tools Ansible uses to connect to the host' + env: [{name: ANSIBLE_HOST_KEY_CHECKING}] + ini: + - {key: host_key_checking, section: defaults} + type: boolean +INVALID_TASK_ATTRIBUTE_FAILED: + name: Controls whether invalid attributes for a task result in errors instead of warnings + default: True + description: If 'false', invalid attributes for a task will result in warnings instead of errors + type: boolean + env: + - name: ANSIBLE_INVALID_TASK_ATTRIBUTE_FAILED + ini: + - key: invalid_task_attribute_failed + section: defaults + version_added: "2.7" +INVENTORY_ANY_UNPARSED_IS_FAILED: + name: Controls whether any unparseable inventory source is a fatal error + default: False + description: > + If 'true', it is a fatal error when any given inventory source + cannot be successfully parsed by any available inventory plugin; + otherwise, this situation only attracts a warning. + type: boolean + env: [{name: ANSIBLE_INVENTORY_ANY_UNPARSED_IS_FAILED}] + ini: + - {key: any_unparsed_is_failed, section: inventory} + version_added: "2.7" +INVENTORY_ENABLED: + name: Active Inventory plugins + default: ['host_list', 'script', 'yaml', 'ini', 'auto'] + description: List of enabled inventory plugins, it also determines the order in which they are used. + env: [{name: ANSIBLE_INVENTORY_ENABLED}] + ini: + - {key: enable_plugins, section: inventory} + type: list +INVENTORY_EXPORT: + name: Set ansible-inventory into export mode + default: False + description: Controls if ansible-inventory will accurately reflect Ansible's view into inventory or its optimized for exporting. + env: [{name: ANSIBLE_INVENTORY_EXPORT}] + ini: + - {key: export, section: inventory} + type: bool +INVENTORY_IGNORE_EXTS: + name: Inventory ignore extensions + default: "{{(BLACKLIST_EXTS + ( '~', '.orig', '.ini', '.cfg', '.retry'))}}" + description: List of extensions to ignore when using a directory as an inventory source + env: [{name: ANSIBLE_INVENTORY_IGNORE}] + ini: + - {key: inventory_ignore_extensions, section: defaults} + - {key: ignore_extensions, section: inventory} + type: list +INVENTORY_IGNORE_PATTERNS: + name: Inventory ignore patterns + default: [] + description: List of patterns to ignore when using a directory as an inventory source + env: [{name: ANSIBLE_INVENTORY_IGNORE_REGEX}] + ini: + - {key: inventory_ignore_patterns, section: defaults} + - {key: ignore_patterns, section: inventory} + type: list +INVENTORY_UNPARSED_IS_FAILED: + name: Unparsed Inventory failure + default: False + description: > + If 'true' it is a fatal error if every single potential inventory + source fails to parse, otherwise this situation will only attract a + warning. + env: [{name: ANSIBLE_INVENTORY_UNPARSED_FAILED}] + ini: + - {key: unparsed_is_failed, section: inventory} + type: bool +MAX_FILE_SIZE_FOR_DIFF: + name: Diff maximum file size + default: 104448 + description: Maximum size of files to be considered for diff display + env: [{name: ANSIBLE_MAX_DIFF_SIZE}] + ini: + - {key: max_diff_size, section: defaults} + type: int +NETWORK_GROUP_MODULES: + name: Network module families + default: [eos, nxos, ios, iosxr, junos, enos, ce, vyos, sros, dellos9, dellos10, dellos6, asa, aruba, aireos, bigip, ironware, onyx, netconf] + description: 'TODO: write it' + env: [{name: NETWORK_GROUP_MODULES}] + ini: + - {key: network_group_modules, section: defaults} + type: list + yaml: {key: defaults.network_group_modules} +INJECT_FACTS_AS_VARS: + default: True + description: + - Facts are available inside the `ansible_facts` variable, this setting also pushes them as their own vars in the main namespace. + - Unlike inside the `ansible_facts` dictionary, these will have an `ansible_` prefix. + env: [{name: ANSIBLE_INJECT_FACT_VARS}] + ini: + - {key: inject_facts_as_vars, section: defaults} + type: boolean + version_added: "2.5" +PARAMIKO_HOST_KEY_AUTO_ADD: + # TODO: move to plugin + default: False + description: 'TODO: write it' + env: [{name: ANSIBLE_PARAMIKO_HOST_KEY_AUTO_ADD}] + ini: + - {key: host_key_auto_add, section: paramiko_connection} + type: boolean +PARAMIKO_LOOK_FOR_KEYS: + name: look for keys + default: True + description: 'TODO: write it' + env: [{name: ANSIBLE_PARAMIKO_LOOK_FOR_KEYS}] + ini: + - {key: look_for_keys, section: paramiko_connection} + type: boolean +PERSISTENT_CONTROL_PATH_DIR: + name: Persistence socket path + default: ~/.ansible/pc + description: Path to socket to be used by the connection persistence system. + env: [{name: ANSIBLE_PERSISTENT_CONTROL_PATH_DIR}] + ini: + - {key: control_path_dir, section: persistent_connection} + type: path +PERSISTENT_CONNECT_TIMEOUT: + name: Persistence timeout + default: 30 + description: This controls how long the persistent connection will remain idle before it is destroyed. + env: [{name: ANSIBLE_PERSISTENT_CONNECT_TIMEOUT}] + ini: + - {key: connect_timeout, section: persistent_connection} + type: integer +PERSISTENT_CONNECT_RETRY_TIMEOUT: + name: Persistence connection retry timeout + default: 15 + description: This controls the retry timeout for presistent connection to connect to the local domain socket. + env: [{name: ANSIBLE_PERSISTENT_CONNECT_RETRY_TIMEOUT}] + ini: + - {key: connect_retry_timeout, section: persistent_connection} + type: integer +PERSISTENT_COMMAND_TIMEOUT: + name: Persistence command timeout + default: 10 + description: This controls the amount of time to wait for response from remote device before timing out presistent connection. + env: [{name: ANSIBLE_PERSISTENT_COMMAND_TIMEOUT}] + ini: + - {key: command_timeout, section: persistent_connection} + type: int +PLAYBOOK_VARS_ROOT: + name: playbook vars files root + default: top + version_added: "2.4.1" + description: + - This sets which playbook dirs will be used as a root to process vars plugins, which includes finding host_vars/group_vars + - The ``top`` option follows the traditional behaviour of using the top playbook in the chain to find the root directory. + - The ``bottom`` option follows the 2.4.0 behaviour of using the current playbook to find the root directory. + - The ``all`` option examines from the first parent to the current playbook. + env: [{name: ANSIBLE_PLAYBOOK_VARS_ROOT}] + ini: + - {key: playbook_vars_root, section: defaults} + choices: [ top, bottom, all ] +PLUGIN_FILTERS_CFG: + name: Config file for limiting valid plugins + default: null + version_added: "2.5.0" + description: + - "A path to configuration for filtering which plugins installed on the system are allowed to be used." + - "See :ref:`plugin_filtering_config` for details of the filter file's format." + - " The default is /etc/ansible/plugin_filters.yml" + ini: + - key: plugin_filters_cfg + section: default + deprecated: + why: Specifying "plugin_filters_cfg" under the "default" section is deprecated + version: "2.12" + alternatives: the "defaults" section instead + - key: plugin_filters_cfg + section: defaults + type: path +RETRY_FILES_ENABLED: + name: Retry files + default: True + description: This controls whether a failed Ansible playbook should create a .retry file. + env: [{name: ANSIBLE_RETRY_FILES_ENABLED}] + ini: + - {key: retry_files_enabled, section: defaults} + type: bool +RETRY_FILES_SAVE_PATH: + name: Retry files path + default: ~ + description: This sets the path in which Ansible will save .retry files when a playbook fails and retry files are enabled. + env: [{name: ANSIBLE_RETRY_FILES_SAVE_PATH}] + ini: + - {key: retry_files_save_path, section: defaults} + type: path +SHOW_CUSTOM_STATS: + name: Display custom stats + default: False + description: 'This adds the custom stats set via the set_stats plugin to the default output' + env: [{name: ANSIBLE_SHOW_CUSTOM_STATS}] + ini: + - {key: show_custom_stats, section: defaults} + type: bool +STRING_TYPE_FILTERS: + name: Filters to preserve strings + default: [string, to_json, to_nice_json, to_yaml, ppretty, json] + description: + - "This list of filters avoids 'type conversion' when templating variables" + - Useful when you want to avoid conversion into lists or dictionaries for JSON strings, for example. + env: [{name: ANSIBLE_STRING_TYPE_FILTERS}] + ini: + - {key: dont_type_filters, section: jinja2} + type: list +SYSTEM_WARNINGS: + name: System warnings + default: True + description: + - Allows disabling of warnings related to potential issues on the system running ansible itself (not on the managed hosts) + - These may include warnings about 3rd party packages or other conditions that should be resolved if possible. + env: [{name: ANSIBLE_SYSTEM_WARNINGS}] + ini: + - {key: system_warnings, section: defaults} + type: boolean +TAGS_RUN: + name: Run Tags + default: [] + type: list + description: default list of tags to run in your plays, Skip Tags has precedence. + env: [{name: ANSIBLE_RUN_TAGS}] + ini: + - {key: run, section: tags} + version_added: "2.5" +TAGS_SKIP: + name: Skip Tags + default: [] + type: list + description: default list of tags to skip in your plays, has precedence over Run Tags + env: [{name: ANSIBLE_SKIP_TAGS}] + ini: + - {key: skip, section: tags} + version_added: "2.5" +USE_PERSISTENT_CONNECTIONS: + name: Persistence + default: False + description: Toggles the use of persistence for connections. + env: [{name: ANSIBLE_USE_PERSISTENT_CONNECTIONS}] + ini: + - {key: use_persistent_connections, section: defaults} + type: boolean +VARIABLE_PRECEDENCE: + name: Group variable precedence + default: ['all_inventory', 'groups_inventory', 'all_plugins_inventory', 'all_plugins_play', 'groups_plugins_inventory', 'groups_plugins_play'] + description: Allows to change the group variable precedence merge order. + env: [{name: ANSIBLE_PRECEDENCE}] + ini: + - {key: precedence, section: defaults} + type: list + version_added: "2.4" +YAML_FILENAME_EXTENSIONS: + name: Valid YAML extensions + default: [".yml", ".yaml", ".json"] + description: + - "Check all of these extensions when looking for 'variable' files which should be YAML or JSON or vaulted versions of these." + - 'This affects vars_files, include_vars, inventory and vars plugins among others.' + env: + - name: ANSIBLE_YAML_FILENAME_EXT + ini: + - section: defaults + key: yaml_valid_extensions + type: list +NETCONF_SSH_CONFIG: + description: This variable is used to enable bastion/jump host with netconf connection. If set to True the bastion/jump + host ssh settings should be present in ~/.ssh/config file, alternatively it can be set + to custom ssh configuration file path to read the bastion/jump host settings. + env: [{name: ANSIBLE_NETCONF_SSH_CONFIG}] + ini: + - {key: ssh_config, section: netconf_connection} + yaml: {key: netconf_connection.ssh_config} + default: null +... diff --git a/env_27/lib/python2.7/site-packages/ansible/config/data.py b/env_27/lib/python2.7/site-packages/ansible/config/data.py new file mode 100644 index 0000000..6a5bb39 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/config/data.py @@ -0,0 +1,43 @@ +# Copyright: (c) 2017, Ansible Project +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + + +class ConfigData(object): + + def __init__(self): + self._global_settings = {} + self._plugins = {} + + def get_setting(self, name, plugin=None): + + setting = None + if plugin is None: + setting = self._global_settings.get(name) + elif plugin.type in self._plugins and plugin.name in self._plugins[plugin.type]: + setting = self._plugins[plugin.type][plugin.name].get(name) + + return setting + + def get_settings(self, plugin=None): + + settings = [] + if plugin is None: + settings = [self._global_settings[k] for k in self._global_settings] + elif plugin.type in self._plugins and plugin.name in self._plugins[plugin.type]: + settings = [self._plugins[plugin.type][plugin.name][k] for k in self._plugins[plugin.type][plugin.name]] + + return settings + + def update_setting(self, setting, plugin=None): + + if plugin is None: + self._global_settings[setting.name] = setting + else: + if plugin.type not in self._plugins: + self._plugins[plugin.type] = {} + if plugin.name not in self._plugins[plugin.type]: + self._plugins[plugin.type][plugin.name] = {} + self._plugins[plugin.type][plugin.name][setting.name] = setting diff --git a/env_27/lib/python2.7/site-packages/ansible/config/manager.py b/env_27/lib/python2.7/site-packages/ansible/config/manager.py new file mode 100644 index 0000000..edabf77 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/config/manager.py @@ -0,0 +1,504 @@ +# Copyright: (c) 2017, Ansible Project +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import io +import os +import os.path +import sys +import stat +import tempfile +import traceback +from collections import namedtuple + +from yaml import load as yaml_load +try: + # use C version if possible for speedup + from yaml import CSafeLoader as SafeLoader +except ImportError: + from yaml import SafeLoader + +from ansible.config.data import ConfigData +from ansible.errors import AnsibleOptionsError, AnsibleError +from ansible.module_utils.six import PY3, string_types +from ansible.module_utils.six.moves import configparser +from ansible.module_utils._text import to_text, to_bytes, to_native +from ansible.module_utils.parsing.convert_bool import boolean +from ansible.parsing.quoting import unquote +from ansible.utils import py3compat +from ansible.utils.path import unfrackpath +from ansible.utils.path import makedirs_safe + + +Plugin = namedtuple('Plugin', 'name type') +Setting = namedtuple('Setting', 'name value origin type') + +INTERNAL_DEFS = {'lookup': ('_terms',)} + + +# FIXME: see if we can unify in module_utils with similar function used by argspec +def ensure_type(value, value_type, origin=None): + ''' return a configuration variable with casting + :arg value: The value to ensure correct typing of + :kwarg value_type: The type of the value. This can be any of the following strings: + :boolean: sets the value to a True or False value + :integer: Sets the value to an integer or raises a ValueType error + :float: Sets the value to a float or raises a ValueType error + :list: Treats the value as a comma separated list. Split the value + and return it as a python list. + :none: Sets the value to None + :path: Expands any environment variables and tilde's in the value. + :tmp_path: Create a unique temporary directory inside of the directory + specified by value and return its path. + :pathlist: Treat the value as a typical PATH string. (On POSIX, this + means colon separated strings.) Split the value and then expand + each part for environment variables and tildes. + ''' + + basedir = None + if origin and os.path.isabs(origin) and os.path.exists(origin): + basedir = origin + + if value_type: + value_type = value_type.lower() + + if value_type in ('boolean', 'bool'): + value = boolean(value, strict=False) + + elif value is not None: + if value_type in ('integer', 'int'): + value = int(value) + + elif value_type == 'float': + value = float(value) + + elif value_type == 'list': + if isinstance(value, string_types): + value = [x.strip() for x in value.split(',')] + + elif value_type == 'none': + if value == "None": + value = None + + elif value_type == 'path': + value = resolve_path(value, basedir=basedir) + + elif value_type in ('tmp', 'temppath', 'tmppath'): + value = resolve_path(value, basedir=basedir) + if not os.path.exists(value): + makedirs_safe(value, 0o700) + prefix = 'ansible-local-%s' % os.getpid() + value = tempfile.mkdtemp(prefix=prefix, dir=value) + + elif value_type == 'pathspec': + if isinstance(value, string_types): + value = value.split(os.pathsep) + value = [resolve_path(x, basedir=basedir) for x in value] + + elif value_type == 'pathlist': + if isinstance(value, string_types): + value = value.split(',') + value = [resolve_path(x, basedir=basedir) for x in value] + + elif value_type in ('str', 'string'): + value = unquote(to_text(value, errors='surrogate_or_strict')) + + # defaults to string type + elif isinstance(value, string_types): + value = unquote(value) + + return to_text(value, errors='surrogate_or_strict', nonstring='passthru') + + +# FIXME: see if this can live in utils/path +def resolve_path(path, basedir=None): + ''' resolve relative or 'varaible' paths ''' + if '{{CWD}}' in path: # allow users to force CWD using 'magic' {{CWD}} + path = path.replace('{{CWD}}', os.getcwd()) + + return unfrackpath(path, follow=False, basedir=basedir) + + +# FIXME: generic file type? +def get_config_type(cfile): + + ftype = None + if cfile is not None: + ext = os.path.splitext(cfile)[-1] + if ext in ('.ini', '.cfg'): + ftype = 'ini' + elif ext in ('.yaml', '.yml'): + ftype = 'yaml' + else: + raise AnsibleOptionsError("Unsupported configuration file extension for %s: %s" % (cfile, to_native(ext))) + + return ftype + + +# FIXME: can move to module_utils for use for ini plugins also? +def get_ini_config_value(p, entry): + ''' returns the value of last ini entry found ''' + value = None + if p is not None: + try: + value = p.get(entry.get('section', 'defaults'), entry.get('key', ''), raw=True) + except Exception: # FIXME: actually report issues here + pass + return value + + +def find_ini_config_file(warnings=None): + ''' Load INI Config File order(first found is used): ENV, CWD, HOME, /etc/ansible ''' + # FIXME: eventually deprecate ini configs + + if warnings is None: + # Note: In this case, warnings does nothing + warnings = set() + + # A value that can never be a valid path so that we can tell if ANSIBLE_CONFIG was set later + # We can't use None because we could set path to None. + SENTINEL = object + + potential_paths = [] + + # Environment setting + path_from_env = os.getenv("ANSIBLE_CONFIG", SENTINEL) + if path_from_env is not SENTINEL: + path_from_env = unfrackpath(path_from_env, follow=False) + if os.path.isdir(path_from_env): + path_from_env = os.path.join(path_from_env, "ansible.cfg") + potential_paths.append(path_from_env) + + # Current working directory + warn_cmd_public = False + try: + cwd = os.getcwd() + perms = os.stat(cwd) + cwd_cfg = os.path.join(cwd, "ansible.cfg") + if perms.st_mode & stat.S_IWOTH: + # Working directory is world writable so we'll skip it. + # Still have to look for a file here, though, so that we know if we have to warn + if os.path.exists(cwd_cfg): + warn_cmd_public = True + else: + potential_paths.append(cwd_cfg) + except OSError: + # If we can't access cwd, we'll simply skip it as a possible config source + pass + + # Per user location + potential_paths.append(unfrackpath("~/.ansible.cfg", follow=False)) + + # System location + potential_paths.append("/etc/ansible/ansible.cfg") + + for path in potential_paths: + if os.path.exists(path): + break + else: + path = None + + # Emit a warning if all the following are true: + # * We did not use a config from ANSIBLE_CONFIG + # * There's an ansible.cfg in the current working directory that we skipped + if path_from_env != path and warn_cmd_public: + warnings.add(u"Ansible is being run in a world writable directory (%s)," + u" ignoring it as an ansible.cfg source." + u" For more information see" + u" https://docs.ansible.com/ansible/devel/reference_appendices/config.html#cfg-in-world-writable-dir" + % to_text(cwd)) + + return path + + +class ConfigManager(object): + + DEPRECATED = [] + WARNINGS = set() + + def __init__(self, conf_file=None, defs_file=None): + + self._base_defs = {} + self._plugins = {} + self._parsers = {} + + self._config_file = conf_file + self.data = ConfigData() + + self._base_defs = self._read_config_yaml_file(defs_file or ('%s/base.yml' % os.path.dirname(__file__))) + + if self._config_file is None: + # set config using ini + self._config_file = find_ini_config_file(self.WARNINGS) + + # consume configuration + if self._config_file: + if os.path.exists(self._config_file): + # initialize parser and read config + self._parse_config_file() + + # update constants + self.update_config_data() + try: + self.update_module_defaults_groups() + except Exception as e: + # Since this is a 2.7 preview feature, we want to have it fail as gracefully as possible when there are issues. + sys.stderr.write('Could not load module_defaults_groups: %s: %s\n\n' % (type(e).__name__, e)) + self.module_defaults_groups = {} + + def _read_config_yaml_file(self, yml_file): + # TODO: handle relative paths as relative to the directory containing the current playbook instead of CWD + # Currently this is only used with absolute paths to the `ansible/config` directory + yml_file = to_bytes(yml_file) + if os.path.exists(yml_file): + with open(yml_file, 'rb') as config_def: + return yaml_load(config_def, Loader=SafeLoader) or {} + raise AnsibleError( + "Missing base YAML definition file (bad install?): %s" % to_native(yml_file)) + + def _parse_config_file(self, cfile=None): + ''' return flat configuration settings from file(s) ''' + # TODO: take list of files with merge/nomerge + + if cfile is None: + cfile = self._config_file + + ftype = get_config_type(cfile) + if cfile is not None: + if ftype == 'ini': + self._parsers[cfile] = configparser.ConfigParser() + with open(cfile, 'rb') as f: + try: + cfg_text = to_text(f.read(), errors='surrogate_or_strict') + except UnicodeError as e: + raise AnsibleOptionsError("Error reading config file(%s) because the config file was not utf8 encoded: %s" % (cfile, to_native(e))) + try: + if PY3: + self._parsers[cfile].read_string(cfg_text) + else: + cfg_file = io.StringIO(cfg_text) + self._parsers[cfile].readfp(cfg_file) + except configparser.Error as e: + raise AnsibleOptionsError("Error reading config file (%s): %s" % (cfile, to_native(e))) + # FIXME: this should eventually handle yaml config files + # elif ftype == 'yaml': + # with open(cfile, 'rb') as config_stream: + # self._parsers[cfile] = yaml.safe_load(config_stream) + else: + raise AnsibleOptionsError("Unsupported configuration file type: %s" % to_native(ftype)) + + def _find_yaml_config_files(self): + ''' Load YAML Config Files in order, check merge flags, keep origin of settings''' + pass + + def get_plugin_options(self, plugin_type, name, keys=None, variables=None, direct=None): + + options = {} + defs = self.get_configuration_definitions(plugin_type, name) + for option in defs: + options[option] = self.get_config_value(option, plugin_type=plugin_type, plugin_name=name, keys=keys, variables=variables, direct=direct) + + return options + + def get_plugin_vars(self, plugin_type, name): + + pvars = [] + for pdef in self.get_configuration_definitions(plugin_type, name).values(): + if 'vars' in pdef and pdef['vars']: + for var_entry in pdef['vars']: + pvars.append(var_entry['name']) + return pvars + + def get_configuration_definitions(self, plugin_type=None, name=None): + ''' just list the possible settings, either base or for specific plugins or plugin ''' + + ret = {} + if plugin_type is None: + ret = self._base_defs + elif name is None: + ret = self._plugins.get(plugin_type, {}) + else: + ret = self._plugins.get(plugin_type, {}).get(name, {}) + + return ret + + def _loop_entries(self, container, entry_list): + ''' repeat code for value entry assignment ''' + + value = None + origin = None + for entry in entry_list: + name = entry.get('name') + temp_value = container.get(name, None) + if temp_value is not None: # only set if env var is defined + value = temp_value + origin = name + + # deal with deprecation of setting source, if used + if 'deprecated' in entry: + self.DEPRECATED.append((entry['name'], entry['deprecated'])) + + return value, origin + + def get_config_value(self, config, cfile=None, plugin_type=None, plugin_name=None, keys=None, variables=None, direct=None): + ''' wrapper ''' + + try: + value, _drop = self.get_config_value_and_origin(config, cfile=cfile, plugin_type=plugin_type, plugin_name=plugin_name, + keys=keys, variables=variables, direct=direct) + except AnsibleError: + raise + except Exception as e: + raise AnsibleError("Unhandled exception when retrieving %s:\n%s" % (config, traceback.format_exc())) + return value + + def get_config_value_and_origin(self, config, cfile=None, plugin_type=None, plugin_name=None, keys=None, variables=None, direct=None): + ''' Given a config key figure out the actual value and report on the origin of the settings ''' + if cfile is None: + # use default config + cfile = self._config_file + + # Note: sources that are lists listed in low to high precedence (last one wins) + value = None + origin = None + + defs = self.get_configuration_definitions(plugin_type, plugin_name) + if config in defs: + + # direct setting via plugin arguments, can set to None so we bypass rest of processing/defaults + if direct and config in direct: + value = direct[config] + origin = 'Direct' + + else: + # Use 'variable overrides' if present, highest precedence, but only present when querying running play + if variables and defs[config].get('vars'): + value, origin = self._loop_entries(variables, defs[config]['vars']) + origin = 'var: %s' % origin + + # use playbook keywords if you have em + if value is None and keys and defs[config].get('keywords'): + value, origin = self._loop_entries(keys, defs[config]['keywords']) + origin = 'keyword: %s' % origin + + # env vars are next precedence + if value is None and defs[config].get('env'): + value, origin = self._loop_entries(py3compat.environ, defs[config]['env']) + origin = 'env: %s' % origin + + # try config file entries next, if we have one + if self._parsers.get(cfile, None) is None: + self._parse_config_file(cfile) + + if value is None and cfile is not None: + ftype = get_config_type(cfile) + if ftype and defs[config].get(ftype): + if ftype == 'ini': + # load from ini config + try: # FIXME: generalize _loop_entries to allow for files also, most of this code is dupe + for ini_entry in defs[config]['ini']: + temp_value = get_ini_config_value(self._parsers[cfile], ini_entry) + if temp_value is not None: + value = temp_value + origin = cfile + if 'deprecated' in ini_entry: + self.DEPRECATED.append(('[%s]%s' % (ini_entry['section'], ini_entry['key']), ini_entry['deprecated'])) + except Exception as e: + sys.stderr.write("Error while loading ini config %s: %s" % (cfile, to_native(e))) + elif ftype == 'yaml': + # FIXME: implement, also , break down key from defs (. notation???) + origin = cfile + + # set default if we got here w/o a value + if value is None: + if defs[config].get('required', False): + entry = '' + if plugin_type: + entry += 'plugin_type: %s ' % plugin_type + if plugin_name: + entry += 'plugin: %s ' % plugin_name + entry += 'setting: %s ' % config + if not plugin_type or config not in INTERNAL_DEFS.get(plugin_type, {}): + raise AnsibleError("No setting was provided for required configuration %s" % (entry)) + else: + value = defs[config].get('default') + origin = 'default' + # skip typing as this is a temlated default that will be resolved later in constants, which has needed vars + if plugin_type is None and isinstance(value, string_types) and (value.startswith('{{') and value.endswith('}}')): + return value, origin + + # ensure correct type, can raise exceptoins on mismatched types + try: + value = ensure_type(value, defs[config].get('type'), origin=origin) + except ValueError as e: + if origin.startswith('env:') and value == '': + # this is empty env var for non string so we can set to default + origin = 'default' + value = ensure_type(defs[config].get('default'), defs[config].get('type'), origin=origin) + else: + raise AnsibleOptionsError('Invalid type for configuration option %s: %s' % (to_native(config), to_native(e))) + + # deal with deprecation of the setting + if 'deprecated' in defs[config] and origin != 'default': + self.DEPRECATED.append((config, defs[config].get('deprecated'))) + else: + raise AnsibleError('Requested option %s was not defined in configuration' % to_native(config)) + + return value, origin + + def initialize_plugin_configuration_definitions(self, plugin_type, name, defs): + + if plugin_type not in self._plugins: + self._plugins[plugin_type] = {} + + self._plugins[plugin_type][name] = defs + + def update_module_defaults_groups(self): + defaults_config = self._read_config_yaml_file( + '%s/module_defaults.yml' % os.path.join(os.path.dirname(__file__)) + ) + if defaults_config.get('version') not in ('1', '1.0', 1, 1.0): + raise AnsibleError('module_defaults.yml has an invalid version "%s" for configuration. Could be a bad install.' % defaults_config.get('version')) + self.module_defaults_groups = defaults_config.get('groupings', {}) + + def update_config_data(self, defs=None, configfile=None): + ''' really: update constants ''' + + if defs is None: + defs = self._base_defs + + if configfile is None: + configfile = self._config_file + + if not isinstance(defs, dict): + raise AnsibleOptionsError("Invalid configuration definition type: %s for %s" % (type(defs), defs)) + + # update the constant for config file + self.data.update_setting(Setting('CONFIG_FILE', configfile, '', 'string')) + + origin = None + # env and config defs can have several entries, ordered in list from lowest to highest precedence + for config in defs: + if not isinstance(defs[config], dict): + raise AnsibleOptionsError("Invalid configuration definition '%s': type is %s" % (to_native(config), type(defs[config]))) + + # get value and origin + try: + value, origin = self.get_config_value_and_origin(config, configfile) + except Exception as e: + # Printing the problem here because, in the current code: + # (1) we can't reach the error handler for AnsibleError before we + # hit a different error due to lack of working config. + # (2) We don't have access to display yet because display depends on config + # being properly loaded. + # + # If we start getting double errors printed from this section of code, then the + # above problem #1 has been fixed. Revamp this to be more like the try: except + # in get_config_value() at that time. + sys.stderr.write("Unhandled error:\n %s\n\n" % traceback.format_exc()) + raise AnsibleError("Invalid settings supplied for %s: %s\n%s" % (config, to_native(e), traceback.format_exc())) + + # set the constant + self.data.update_setting(Setting(config, value, origin, defs[config].get('type', 'string'))) diff --git a/env_27/lib/python2.7/site-packages/ansible/config/module_defaults.yml b/env_27/lib/python2.7/site-packages/ansible/config/module_defaults.yml new file mode 100644 index 0000000..de58c47 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/config/module_defaults.yml @@ -0,0 +1,594 @@ +version: '1.0' +groupings: + aws_acm_facts: + - aws + aws_api_gateway: + - aws + aws_application_scaling_policy: + - aws + aws_az_facts: + - aws + aws_batch_compute_environment: + - aws + aws_batch_job_definition: + - aws + aws_batch_job_queue: + - aws + aws_caller_facts: + - aws + aws_config_aggregation_authorization: + - aws + aws_config_aggregator: + - aws + aws_config_delivery_channel: + - aws + aws_config_recorder: + - aws + aws_config_rule: + - aws + aws_direct_connect_connection: + - aws + aws_direct_connect_gateway: + - aws + aws_direct_connect_link_aggregation_group: + - aws + aws_direct_connect_virtual_interface: + - aws + aws_eks_cluster: + - aws + aws_elasticbeanstalk_app: + - aws + aws_glue_connection: + - aws + aws_glue_job: + - aws + aws_inspector_target: + - aws + aws_kms: + - aws + aws_kms_facts: + - aws + aws_region_facts: + - aws + aws_s3: + - aws + aws_s3_bucket_facts: + - aws + aws_s3_cors: + - aws + aws_ses_identity: + - aws + aws_ses_identity_policy: + - aws + aws_sgw_facts: + - aws + aws_ssm_parameter_store: + - aws + aws_waf_condition: + - aws + aws_waf_facts: + - aws + aws_waf_rule: + - aws + aws_waf_web_acl: + - aws + cloudformation: + - aws + cloudformation_facts: + - aws + cloudfront_distribution: + - aws + cloudfront_facts: + - aws + cloudfront_invalidation: + - aws + cloudfront_origin_access_identity: + - aws + cloudtrail: + - aws + cloudwatchevent_rule: + - aws + cloudwatchlogs_log_group: + - aws + cloudwatchlogs_log_group_facts: + - aws + data_pipeline: + - aws + dynamodb_table: + - aws + dynamodb_ttl: + - aws + ec2: + - aws + ec2_ami: + - aws + ec2_ami_copy: + - aws + ec2_ami_facts: + - aws + ec2_asg: + - aws + ec2_asg_facts: + - aws + ec2_asg_lifecycle_hook: + - aws + ec2_customer_gateway: + - aws + ec2_customer_gateway_facts: + - aws + ec2_eip: + - aws + ec2_eip_facts: + - aws + ec2_elb: + - aws + ec2_elb_facts: + - aws + ec2_elb_lb: + - aws + ec2_eni: + - aws + ec2_eni_facts: + - aws + ec2_group: + - aws + ec2_group_facts: + - aws + ec2_instance: + - aws + ec2_instance_facts: + - aws + ec2_key: + - aws + ec2_lc: + - aws + ec2_lc_facts: + - aws + ec2_lc_find: + - aws + ec2_metric_alarm: + - aws + ec2_placement_group: + - aws + ec2_placement_group_facts: + - aws + ec2_scaling_policy: + - aws + ec2_snapshot: + - aws + ec2_snapshot_copy: + - aws + ec2_snapshot_facts: + - aws + ec2_tag: + - aws + ec2_vol: + - aws + ec2_vol_facts: + - aws + ec2_vpc_dhcp_option: + - aws + ec2_vpc_dhcp_option_facts: + - aws + ec2_vpc_egress_igw: + - aws + ec2_vpc_endpoint: + - aws + ec2_vpc_endpoint_facts: + - aws + ec2_vpc_igw: + - aws + ec2_vpc_igw_facts: + - aws + ec2_vpc_nacl: + - aws + ec2_vpc_nacl_facts: + - aws + ec2_vpc_nat_gateway: + - aws + ec2_vpc_nat_gateway_facts: + - aws + ec2_vpc_net: + - aws + ec2_vpc_net_facts: + - aws + ec2_vpc_peer: + - aws + ec2_vpc_peering_facts: + - aws + ec2_vpc_route_table: + - aws + ec2_vpc_route_table_facts: + - aws + ec2_vpc_subnet: + - aws + ec2_vpc_subnet_facts: + - aws + ec2_vpc_vgw: + - aws + ec2_vpc_vgw_facts: + - aws + ec2_vpc_vpn: + - aws + ec2_vpc_vpn_facts: + - aws + ec2_win_password: + - aws + ecs_attribute: + - aws + ecs_cluster: + - aws + ecs_ecr: + - aws + ecs_service: + - aws + ecs_service_facts: + - aws + ecs_task: + - aws + ecs_taskdefinition: + - aws + ecs_taskdefinition_facts: + - aws + efs: + - aws + efs_facts: + - aws + elasticache: + - aws + elasticache_facts: + - aws + elasticache_parameter_group: + - aws + elasticache_snapshot: + - aws + elasticache_subnet_group: + - aws + elb_application_lb: + - aws + elb_application_lb_facts: + - aws + elb_classic_lb: + - aws + elb_classic_lb_facts: + - aws + elb_instance: + - aws + elb_network_lb: + - aws + elb_target: + - aws + elb_target_group: + - aws + elb_target_group_facts: + - aws + execute_lambda: + - aws + iam: + - aws + iam_cert: + - aws + iam_group: + - aws + iam_managed_policy: + - aws + iam_mfa_device_facts: + - aws + iam_policy: + - aws + iam_role: + - aws + iam_role_facts: + - aws + iam_server_certificate_facts: + - aws + iam_user: + - aws + kinesis_stream: + - aws + lambda: + - aws + lambda_alias: + - aws + lambda_event: + - aws + lambda_facts: + - aws + lambda_policy: + - aws + lightsail: + - aws + rds: + - aws + rds_instance: + - aws + rds_instance_facts: + - aws + rds_param_group: + - aws + rds_snapshot_facts: + - aws + rds_subnet_group: + - aws + redshift: + - aws + redshift_facts: + - aws + redshift_subnet_group: + - aws + route53: + - aws + route53_facts: + - aws + route53_health_check: + - aws + route53_zone: + - aws + s3_bucket: + - aws + s3_lifecycle: + - aws + s3_logging: + - aws + s3_sync: + - aws + s3_website: + - aws + sns: + - aws + sns_topic: + - aws + sqs_queue: + - aws + sts_assume_role: + - aws + sts_session_token: + - aws + gcp_compute_address: + - gcp + gcp_compute_address_facts: + - gcp + gcp_compute_backend_bucket: + - gcp + gcp_compute_backend_bucket_facts: + - gcp + gcp_compute_backend_service: + - gcp + gcp_compute_backend_service_facts: + - gcp + gcp_compute_disk: + - gcp + gcp_compute_disk_facts: + - gcp + gcp_compute_firewall: + - gcp + gcp_compute_firewall_facts: + - gcp + gcp_compute_forwarding_rule: + - gcp + gcp_compute_forwarding_rule_facts: + - gcp + gcp_compute_global_address: + - gcp + gcp_compute_global_address_facts: + - gcp + gcp_compute_global_forwarding_rule: + - gcp + gcp_compute_global_forwarding_rule_facts: + - gcp + gcp_compute_health_check: + - gcp + gcp_compute_health_check_facts: + - gcp + gcp_compute_http_health_check: + - gcp + gcp_compute_http_health_check_facts: + - gcp + gcp_compute_https_health_check: + - gcp + gcp_compute_https_health_check_facts: + - gcp + gcp_compute_image: + - gcp + gcp_compute_image_facts: + - gcp + gcp_compute_instance: + - gcp + gcp_compute_instance_facts: + - gcp + gcp_compute_instance_group: + - gcp + gcp_compute_instance_group_facts: + - gcp + gcp_compute_instance_group_manager: + - gcp + gcp_compute_instance_group_manager_facts: + - gcp + gcp_compute_instance_template: + - gcp + gcp_compute_instance_template_facts: + - gcp + gcp_compute_network: + - gcp + gcp_compute_network_facts: + - gcp + gcp_compute_route: + - gcp + gcp_compute_route_facts: + - gcp + gcp_compute_router_facts: + - gcp + gcp_compute_ssl_certificate: + - gcp + gcp_compute_ssl_certificate_facts: + - gcp + gcp_compute_ssl_policy: + - gcp + gcp_compute_ssl_policy_facts: + - gcp + gcp_compute_subnetwork: + - gcp + gcp_compute_subnetwork_facts: + - gcp + gcp_compute_target_http_proxy: + - gcp + gcp_compute_target_http_proxy_facts: + - gcp + gcp_compute_target_https_proxy: + - gcp + gcp_compute_target_https_proxy_facts: + - gcp + gcp_compute_target_pool: + - gcp + gcp_compute_target_pool_facts: + - gcp + gcp_compute_target_ssl_proxy: + - gcp + gcp_compute_target_ssl_proxy_facts: + - gcp + gcp_compute_target_tcp_proxy: + - gcp + gcp_compute_target_tcp_proxy_facts: + - gcp + gcp_compute_target_vpn_gateway: + - gcp + gcp_compute_target_vpn_gateway_facts: + - gcp + gcp_compute_url_map: + - gcp + gcp_compute_url_map_facts: + - gcp + gcp_compute_vpn_tunnel: + - gcp + gcp_compute_vpn_tunnel_facts: + - gcp + gcp_container_cluster: + - gcp + gcp_container_node_pool: + - gcp + gcp_dns_managed_zone: + - gcp + gcp_dns_resource_record_set: + - gcp + gcp_pubsub_subscription: + - gcp + gcp_pubsub_topic: + - gcp + gcp_storage_bucket: + - gcp + gcp_storage_bucket_access_control: + - gcp + azure_rm_acs: + - azure + azure_rm_aks: + - azure + azure_rm_aks_facts: + - azure + azure_rm_appserviceplan: + - azure + azure_rm_appserviceplan_facts: + - azure + azure_rm_availabilityset: + - azure + azure_rm_availabilityset_facts: + - azure + azure_rm_containerinstance: + - azure + azure_rm_containerregistry: + - azure + azure_rm_deployment: + - azure + azure_rm_dnsrecordset: + - azure + azure_rm_dnsrecordset_facts: + - azure + azure_rm_dnszone: + - azure + azure_rm_dnszone_facts: + - azure + azure_rm_functionapp: + - azure + azure_rm_functionapp_facts: + - azure + azure_rm_image: + - azure + azure_rm_keyvault: + - azure + azure_rm_keyvaultkey: + - azure + azure_rm_keyvaultsecret: + - azure + azure_rm_loadbalancer: + - azure + azure_rm_loadbalancer_facts: + - azure + azure_rm_managed_disk: + - azure + azure_rm_managed_disk_facts: + - azure + azure_rm_mysqldatabase: + - azure + azure_rm_mysqldatabase_facts: + - azure + azure_rm_mysqlserver: + - azure + azure_rm_mysqlserver_facts: + - azure + azure_rm_networkinterface: + - azure + azure_rm_networkinterface_facts: + - azure + azure_rm_postgresqldatabase: + - azure + azure_rm_postgresqldatabase_facts: + - azure + azure_rm_postgresqlserver: + - azure + azure_rm_publicipaddress: + - azure + azure_rm_publicipaddress_facts: + - azure + azure_rm_resource: + - azure + azure_rm_resource_facts: + - azure + azure_rm_resourcegroup: + - azure + azure_rm_resourcegroup_facts: + - azure + azure_rm_securitygroup: + - azure + azure_rm_securitygroup_facts: + - azure + azure_rm_sqldatabase: + - azure + azure_rm_sqlserver: + - azure + azure_rm_sqlserver_facts: + - azure + azure_rm_storageaccount: + - azure + azure_rm_storageaccount_facts: + - azure + azure_rm_storageblob: + - azure + azure_rm_subnet: + - azure + azure_rm_virtualmachine: + - azure + azure_rm_virtualmachine_extension: + - azure + azure_rm_virtualmachine_facts: + - azure + azure_rm_virtualmachineimage_facts: + - azure + azure_rm_virtualmachine_scaleset: + - azure + azure_rm_virtualmachine_scaleset_facts: + - azure + azure_rm_virtualnetwork: + - azure + azure_rm_virtualnetwork_facts: + - azure + azure_rm_webapp: + - azure diff --git a/env_27/lib/python2.7/site-packages/ansible/constants.py b/env_27/lib/python2.7/site-packages/ansible/constants.py new file mode 100644 index 0000000..225361d --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/constants.py @@ -0,0 +1,208 @@ +# Copyright: (c) 2012-2014, Michael DeHaan +# Copyright: (c) 2017, Ansible Project +# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import os + +from ast import literal_eval +from jinja2 import Template +from string import ascii_letters, digits + +from ansible.module_utils._text import to_text +from ansible.module_utils.parsing.convert_bool import boolean, BOOLEANS_TRUE +from ansible.module_utils.six import string_types +from ansible.config.manager import ConfigManager, ensure_type, get_ini_config_value + + +def _warning(msg): + ''' display is not guaranteed here, nor it being the full class, but try anyways, fallback to sys.stderr.write ''' + try: + from __main__ import display + display.warning(msg) + except Exception: + import sys + sys.stderr.write(' [WARNING] %s\n' % (msg)) + + +def _deprecated(msg, version='2.8'): + ''' display is not guaranteed here, nor it being the full class, but try anyways, fallback to sys.stderr.write ''' + try: + from __main__ import display + display.deprecated(msg, version=version) + except Exception: + import sys + sys.stderr.write(' [DEPRECATED] %s, to be removed in %s\n' % (msg, version)) + + +def mk_boolean(value): + ''' moved to module_utils''' + _deprecated('ansible.constants.mk_boolean() is deprecated. Use ansible.module_utils.parsing.convert_bool.boolean() instead') + return boolean(value, strict=False) + + +def get_config(parser, section, key, env_var, default_value, value_type=None, expand_relative_paths=False): + ''' kept for backwarsd compatibility, but deprecated ''' + _deprecated('ansible.constants.get_config() is deprecated. There is new config API, see porting docs.') + + value = None + # small reconstruction of the old code env/ini/default + value = os.environ.get(env_var, None) + if value is None: + try: + value = get_ini_config_value(parser, {'key': key, 'section': section}) + except Exception: + pass + if value is None: + value = default_value + + value = ensure_type(value, value_type) + + return value + + +def set_constant(name, value, export=vars()): + ''' sets constants and returns resolved options dict ''' + export[name] = value + + +# CONSTANTS ### yes, actual ones +BECOME_METHODS = ['sudo', 'su', 'pbrun', 'pfexec', 'doas', 'dzdo', 'ksu', 'runas', 'pmrun', 'enable', 'machinectl'] +BECOME_ERROR_STRINGS = { + 'sudo': 'Sorry, try again.', + 'su': 'Authentication failure', + 'pbrun': '', + 'pfexec': '', + 'doas': 'Permission denied', + 'dzdo': '', + 'ksu': 'Password incorrect', + 'pmrun': 'You are not permitted to run this command', + 'enable': '', + 'machinectl': '', +} # FIXME: deal with i18n +BECOME_MISSING_STRINGS = { + 'sudo': 'sorry, a password is required to run sudo', + 'su': '', + 'pbrun': '', + 'pfexec': '', + 'doas': 'Authorization required', + 'dzdo': '', + 'ksu': 'No password given', + 'pmrun': '', + 'enable': '', + 'machinectl': '', +} # FIXME: deal with i18n +BLACKLIST_EXTS = ('.pyc', '.pyo', '.swp', '.bak', '~', '.rpm', '.md', '.txt', '.rst') +BOOL_TRUE = BOOLEANS_TRUE +CONTROLER_LANG = os.getenv('LANG', 'en_US.UTF-8') +DEFAULT_BECOME_PASS = None +DEFAULT_PASSWORD_CHARS = to_text(ascii_letters + digits + ".,:-_", errors='strict') # characters included in auto-generated passwords +DEFAULT_SUDO_PASS = None +DEFAULT_REMOTE_PASS = None +DEFAULT_SUBSET = None +DEFAULT_SU_PASS = None +# FIXME: expand to other plugins, but never doc fragments +CONFIGURABLE_PLUGINS = ('cache', 'callback', 'connection', 'inventory', 'lookup', 'shell', 'cliconf', 'httpapi') +# NOTE: always update the docs/docsite/Makefile to match +DOCUMENTABLE_PLUGINS = ('cache', 'callback', 'connection', 'inventory', 'lookup', 'shell', 'module', 'strategy', 'vars') +IGNORE_FILES = ("COPYING", "CONTRIBUTING", "LICENSE", "README", "VERSION", "GUIDELINES") # ignore during module search +INTERNAL_RESULT_KEYS = ('add_host', 'add_group') +LOCALHOST = ('127.0.0.1', 'localhost', '::1') +MODULE_REQUIRE_ARGS = ('command', 'win_command', 'shell', 'win_shell', 'raw', 'script') +MODULE_NO_JSON = ('command', 'win_command', 'shell', 'win_shell', 'raw') +RESTRICTED_RESULT_KEYS = ('ansible_rsync_path', 'ansible_playbook_python') +TREE_DIR = None +VAULT_VERSION_MIN = 1.0 +VAULT_VERSION_MAX = 1.0 + +# FIXME: remove once play_context mangling is removed +# the magic variable mapping dictionary below is used to translate +# host/inventory variables to fields in the PlayContext +# object. The dictionary values are tuples, to account for aliases +# in variable names. + +COMMON_CONNECTION_VARS = frozenset(('ansible_connection', 'ansible_host', 'ansible_user', 'ansible_shell_executable', + 'ansible_port', 'ansible_pipelining', 'ansible_password', 'ansible_timeout', + 'ansible_shell_type', 'ansible_module_compression', 'ansible_private_key_file')) + +MAGIC_VARIABLE_MAPPING = dict( + + # base + connection=('ansible_connection', ), + module_compression=('ansible_module_compression', ), + shell=('ansible_shell_type', ), + executable=('ansible_shell_executable', ), + + # connection common + remote_addr=('ansible_ssh_host', 'ansible_host'), + remote_user=('ansible_ssh_user', 'ansible_user'), + password=('ansible_ssh_pass', 'ansible_password'), + port=('ansible_ssh_port', 'ansible_port'), + pipelining=('ansible_ssh_pipelining', 'ansible_pipelining'), + timeout=('ansible_ssh_timeout', 'ansible_timeout'), + private_key_file=('ansible_ssh_private_key_file', 'ansible_private_key_file'), + + # networking modules + network_os=('ansible_network_os', ), + connection_user=('ansible_connection_user',), + + # ssh TODO: remove + ssh_executable=('ansible_ssh_executable', ), + ssh_common_args=('ansible_ssh_common_args', ), + sftp_extra_args=('ansible_sftp_extra_args', ), + scp_extra_args=('ansible_scp_extra_args', ), + ssh_extra_args=('ansible_ssh_extra_args', ), + ssh_transfer_method=('ansible_ssh_transfer_method', ), + + # docker TODO: remove + docker_extra_args=('ansible_docker_extra_args', ), + + # become + become=('ansible_become', ), + become_method=('ansible_become_method', ), + become_user=('ansible_become_user', ), + become_pass=('ansible_become_password', 'ansible_become_pass'), + become_exe=('ansible_become_exe', ), + become_flags=('ansible_become_flags', ), + + # deprecated + sudo=('ansible_sudo', ), + sudo_user=('ansible_sudo_user', ), + sudo_pass=('ansible_sudo_password', 'ansible_sudo_pass'), + sudo_exe=('ansible_sudo_exe', ), + sudo_flags=('ansible_sudo_flags', ), + su=('ansible_su', ), + su_user=('ansible_su_user', ), + su_pass=('ansible_su_password', 'ansible_su_pass'), + su_exe=('ansible_su_exe', ), + su_flags=('ansible_su_flags', ), +) + +# POPULATE SETTINGS FROM CONFIG ### +config = ConfigManager() + +# Generate constants from config +for setting in config.data.get_settings(): + + value = setting.value + if setting.origin == 'default' and \ + isinstance(setting.value, string_types) and \ + (setting.value.startswith('{{') and setting.value.endswith('}}')): + try: + t = Template(setting.value) + value = t.render(vars()) + try: + value = literal_eval(value) + except ValueError: + pass # not a python data structure + except Exception: + pass # not templatable + + value = ensure_type(value, setting.type) + + set_constant(setting.name, value) + +for warn in config.WARNINGS: + _warning(warn) diff --git a/env_27/lib/python2.7/site-packages/ansible/errors/__init__.py b/env_27/lib/python2.7/site-packages/ansible/errors/__init__.py new file mode 100644 index 0000000..6bbc0e6 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/errors/__init__.py @@ -0,0 +1,293 @@ +# (c) 2012-2014, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +from collections import Sequence + +from ansible.errors.yaml_strings import ( + YAML_COMMON_DICT_ERROR, + YAML_COMMON_LEADING_TAB_ERROR, + YAML_COMMON_PARTIALLY_QUOTED_LINE_ERROR, + YAML_COMMON_UNBALANCED_QUOTES_ERROR, + YAML_COMMON_UNQUOTED_COLON_ERROR, + YAML_COMMON_UNQUOTED_VARIABLE_ERROR, + YAML_POSITION_DETAILS, +) +from ansible.module_utils._text import to_native, to_text + + +class AnsibleError(Exception): + ''' + This is the base class for all errors raised from Ansible code, + and can be instantiated with two optional parameters beyond the + error message to control whether detailed information is displayed + when the error occurred while parsing a data file of some kind. + + Usage: + + raise AnsibleError('some message here', obj=obj, show_content=True) + + Where "obj" is some subclass of ansible.parsing.yaml.objects.AnsibleBaseYAMLObject, + which should be returned by the DataLoader() class. + ''' + + def __init__(self, message="", obj=None, show_content=True, suppress_extended_error=False, orig_exc=None): + super(AnsibleError, self).__init__(message) + + # we import this here to prevent an import loop problem, + # since the objects code also imports ansible.errors + from ansible.parsing.yaml.objects import AnsibleBaseYAMLObject + + self._obj = obj + self._show_content = show_content + if obj and isinstance(obj, AnsibleBaseYAMLObject): + extended_error = self._get_extended_error() + if extended_error and not suppress_extended_error: + self.message = '%s\n\n%s' % (to_native(message), to_native(extended_error)) + else: + self.message = '%s' % to_native(message) + else: + self.message = '%s' % to_native(message) + if orig_exc: + self.orig_exc = orig_exc + + def __str__(self): + return self.message + + def __repr__(self): + return self.message + + def _get_error_lines_from_file(self, file_name, line_number): + ''' + Returns the line in the file which corresponds to the reported error + location, as well as the line preceding it (if the error did not + occur on the first line), to provide context to the error. + ''' + + target_line = '' + prev_line = '' + + with open(file_name, 'r') as f: + lines = f.readlines() + + target_line = lines[line_number] + if line_number > 0: + prev_line = lines[line_number - 1] + + return (target_line, prev_line) + + def _get_extended_error(self): + ''' + Given an object reporting the location of the exception in a file, return + detailed information regarding it including: + + * the line which caused the error as well as the one preceding it + * causes and suggested remedies for common syntax errors + + If this error was created with show_content=False, the reporting of content + is suppressed, as the file contents may be sensitive (ie. vault data). + ''' + + error_message = '' + + try: + (src_file, line_number, col_number) = self._obj.ansible_pos + error_message += YAML_POSITION_DETAILS % (src_file, line_number, col_number) + if src_file not in ('', '') and self._show_content: + (target_line, prev_line) = self._get_error_lines_from_file(src_file, line_number - 1) + target_line = to_text(target_line) + prev_line = to_text(prev_line) + if target_line: + stripped_line = target_line.replace(" ", "") + arrow_line = (" " * (col_number - 1)) + "^ here" + # header_line = ("=" * 73) + error_message += "\nThe offending line appears to be:\n\n%s\n%s\n%s\n" % (prev_line.rstrip(), target_line.rstrip(), arrow_line) + + # TODO: There may be cases where there is a valid tab in a line that has other errors. + if '\t' in target_line: + error_message += YAML_COMMON_LEADING_TAB_ERROR + # common error/remediation checking here: + # check for unquoted vars starting lines + if ('{{' in target_line and '}}' in target_line) and ('"{{' not in target_line or "'{{" not in target_line): + error_message += YAML_COMMON_UNQUOTED_VARIABLE_ERROR + # check for common dictionary mistakes + elif ":{{" in stripped_line and "}}" in stripped_line: + error_message += YAML_COMMON_DICT_ERROR + # check for common unquoted colon mistakes + elif (len(target_line) and + len(target_line) > 1 and + len(target_line) > col_number and + target_line[col_number] == ":" and + target_line.count(':') > 1): + error_message += YAML_COMMON_UNQUOTED_COLON_ERROR + # otherwise, check for some common quoting mistakes + else: + parts = target_line.split(":") + if len(parts) > 1: + middle = parts[1].strip() + match = False + unbalanced = False + + if middle.startswith("'") and not middle.endswith("'"): + match = True + elif middle.startswith('"') and not middle.endswith('"'): + match = True + + if (len(middle) > 0 and + middle[0] in ['"', "'"] and + middle[-1] in ['"', "'"] and + target_line.count("'") > 2 or + target_line.count('"') > 2): + unbalanced = True + + if match: + error_message += YAML_COMMON_PARTIALLY_QUOTED_LINE_ERROR + if unbalanced: + error_message += YAML_COMMON_UNBALANCED_QUOTES_ERROR + + except (IOError, TypeError): + error_message += '\n(could not open file to display line)' + except IndexError: + error_message += '\n(specified line no longer in file, maybe it changed?)' + + return error_message + + +class AnsibleAssertionError(AnsibleError, AssertionError): + '''Invalid assertion''' + pass + + +class AnsibleOptionsError(AnsibleError): + ''' bad or incomplete options passed ''' + pass + + +class AnsibleParserError(AnsibleError): + ''' something was detected early that is wrong about a playbook or data file ''' + pass + + +class AnsibleInternalError(AnsibleError): + ''' internal safeguards tripped, something happened in the code that should never happen ''' + pass + + +class AnsibleRuntimeError(AnsibleError): + ''' ansible had a problem while running a playbook ''' + pass + + +class AnsibleModuleError(AnsibleRuntimeError): + ''' a module failed somehow ''' + pass + + +class AnsibleConnectionFailure(AnsibleRuntimeError): + ''' the transport / connection_plugin had a fatal error ''' + pass + + +class AnsibleAuthenticationFailure(AnsibleConnectionFailure): + '''invalid username/password/key''' + pass + + +class AnsibleFilterError(AnsibleRuntimeError): + ''' a templating failure ''' + pass + + +class AnsibleLookupError(AnsibleRuntimeError): + ''' a lookup failure ''' + pass + + +class AnsibleCallbackError(AnsibleRuntimeError): + ''' a callback failure ''' + pass + + +class AnsibleUndefinedVariable(AnsibleRuntimeError): + ''' a templating failure ''' + pass + + +class AnsibleFileNotFound(AnsibleRuntimeError): + ''' a file missing failure ''' + + def __init__(self, message="", obj=None, show_content=True, suppress_extended_error=False, orig_exc=None, paths=None, file_name=None): + + self.file_name = file_name + self.paths = paths + + if self.file_name: + if message: + message += "\n" + message += "Could not find or access '%s'" % to_text(self.file_name) + + if self.paths and isinstance(self.paths, Sequence): + searched = to_text('\n\t'.join(self.paths)) + if message: + message += "\n" + message += "Searched in:\n\t%s" % searched + + message += " on the Ansible Controller.\nIf you are using a module and expect the file to exist on the remote, see the remote_src option" + + super(AnsibleFileNotFound, self).__init__(message=message, obj=obj, show_content=show_content, + suppress_extended_error=suppress_extended_error, orig_exc=orig_exc) + + +# These Exceptions are temporary, using them as flow control until we can get a better solution. +# DO NOT USE as they will probably be removed soon. +# We will port the action modules in our tree to use a context manager instead. +class AnsibleAction(AnsibleRuntimeError): + ''' Base Exception for Action plugin flow control ''' + + def __init__(self, message="", obj=None, show_content=True, suppress_extended_error=False, orig_exc=None, result=None): + + super(AnsibleAction, self).__init__(message=message, obj=obj, show_content=show_content, + suppress_extended_error=suppress_extended_error, orig_exc=orig_exc) + if result is None: + self.result = {} + else: + self.result = result + + +class AnsibleActionSkip(AnsibleAction): + ''' an action runtime skip''' + + def __init__(self, message="", obj=None, show_content=True, suppress_extended_error=False, orig_exc=None, result=None): + super(AnsibleActionSkip, self).__init__(message=message, obj=obj, show_content=show_content, + suppress_extended_error=suppress_extended_error, orig_exc=orig_exc, result=result) + self.result.update({'skipped': True, 'msg': message}) + + +class AnsibleActionFail(AnsibleAction): + ''' an action runtime failure''' + def __init__(self, message="", obj=None, show_content=True, suppress_extended_error=False, orig_exc=None, result=None): + super(AnsibleActionFail, self).__init__(message=message, obj=obj, show_content=show_content, + suppress_extended_error=suppress_extended_error, orig_exc=orig_exc, result=result) + self.result.update({'failed': True, 'msg': message}) + + +class _AnsibleActionDone(AnsibleAction): + ''' an action runtime early exit''' + pass diff --git a/env_27/lib/python2.7/site-packages/ansible/errors/yaml_strings.py b/env_27/lib/python2.7/site-packages/ansible/errors/yaml_strings.py new file mode 100644 index 0000000..ed574eb --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/errors/yaml_strings.py @@ -0,0 +1,135 @@ +# (c) 2012-2014, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +__all__ = [ + 'YAML_SYNTAX_ERROR', + 'YAML_POSITION_DETAILS', + 'YAML_COMMON_DICT_ERROR', + 'YAML_COMMON_UNQUOTED_VARIABLE_ERROR', + 'YAML_COMMON_UNQUOTED_COLON_ERROR', + 'YAML_COMMON_PARTIALLY_QUOTED_LINE_ERROR', + 'YAML_COMMON_UNBALANCED_QUOTES_ERROR', +] + +YAML_SYNTAX_ERROR = """\ +Syntax Error while loading YAML. + %s""" + +YAML_POSITION_DETAILS = """\ +The error appears to have been in '%s': line %s, column %s, but may +be elsewhere in the file depending on the exact syntax problem. +""" + +YAML_COMMON_DICT_ERROR = """\ +This one looks easy to fix. YAML thought it was looking for the start of a +hash/dictionary and was confused to see a second "{". Most likely this was +meant to be an ansible template evaluation instead, so we have to give the +parser a small hint that we wanted a string instead. The solution here is to +just quote the entire value. + +For instance, if the original line was: + + app_path: {{ base_path }}/foo + +It should be written as: + + app_path: "{{ base_path }}/foo" +""" + +YAML_COMMON_UNQUOTED_VARIABLE_ERROR = """\ +We could be wrong, but this one looks like it might be an issue with +missing quotes. Always quote template expression brackets when they +start a value. For instance: + + with_items: + - {{ foo }} + +Should be written as: + + with_items: + - "{{ foo }}" +""" + +YAML_COMMON_UNQUOTED_COLON_ERROR = """\ +This one looks easy to fix. There seems to be an extra unquoted colon in the line +and this is confusing the parser. It was only expecting to find one free +colon. The solution is just add some quotes around the colon, or quote the +entire line after the first colon. + +For instance, if the original line was: + + copy: src=file.txt dest=/path/filename:with_colon.txt + +It can be written as: + + copy: src=file.txt dest='/path/filename:with_colon.txt' + +Or: + + copy: 'src=file.txt dest=/path/filename:with_colon.txt' +""" + +YAML_COMMON_PARTIALLY_QUOTED_LINE_ERROR = """\ +This one looks easy to fix. It seems that there is a value started +with a quote, and the YAML parser is expecting to see the line ended +with the same kind of quote. For instance: + + when: "ok" in result.stdout + +Could be written as: + + when: '"ok" in result.stdout' + +Or equivalently: + + when: "'ok' in result.stdout" +""" + +YAML_COMMON_UNBALANCED_QUOTES_ERROR = """\ +We could be wrong, but this one looks like it might be an issue with +unbalanced quotes. If starting a value with a quote, make sure the +line ends with the same set of quotes. For instance this arbitrary +example: + + foo: "bad" "wolf" + +Could be written as: + + foo: '"bad" "wolf"' +""" + +YAML_COMMON_LEADING_TAB_ERROR = """\ +There appears to be a tab character at the start of the line. + +YAML does not use tabs for formatting. Tabs should be replaced with spaces. + +For example: + - name: update tooling + vars: + version: 1.2.3 +# ^--- there is a tab there. + +Should be written as: + - name: update tooling + vars: + version: 1.2.3 +# ^--- all spaces here. +""" diff --git a/env_27/lib/python2.7/site-packages/ansible/executor/__init__.py b/env_27/lib/python2.7/site-packages/ansible/executor/__init__.py new file mode 100644 index 0000000..ae8ccff --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/executor/__init__.py @@ -0,0 +1,20 @@ +# (c) 2012-2014, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type diff --git a/env_27/lib/python2.7/site-packages/ansible/executor/action_write_locks.py b/env_27/lib/python2.7/site-packages/ansible/executor/action_write_locks.py new file mode 100644 index 0000000..dfc7f9c --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/executor/action_write_locks.py @@ -0,0 +1,44 @@ +# (c) 2016 - Red Hat, Inc. +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +from multiprocessing import Lock + +from ansible.module_utils.facts.system.pkg_mgr import PKG_MGRS + +if 'action_write_locks' not in globals(): + # Do not initialize this more than once because it seems to bash + # the existing one. multiprocessing must be reloading the module + # when it forks? + action_write_locks = dict() + + # Below is a Lock for use when we weren't expecting a named module. It gets used when an action + # plugin invokes a module whose name does not match with the action's name. Slightly less + # efficient as all processes with unexpected module names will wait on this lock + action_write_locks[None] = Lock() + + # These plugins are known to be called directly by action plugins with names differing from the + # action plugin name. We precreate them here as an optimization. + # If a list of service managers is created in the future we can do the same for them. + mods = set(p['name'] for p in PKG_MGRS) + + mods.update(('copy', 'file', 'setup', 'slurp', 'stat')) + for mod_name in mods: + action_write_locks[mod_name] = Lock() diff --git a/env_27/lib/python2.7/site-packages/ansible/executor/module_common.py b/env_27/lib/python2.7/site-packages/ansible/executor/module_common.py new file mode 100644 index 0000000..4f4a438 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/executor/module_common.py @@ -0,0 +1,1003 @@ +# (c) 2013-2014, Michael DeHaan +# (c) 2015 Toshio Kuratomi +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import ast +import base64 +import datetime +import imp +import json +import os +import shlex +import zipfile +import random +import re +from distutils.version import LooseVersion +from io import BytesIO + +from ansible.release import __version__, __author__ +from ansible import constants as C +from ansible.errors import AnsibleError +from ansible.module_utils._text import to_bytes, to_text, to_native +from ansible.plugins.loader import module_utils_loader, ps_module_utils_loader +from ansible.plugins.shell.powershell import async_watchdog, async_wrapper, become_wrapper, leaf_exec, exec_wrapper +# Must import strategy and use write_locks from there +# If we import write_locks directly then we end up binding a +# variable to the object and then it never gets updated. +from ansible.executor import action_write_locks + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +REPLACER = b"#<>" +REPLACER_VERSION = b"\"<>\"" +REPLACER_COMPLEX = b"\"<>\"" +REPLACER_WINDOWS = b"# POWERSHELL_COMMON" +REPLACER_JSONARGS = b"<>" +REPLACER_SELINUX = b"<>" + +# We could end up writing out parameters with unicode characters so we need to +# specify an encoding for the python source file +ENCODING_STRING = u'# -*- coding: utf-8 -*-' +b_ENCODING_STRING = b'# -*- coding: utf-8 -*-' + +# module_common is relative to module_utils, so fix the path +_MODULE_UTILS_PATH = os.path.join(os.path.dirname(__file__), '..', 'module_utils') + +# ****************************************************************************** + +ANSIBALLZ_TEMPLATE = u'''%(shebang)s +%(coding)s +_ANSIBALLZ_WRAPPER = True # For test-module 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(): + 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 imp + import shutil + import tempfile + import zipfile + + if sys.version_info < (3,): + bytes = str + MOD_DESC = ('.py', 'U', imp.PY_SOURCE) + PY3 = False + else: + unicode = str + MOD_DESC = ('.py', 'r', imp.PY_SOURCE) + 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) + # Note: Remove the following section when we switch to zipimport + # Write the module to disk for imp.load_module + module = os.path.join(temp_path, '__main__.py') + with open(module, 'wb') as f: + f.write(z.read('__main__.py')) + f.close() + # End pre-zipimport section + 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 + with open(module, 'rb') as mod: + imp.load_module('__main__', mod, module, MOD_DESC) + + # 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') + script_path = os.path.join(basedir, '__main__.py') + + 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 + import imp + with open(script_path, 'r') as f: + importer = imp.load_module('__main__', f, script_path, ('.py', 'r', imp.PY_SOURCE)) + + # 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() +''' + +ANSIBALLZ_COVERAGE_TEMPLATE = ''' + # 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 + import coverage + + cov = coverage.Coverage(config_file='%(coverage_config)s') + + def atexit_coverage(): + cov.stop() + cov.save() + + atexit.register(atexit_coverage) + + cov.start() +''' + + +def _strip_comments(source): + # Strip comments and blank lines from the wrapper + buf = [] + for line in source.splitlines(): + l = line.strip() + if not l or l.startswith(u'#'): + continue + buf.append(line) + return u'\n'.join(buf) + + +if C.DEFAULT_KEEP_REMOTE_FILES: + # Keep comments when KEEP_REMOTE_FILES is set. That way users will see + # the comments with some nice usage instructions + ACTIVE_ANSIBALLZ_TEMPLATE = ANSIBALLZ_TEMPLATE +else: + # ANSIBALLZ_TEMPLATE stripped of comments for smaller over the wire size + ACTIVE_ANSIBALLZ_TEMPLATE = _strip_comments(ANSIBALLZ_TEMPLATE) + + +class ModuleDepFinder(ast.NodeVisitor): + # Caveats: + # This code currently does not handle: + # * relative imports from py2.6+ from . import urls + IMPORT_PREFIX_SIZE = len('ansible.module_utils.') + + def __init__(self, *args, **kwargs): + """ + Walk the ast tree for the python module. + + Save submodule[.submoduleN][.identifier] into self.submodules + + self.submodules will end up with tuples like: + - ('basic',) + - ('urls', 'fetch_url') + - ('database', 'postgres') + - ('database', 'postgres', 'quote') + + It's up to calling code to determine whether the final element of the + dotted strings are module names or something else (function, class, or + variable names) + """ + super(ModuleDepFinder, self).__init__(*args, **kwargs) + self.submodules = set() + + def visit_Import(self, node): + # import ansible.module_utils.MODLIB[.MODLIBn] [as asname] + for alias in (a for a in node.names if a.name.startswith('ansible.module_utils.')): + py_mod = alias.name[self.IMPORT_PREFIX_SIZE:] + py_mod = tuple(py_mod.split('.')) + self.submodules.add(py_mod) + self.generic_visit(node) + + def visit_ImportFrom(self, node): + # Specialcase: six is a special case because of its + # import logic + if node.names[0].name == '_six': + self.submodules.add(('_six',)) + elif node.module.startswith('ansible.module_utils'): + where_from = node.module[self.IMPORT_PREFIX_SIZE:] + if where_from: + # from ansible.module_utils.MODULE1[.MODULEn] import IDENTIFIER [as asname] + # from ansible.module_utils.MODULE1[.MODULEn] import MODULEn+1 [as asname] + # from ansible.module_utils.MODULE1[.MODULEn] import MODULEn+1 [,IDENTIFIER] [as asname] + py_mod = tuple(where_from.split('.')) + for alias in node.names: + self.submodules.add(py_mod + (alias.name,)) + else: + # from ansible.module_utils import MODLIB [,MODLIB2] [as asname] + for alias in node.names: + self.submodules.add((alias.name,)) + self.generic_visit(node) + + +class PSModuleDepFinder(): + + def __init__(self): + self.modules = dict() + self.ps_version = None + self.os_version = None + self.become = False + + self._re_module = re.compile(to_bytes(r'(?i)^#\s*requires\s+\-module(?:s?)\s*(Ansible\.ModuleUtils\..+)')) + self._re_ps_version = re.compile(to_bytes(r'(?i)^#requires\s+\-version\s+([0-9]+(\.[0-9]+){0,3})$')) + self._re_os_version = re.compile(to_bytes(r'(?i)^#ansiblerequires\s+\-osversion\s+([0-9]+(\.[0-9]+){0,3})$')) + self._re_become = re.compile(to_bytes(r'(?i)^#ansiblerequires\s+\-become$')) + + def scan_module(self, module_data): + lines = module_data.split(b'\n') + module_utils = set() + + for line in lines: + module_util_match = self._re_module.match(line) + if module_util_match: + # tolerate windows line endings by stripping any remaining newline chars + module_util_name = to_text(module_util_match.group(1).rstrip()) + if module_util_name not in self.modules.keys(): + module_utils.add(module_util_name) + + ps_version_match = self._re_ps_version.match(line) + if ps_version_match: + self._parse_version_match(ps_version_match, "ps_version") + + os_version_match = self._re_os_version.match(line) + if os_version_match: + self._parse_version_match(os_version_match, "os_version") + + # once become is set, no need to keep on checking recursively + if not self.become: + become_match = self._re_become.match(line) + if become_match: + self.become = True + + # recursively drill into each Requires to see if there are any more + # requirements + for m in set(module_utils): + m = to_text(m) + mu_path = ps_module_utils_loader.find_plugin(m, ".psm1") + if not mu_path: + raise AnsibleError('Could not find imported module support code for \'%s\'.' % m) + + module_util_data = to_bytes(_slurp(mu_path)) + self.modules[m] = module_util_data + self.scan_module(module_util_data) + + def _parse_version_match(self, match, attribute): + new_version = to_text(match.group(1)).rstrip() + + # PowerShell cannot cast a string of "1" to Version, it must have at + # least the major.minor for it to be valid so we append 0 + if match.group(2) is None: + new_version = "%s.0" % new_version + + existing_version = getattr(self, attribute, None) + if existing_version is None: + setattr(self, attribute, new_version) + else: + # determine which is the latest version and set that + if LooseVersion(new_version) > LooseVersion(existing_version): + setattr(self, attribute, new_version) + + +def _slurp(path): + if not os.path.exists(path): + raise AnsibleError("imported module support code does not exist at %s" % os.path.abspath(path)) + fd = open(path, 'rb') + data = fd.read() + fd.close() + return data + + +def _get_shebang(interpreter, task_vars, templar, args=tuple()): + """ + 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. + """ + interpreter_config = u'ansible_%s_interpreter' % os.path.basename(interpreter).strip() + + if interpreter_config not in task_vars: + return (None, interpreter) + + interpreter = templar.template(task_vars[interpreter_config].strip()) + shebang = u'#!' + interpreter + + if args: + shebang = shebang + u' ' + u' '.join(args) + + return (shebang, interpreter) + + +def recursive_finder(name, data, py_module_names, py_module_cache, zf): + """ + Using ModuleDepFinder, make sure we have all of the module_utils files that + the module its module_utils files needs. + """ + # Parse the module and find the imports of ansible.module_utils + tree = ast.parse(data) + finder = ModuleDepFinder() + finder.visit(tree) + + # + # Determine what imports that we've found are modules (vs class, function. + # variable names) for packages + # + + normalized_modules = set() + # Loop through the imports that we've found to normalize them + # Exclude paths that match with paths we've already processed + # (Have to exclude them a second time once the paths are processed) + + module_utils_paths = [p for p in module_utils_loader._get_paths(subdirs=False) if os.path.isdir(p)] + module_utils_paths.append(_MODULE_UTILS_PATH) + for py_module_name in finder.submodules.difference(py_module_names): + module_info = None + + if py_module_name[0] == 'six': + # Special case the python six library because it messes up the + # import process in an incompatible way + module_info = imp.find_module('six', module_utils_paths) + py_module_name = ('six',) + idx = 0 + elif py_module_name[0] == '_six': + # Special case the python six library because it messes up the + # import process in an incompatible way + module_info = imp.find_module('_six', [os.path.join(p, 'six') for p in module_utils_paths]) + py_module_name = ('six', '_six') + idx = 0 + else: + # Check whether either the last or the second to last identifier is + # a module name + for idx in (1, 2): + if len(py_module_name) < idx: + break + try: + module_info = imp.find_module(py_module_name[-idx], + [os.path.join(p, *py_module_name[:-idx]) for p in module_utils_paths]) + break + except ImportError: + continue + + # Could not find the module. Construct a helpful error message. + if module_info is None: + msg = ['Could not find imported module support code for %s. Looked for' % (name,)] + if idx == 2: + msg.append('either %s.py or %s.py' % (py_module_name[-1], py_module_name[-2])) + else: + msg.append(py_module_name[-1]) + raise AnsibleError(' '.join(msg)) + + # Found a byte compiled file rather than source. We cannot send byte + # compiled over the wire as the python version might be different. + # imp.find_module seems to prefer to return source packages so we just + # error out if imp.find_module returns byte compiled files (This is + # fragile as it depends on undocumented imp.find_module behaviour) + if module_info[2][2] not in (imp.PY_SOURCE, imp.PKG_DIRECTORY): + msg = ['Could not find python source for imported module support code for %s. Looked for' % name] + if idx == 2: + msg.append('either %s.py or %s.py' % (py_module_name[-1], py_module_name[-2])) + else: + msg.append(py_module_name[-1]) + raise AnsibleError(' '.join(msg)) + + if idx == 2: + # We've determined that the last portion was an identifier and + # thus, not part of the module name + py_module_name = py_module_name[:-1] + + # If not already processed then we've got work to do + # If not in the cache, then read the file into the cache + # We already have a file handle for the module open so it makes + # sense to read it now + if py_module_name not in py_module_cache: + if module_info[2][2] == imp.PKG_DIRECTORY: + # Read the __init__.py instead of the module file as this is + # a python package + normalized_name = py_module_name + ('__init__',) + if normalized_name not in py_module_names: + normalized_path = os.path.join(os.path.join(module_info[1], '__init__.py')) + normalized_data = _slurp(normalized_path) + py_module_cache[normalized_name] = (normalized_data, normalized_path) + normalized_modules.add(normalized_name) + else: + normalized_name = py_module_name + if normalized_name not in py_module_names: + normalized_path = module_info[1] + normalized_data = module_info[0].read() + module_info[0].close() + py_module_cache[normalized_name] = (normalized_data, normalized_path) + normalized_modules.add(normalized_name) + + # Make sure that all the packages that this module is a part of + # are also added + for i in range(1, len(py_module_name)): + py_pkg_name = py_module_name[:-i] + ('__init__',) + if py_pkg_name not in py_module_names: + pkg_dir_info = imp.find_module(py_pkg_name[-1], + [os.path.join(p, *py_pkg_name[:-1]) for p in module_utils_paths]) + normalized_modules.add(py_pkg_name) + py_module_cache[py_pkg_name] = (_slurp(pkg_dir_info[1]), pkg_dir_info[1]) + + # FIXME: Currently the AnsiBallZ wrapper monkeypatches module args into a global + # variable in basic.py. If a module doesn't import basic.py, then the AnsiBallZ wrapper will + # traceback when it tries to monkypatch. So, for now, we have to unconditionally include + # basic.py. + # + # In the future we need to change the wrapper to monkeypatch the args into a global variable in + # their own, separate python module. That way we won't require basic.py. Modules which don't + # want basic.py can import that instead. AnsibleModule will need to change to import the vars + # from the separate python module and mirror the args into its global variable for backwards + # compatibility. + if ('basic',) not in py_module_names: + pkg_dir_info = imp.find_module('basic', module_utils_paths) + normalized_modules.add(('basic',)) + py_module_cache[('basic',)] = (_slurp(pkg_dir_info[1]), pkg_dir_info[1]) + # End of AnsiballZ hack + + # + # iterate through all of the ansible.module_utils* imports that we haven't + # already checked for new imports + # + + # set of modules that we haven't added to the zipfile + unprocessed_py_module_names = normalized_modules.difference(py_module_names) + + for py_module_name in unprocessed_py_module_names: + py_module_path = os.path.join(*py_module_name) + py_module_file_name = '%s.py' % py_module_path + + zf.writestr(os.path.join("ansible/module_utils", + py_module_file_name), py_module_cache[py_module_name][0]) + display.vvvvv("Using module_utils file %s" % py_module_cache[py_module_name][1]) + + # Add the names of the files we're scheduling to examine in the loop to + # py_module_names so that we don't re-examine them in the next pass + # through recursive_finder() + py_module_names.update(unprocessed_py_module_names) + + for py_module_file in unprocessed_py_module_names: + recursive_finder(py_module_file, py_module_cache[py_module_file][0], py_module_names, py_module_cache, zf) + # Save memory; the file won't have to be read again for this ansible module. + del py_module_cache[py_module_file] + + +def _is_binary(b_module_data): + textchars = bytearray(set([7, 8, 9, 10, 12, 13, 27]) | set(range(0x20, 0x100)) - set([0x7f])) + start = b_module_data[:1024] + return bool(start.translate(None, textchars)) + + +def _find_module_utils(module_name, b_module_data, module_path, module_args, task_vars, templar, module_compression, async_timeout, become, + become_method, become_user, become_password, become_flags, environment): + """ + 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. + """ + module_substyle = module_style = 'old' + + # module_style is something important to calling code (ActionBase). It + # determines how arguments are formatted (json vs k=v) and whether + # a separate arguments file needs to be sent over the wire. + # module_substyle is extra information that's useful internally. It tells + # us what we have to look to substitute in the module files and whether + # we're using module replacer or ansiballz to format the module itself. + if _is_binary(b_module_data): + module_substyle = module_style = 'binary' + elif REPLACER in b_module_data: + # Do REPLACER before from ansible.module_utils because we need make sure + # we substitute "from ansible.module_utils basic" for REPLACER + module_style = 'new' + module_substyle = 'python' + b_module_data = b_module_data.replace(REPLACER, b'from ansible.module_utils.basic import *') + elif b'from ansible.module_utils.' in b_module_data: + module_style = 'new' + module_substyle = 'python' + elif REPLACER_WINDOWS in b_module_data: + module_style = 'new' + module_substyle = 'powershell' + b_module_data = b_module_data.replace(REPLACER_WINDOWS, b'#Requires -Module Ansible.ModuleUtils.Legacy') + elif re.search(b'#Requires -Module', b_module_data, re.IGNORECASE) \ + or re.search(b'#Requires -Version', b_module_data, re.IGNORECASE)\ + or re.search(b'#AnsibleRequires -OSVersion', b_module_data, re.IGNORECASE): + module_style = 'new' + module_substyle = 'powershell' + elif REPLACER_JSONARGS in b_module_data: + module_style = 'new' + module_substyle = 'jsonargs' + elif b'WANT_JSON' in b_module_data: + module_substyle = module_style = 'non_native_want_json' + + shebang = None + # Neither old-style, non_native_want_json nor binary modules should be modified + # except for the shebang line (Done by modify_module) + if module_style in ('old', 'non_native_want_json', 'binary'): + return b_module_data, module_style, shebang + + output = BytesIO() + py_module_names = set() + + if module_substyle == 'python': + params = dict(ANSIBLE_MODULE_ARGS=module_args,) + python_repred_params = repr(json.dumps(params)) + + try: + compression_method = getattr(zipfile, module_compression) + except AttributeError: + display.warning(u'Bad module compression string specified: %s. Using ZIP_STORED (no compression)' % module_compression) + compression_method = zipfile.ZIP_STORED + + lookup_path = os.path.join(C.DEFAULT_LOCAL_TMP, 'ansiballz_cache') + cached_module_filename = os.path.join(lookup_path, "%s-%s" % (module_name, module_compression)) + + zipdata = None + # Optimization -- don't lock if the module has already been cached + if os.path.exists(cached_module_filename): + display.debug('ANSIBALLZ: using cached module: %s' % cached_module_filename) + zipdata = open(cached_module_filename, 'rb').read() + else: + if module_name in action_write_locks.action_write_locks: + display.debug('ANSIBALLZ: Using lock for %s' % module_name) + lock = action_write_locks.action_write_locks[module_name] + else: + # If the action plugin directly invokes the module (instead of + # going through a strategy) then we don't have a cross-process + # Lock specifically for this module. Use the "unexpected + # module" lock instead + display.debug('ANSIBALLZ: Using generic lock for %s' % module_name) + lock = action_write_locks.action_write_locks[None] + + display.debug('ANSIBALLZ: Acquiring lock') + with lock: + display.debug('ANSIBALLZ: Lock acquired: %s' % id(lock)) + # Check that no other process has created this while we were + # waiting for the lock + if not os.path.exists(cached_module_filename): + display.debug('ANSIBALLZ: Creating module') + # Create the module zip data + zipoutput = BytesIO() + zf = zipfile.ZipFile(zipoutput, mode='w', compression=compression_method) + # Note: If we need to import from release.py first, + # remember to catch all exceptions: https://github.com/ansible/ansible/issues/16523 + zf.writestr('ansible/__init__.py', + b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n__version__="' + + to_bytes(__version__) + b'"\n__author__="' + + to_bytes(__author__) + b'"\n') + zf.writestr('ansible/module_utils/__init__.py', b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n') + + zf.writestr('__main__.py', b_module_data) + + py_module_cache = {('__init__',): (b'', '[builtin]')} + recursive_finder(module_name, b_module_data, py_module_names, py_module_cache, zf) + zf.close() + zipdata = base64.b64encode(zipoutput.getvalue()) + + # Write the assembled module to a temp file (write to temp + # so that no one looking for the file reads a partially + # written file) + if not os.path.exists(lookup_path): + # Note -- if we have a global function to setup, that would + # be a better place to run this + os.makedirs(lookup_path) + display.debug('ANSIBALLZ: Writing module') + with open(cached_module_filename + '-part', 'wb') as f: + f.write(zipdata) + + # Rename the file into its final position in the cache so + # future users of this module can read it off the + # filesystem instead of constructing from scratch. + display.debug('ANSIBALLZ: Renaming module') + os.rename(cached_module_filename + '-part', cached_module_filename) + display.debug('ANSIBALLZ: Done creating module') + + if zipdata is None: + display.debug('ANSIBALLZ: Reading module after lock') + # Another process wrote the file while we were waiting for + # the write lock. Go ahead and read the data from disk + # instead of re-creating it. + try: + zipdata = open(cached_module_filename, 'rb').read() + except IOError: + raise AnsibleError('A different worker process failed to create module file. ' + 'Look at traceback for that process for debugging information.') + zipdata = to_text(zipdata, errors='surrogate_or_strict') + + shebang, interpreter = _get_shebang(u'/usr/bin/python', task_vars, templar) + if shebang is None: + shebang = u'#!/usr/bin/python' + + # Enclose the parts of the interpreter in quotes because we're + # substituting it into the template as a Python string + interpreter_parts = interpreter.split(u' ') + interpreter = u"'{0}'".format(u"', '".join(interpreter_parts)) + + coverage_config = os.environ.get('_ANSIBLE_COVERAGE_CONFIG') + + if coverage_config: + # Enable code coverage analysis of the module. + # This feature is for internal testing and may change without notice. + coverage = ANSIBALLZ_COVERAGE_TEMPLATE % dict( + coverage_config=coverage_config, + coverage_output=os.environ['_ANSIBLE_COVERAGE_OUTPUT'] + ) + else: + coverage = '' + + now = datetime.datetime.utcnow() + output.write(to_bytes(ACTIVE_ANSIBALLZ_TEMPLATE % dict( + zipdata=zipdata, + ansible_module=module_name, + params=python_repred_params, + shebang=shebang, + interpreter=interpreter, + coding=ENCODING_STRING, + year=now.year, + month=now.month, + day=now.day, + hour=now.hour, + minute=now.minute, + second=now.second, + coverage=coverage, + ))) + b_module_data = output.getvalue() + + elif module_substyle == 'powershell': + # Powershell/winrm don't actually make use of shebang so we can + # safely set this here. If we let the fallback code handle this + # it can fail in the presence of the UTF8 BOM commonly added by + # Windows text editors + shebang = u'#!powershell' + + exec_manifest = dict( + module_entry=to_text(base64.b64encode(b_module_data)), + powershell_modules=dict(), + module_args=module_args, + actions=['exec'], + environment=environment + ) + + exec_manifest['exec'] = to_text(base64.b64encode(to_bytes(leaf_exec))) + + if async_timeout > 0: + exec_manifest["actions"].insert(0, 'async_watchdog') + exec_manifest["async_watchdog"] = to_text(base64.b64encode(to_bytes(async_watchdog))) + exec_manifest["actions"].insert(0, 'async_wrapper') + exec_manifest["async_wrapper"] = to_text(base64.b64encode(to_bytes(async_wrapper))) + exec_manifest["async_jid"] = str(random.randint(0, 999999999999)) + exec_manifest["async_timeout_sec"] = async_timeout + + if become and become_method == 'runas': + exec_manifest["actions"].insert(0, 'become') + exec_manifest["become_user"] = become_user + exec_manifest["become_password"] = become_password + exec_manifest['become_flags'] = become_flags + exec_manifest["become"] = to_text(base64.b64encode(to_bytes(become_wrapper))) + + finder = PSModuleDepFinder() + finder.scan_module(b_module_data) + + for name, data in finder.modules.items(): + b64_data = to_text(base64.b64encode(data)) + exec_manifest['powershell_modules'][name] = b64_data + + exec_manifest['min_ps_version'] = finder.ps_version + exec_manifest['min_os_version'] = finder.os_version + if finder.become and 'become' not in exec_manifest['actions']: + exec_manifest['actions'].insert(0, 'become') + exec_manifest['become_user'] = 'SYSTEM' + exec_manifest['become_password'] = None + exec_manifest['become_flags'] = None + exec_manifest['become'] = to_text(base64.b64encode(to_bytes(become_wrapper))) + + # FUTURE: smuggle this back as a dict instead of serializing here; the connection plugin may need to modify it + module_json = json.dumps(exec_manifest) + + # delimit the payload JSON from the wrapper to keep sensitive contents out of scriptblocks (which can be logged) + b_module_data = to_bytes(exec_wrapper) + b'\0\0\0\0' + to_bytes(module_json) + + elif module_substyle == 'jsonargs': + module_args_json = to_bytes(json.dumps(module_args)) + + # these strings could be included in a third-party module but + # officially they were included in the 'basic' snippet for new-style + # python modules (which has been replaced with something else in + # ansiballz) If we remove them from jsonargs-style module replacer + # then we can remove them everywhere. + python_repred_args = to_bytes(repr(module_args_json)) + b_module_data = b_module_data.replace(REPLACER_VERSION, to_bytes(repr(__version__))) + b_module_data = b_module_data.replace(REPLACER_COMPLEX, python_repred_args) + b_module_data = b_module_data.replace(REPLACER_SELINUX, to_bytes(','.join(C.DEFAULT_SELINUX_SPECIAL_FS))) + + # The main event -- substitute the JSON args string into the module + b_module_data = b_module_data.replace(REPLACER_JSONARGS, module_args_json) + + facility = b'syslog.' + to_bytes(task_vars.get('ansible_syslog_facility', C.DEFAULT_SYSLOG_FACILITY), errors='surrogate_or_strict') + b_module_data = b_module_data.replace(b'syslog.LOG_USER', facility) + + return (b_module_data, module_style, shebang) + + +def modify_module(module_name, module_path, module_args, templar, task_vars=None, module_compression='ZIP_STORED', async_timeout=0, become=False, + become_method=None, become_user=None, become_password=None, become_flags=None, environment=None): + """ + 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. + + """ + task_vars = {} if task_vars is None else task_vars + environment = {} if environment is None else environment + + with open(module_path, 'rb') as f: + + # read in the module source + b_module_data = f.read() + + (b_module_data, module_style, shebang) = _find_module_utils(module_name, b_module_data, module_path, module_args, task_vars, templar, module_compression, + async_timeout=async_timeout, become=become, become_method=become_method, + become_user=become_user, become_password=become_password, become_flags=become_flags, + environment=environment) + + if module_style == 'binary': + return (b_module_data, module_style, to_text(shebang, nonstring='passthru')) + elif shebang is None: + b_lines = b_module_data.split(b"\n", 1) + if b_lines[0].startswith(b"#!"): + b_shebang = b_lines[0].strip() + # shlex.split on python-2.6 needs bytes. On python-3.x it needs text + args = shlex.split(to_native(b_shebang[2:], errors='surrogate_or_strict')) + + # _get_shebang() takes text strings + args = [to_text(a, errors='surrogate_or_strict') for a in args] + interpreter = args[0] + b_new_shebang = to_bytes(_get_shebang(interpreter, task_vars, templar, args[1:])[0], + errors='surrogate_or_strict', nonstring='passthru') + + if b_new_shebang: + b_lines[0] = b_shebang = b_new_shebang + + if os.path.basename(interpreter).startswith(u'python'): + b_lines.insert(1, b_ENCODING_STRING) + + shebang = to_text(b_shebang, nonstring='passthru', errors='surrogate_or_strict') + else: + # No shebang, assume a binary module? + pass + + b_module_data = b"\n".join(b_lines) + + return (b_module_data, module_style, shebang) diff --git a/env_27/lib/python2.7/site-packages/ansible/executor/play_iterator.py b/env_27/lib/python2.7/site-packages/ansible/executor/play_iterator.py new file mode 100644 index 0000000..cdf5048 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/executor/play_iterator.py @@ -0,0 +1,568 @@ +# (c) 2012-2014, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import fnmatch + +from ansible import constants as C +from ansible.module_utils.six import iteritems +from ansible.module_utils.parsing.convert_bool import boolean +from ansible.playbook.block import Block +from ansible.playbook.task import Task + + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +__all__ = ['PlayIterator'] + + +class HostState: + def __init__(self, blocks): + self._blocks = blocks[:] + + self.cur_block = 0 + self.cur_regular_task = 0 + self.cur_rescue_task = 0 + self.cur_always_task = 0 + self.cur_dep_chain = None + self.run_state = PlayIterator.ITERATING_SETUP + self.fail_state = PlayIterator.FAILED_NONE + self.pending_setup = False + self.tasks_child_state = None + self.rescue_child_state = None + self.always_child_state = None + self.did_rescue = False + self.did_start_at_task = False + + def __repr__(self): + return "HostState(%r)" % self._blocks + + def __str__(self): + def _run_state_to_string(n): + states = ["ITERATING_SETUP", "ITERATING_TASKS", "ITERATING_RESCUE", "ITERATING_ALWAYS", "ITERATING_COMPLETE"] + try: + return states[n] + except IndexError: + return "UNKNOWN STATE" + + def _failed_state_to_string(n): + states = {1: "FAILED_SETUP", 2: "FAILED_TASKS", 4: "FAILED_RESCUE", 8: "FAILED_ALWAYS"} + if n == 0: + return "FAILED_NONE" + else: + ret = [] + for i in (1, 2, 4, 8): + if n & i: + ret.append(states[i]) + return "|".join(ret) + + return ("HOST STATE: block=%d, task=%d, rescue=%d, always=%d, run_state=%s, fail_state=%s, pending_setup=%s, tasks child state? (%s), " + "rescue child state? (%s), always child state? (%s), did rescue? %s, did start at task? %s" % ( + self.cur_block, + self.cur_regular_task, + self.cur_rescue_task, + self.cur_always_task, + _run_state_to_string(self.run_state), + _failed_state_to_string(self.fail_state), + self.pending_setup, + self.tasks_child_state, + self.rescue_child_state, + self.always_child_state, + self.did_rescue, + self.did_start_at_task, + )) + + def __eq__(self, other): + if not isinstance(other, HostState): + return False + + for attr in ('_blocks', 'cur_block', 'cur_regular_task', 'cur_rescue_task', 'cur_always_task', + 'run_state', 'fail_state', 'pending_setup', 'cur_dep_chain', + 'tasks_child_state', 'rescue_child_state', 'always_child_state'): + if getattr(self, attr) != getattr(other, attr): + return False + + return True + + def get_current_block(self): + return self._blocks[self.cur_block] + + def copy(self): + new_state = HostState(self._blocks) + new_state.cur_block = self.cur_block + new_state.cur_regular_task = self.cur_regular_task + new_state.cur_rescue_task = self.cur_rescue_task + new_state.cur_always_task = self.cur_always_task + new_state.run_state = self.run_state + new_state.fail_state = self.fail_state + new_state.pending_setup = self.pending_setup + new_state.did_rescue = self.did_rescue + new_state.did_start_at_task = self.did_start_at_task + if self.cur_dep_chain is not None: + new_state.cur_dep_chain = self.cur_dep_chain[:] + if self.tasks_child_state is not None: + new_state.tasks_child_state = self.tasks_child_state.copy() + if self.rescue_child_state is not None: + new_state.rescue_child_state = self.rescue_child_state.copy() + if self.always_child_state is not None: + new_state.always_child_state = self.always_child_state.copy() + return new_state + + +class PlayIterator: + + # the primary running states for the play iteration + ITERATING_SETUP = 0 + ITERATING_TASKS = 1 + ITERATING_RESCUE = 2 + ITERATING_ALWAYS = 3 + ITERATING_COMPLETE = 4 + + # the failure states for the play iteration, which are powers + # of 2 as they may be or'ed together in certain circumstances + FAILED_NONE = 0 + FAILED_SETUP = 1 + FAILED_TASKS = 2 + FAILED_RESCUE = 4 + FAILED_ALWAYS = 8 + + def __init__(self, inventory, play, play_context, variable_manager, all_vars, start_at_done=False): + self._play = play + self._blocks = [] + self._variable_manager = variable_manager + + # Default options to gather + gather_subset = play_context.gather_subset + gather_timeout = play_context.gather_timeout + fact_path = play_context.fact_path + + # Retrieve subset to gather + if self._play.gather_subset is not None: + gather_subset = self._play.gather_subset + # Retrieve timeout for gather + if self._play.gather_timeout is not None: + gather_timeout = self._play.gather_timeout + # Retrieve fact_path + if self._play.fact_path is not None: + fact_path = self._play.fact_path + + setup_block = Block(play=self._play) + # Gathering facts with run_once would copy the facts from one host to + # the others. + setup_block.run_once = False + setup_task = Task(block=setup_block) + setup_task.action = 'setup' + setup_task.name = 'Gathering Facts' + setup_task.tags = ['always'] + setup_task.args = { + 'gather_subset': gather_subset, + } + if gather_timeout: + setup_task.args['gather_timeout'] = gather_timeout + if fact_path: + setup_task.args['fact_path'] = fact_path + setup_task.set_loader(self._play._loader) + # short circuit fact gathering if the entire playbook is conditional + if self._play._included_conditional is not None: + setup_task.when = self._play._included_conditional[:] + setup_block.block = [setup_task] + + setup_block = setup_block.filter_tagged_tasks(play_context, all_vars) + self._blocks.append(setup_block) + self.cache_block_tasks(setup_block) + + for block in self._play.compile(): + new_block = block.filter_tagged_tasks(play_context, all_vars) + if new_block.has_tasks(): + self.cache_block_tasks(new_block) + self._blocks.append(new_block) + + for handler_block in self._play.handlers: + self.cache_block_tasks(handler_block) + + self._host_states = {} + start_at_matched = False + batch = inventory.get_hosts(self._play.hosts, order=self._play.order) + self.batch_size = len(batch) + for host in batch: + self._host_states[host.name] = HostState(blocks=self._blocks) + # if we're looking to start at a specific task, iterate through + # the tasks for this host until we find the specified task + if play_context.start_at_task is not None and not start_at_done: + while True: + (s, task) = self.get_next_task_for_host(host, peek=True) + if s.run_state == self.ITERATING_COMPLETE: + break + if task.name == play_context.start_at_task or fnmatch.fnmatch(task.name, play_context.start_at_task) or \ + task.get_name() == play_context.start_at_task or fnmatch.fnmatch(task.get_name(), play_context.start_at_task): + start_at_matched = True + break + else: + self.get_next_task_for_host(host) + + # finally, reset the host's state to ITERATING_SETUP + if start_at_matched: + self._host_states[host.name].did_start_at_task = True + self._host_states[host.name].run_state = self.ITERATING_SETUP + + if start_at_matched: + # we have our match, so clear the start_at_task field on the + # play context to flag that we've started at a task (and future + # plays won't try to advance) + play_context.start_at_task = None + + def get_host_state(self, host): + # Since we're using the PlayIterator to carry forward failed hosts, + # in the event that a previous host was not in the current inventory + # we create a stub state for it now + if host.name not in self._host_states: + self._host_states[host.name] = HostState(blocks=[]) + + return self._host_states[host.name].copy() + + def cache_block_tasks(self, block): + # now a noop, we've changed the way we do caching and finding of + # original task entries, but just in case any 3rd party strategies + # are using this we're leaving it here for now + return + + def get_next_task_for_host(self, host, peek=False): + + display.debug("getting the next task for host %s" % host.name) + s = self.get_host_state(host) + + task = None + if s.run_state == self.ITERATING_COMPLETE: + display.debug("host %s is done iterating, returning" % host.name) + return (s, None) + + (s, task) = self._get_next_task_from_state(s, host=host, peek=peek) + + if not peek: + self._host_states[host.name] = s + + display.debug("done getting next task for host %s" % host.name) + display.debug(" ^ task is: %s" % task) + display.debug(" ^ state is: %s" % s) + return (s, task) + + def _get_next_task_from_state(self, state, host, peek, in_child=False): + + task = None + + # try and find the next task, given the current state. + while True: + # try to get the current block from the list of blocks, and + # if we run past the end of the list we know we're done with + # this block + try: + block = state._blocks[state.cur_block] + except IndexError: + state.run_state = self.ITERATING_COMPLETE + return (state, None) + + if state.run_state == self.ITERATING_SETUP: + # First, we check to see if we were pending setup. If not, this is + # the first trip through ITERATING_SETUP, so we set the pending_setup + # flag and try to determine if we do in fact want to gather facts for + # the specified host. + if not state.pending_setup: + state.pending_setup = True + + # Gather facts if the default is 'smart' and we have not yet + # done it for this host; or if 'explicit' and the play sets + # gather_facts to True; or if 'implicit' and the play does + # NOT explicitly set gather_facts to False. + + gathering = C.DEFAULT_GATHERING + implied = self._play.gather_facts is None or boolean(self._play.gather_facts, strict=False) + + if (gathering == 'implicit' and implied) or \ + (gathering == 'explicit' and boolean(self._play.gather_facts, strict=False)) or \ + (gathering == 'smart' and implied and not (self._variable_manager._fact_cache.get(host.name, {}).get('module_setup', False))): + # The setup block is always self._blocks[0], as we inject it + # during the play compilation in __init__ above. + setup_block = self._blocks[0] + if setup_block.has_tasks() and len(setup_block.block) > 0: + task = setup_block.block[0] + else: + # This is the second trip through ITERATING_SETUP, so we clear + # the flag and move onto the next block in the list while setting + # the run state to ITERATING_TASKS + state.pending_setup = False + + state.run_state = self.ITERATING_TASKS + if not state.did_start_at_task: + state.cur_block += 1 + state.cur_regular_task = 0 + state.cur_rescue_task = 0 + state.cur_always_task = 0 + state.child_state = None + + elif state.run_state == self.ITERATING_TASKS: + # clear the pending setup flag, since we're past that and it didn't fail + if state.pending_setup: + state.pending_setup = False + + # First, we check for a child task state that is not failed, and if we + # have one recurse into it for the next task. If we're done with the child + # state, we clear it and drop back to getting the next task from the list. + if state.tasks_child_state: + (state.tasks_child_state, task) = self._get_next_task_from_state(state.tasks_child_state, host=host, peek=peek, in_child=True) + if self._check_failed_state(state.tasks_child_state): + # failed child state, so clear it and move into the rescue portion + state.tasks_child_state = None + self._set_failed_state(state) + else: + # get the next task recursively + if task is None or state.tasks_child_state.run_state == self.ITERATING_COMPLETE: + # we're done with the child state, so clear it and continue + # back to the top of the loop to get the next task + state.tasks_child_state = None + continue + else: + # First here, we check to see if we've failed anywhere down the chain + # of states we have, and if so we move onto the rescue portion. Otherwise, + # we check to see if we've moved past the end of the list of tasks. If so, + # we move into the always portion of the block, otherwise we get the next + # task from the list. + if self._check_failed_state(state): + state.run_state = self.ITERATING_RESCUE + elif state.cur_regular_task >= len(block.block): + state.run_state = self.ITERATING_ALWAYS + else: + task = block.block[state.cur_regular_task] + # if the current task is actually a child block, create a child + # state for us to recurse into on the next pass + if isinstance(task, Block) or state.tasks_child_state is not None: + state.tasks_child_state = HostState(blocks=[task]) + state.tasks_child_state.run_state = self.ITERATING_TASKS + # since we've created the child state, clear the task + # so we can pick up the child state on the next pass + task = None + state.cur_regular_task += 1 + + elif state.run_state == self.ITERATING_RESCUE: + # The process here is identical to ITERATING_TASKS, except instead + # we move into the always portion of the block. + if host.name in self._play._removed_hosts: + self._play._removed_hosts.remove(host.name) + + if state.rescue_child_state: + (state.rescue_child_state, task) = self._get_next_task_from_state(state.rescue_child_state, host=host, peek=peek, in_child=True) + if self._check_failed_state(state.rescue_child_state): + state.rescue_child_state = None + self._set_failed_state(state) + else: + if task is None or state.rescue_child_state.run_state == self.ITERATING_COMPLETE: + state.rescue_child_state = None + continue + else: + if state.fail_state & self.FAILED_RESCUE == self.FAILED_RESCUE: + state.run_state = self.ITERATING_ALWAYS + elif state.cur_rescue_task >= len(block.rescue): + if len(block.rescue) > 0: + state.fail_state = self.FAILED_NONE + state.run_state = self.ITERATING_ALWAYS + state.did_rescue = True + else: + task = block.rescue[state.cur_rescue_task] + if isinstance(task, Block) or state.rescue_child_state is not None: + state.rescue_child_state = HostState(blocks=[task]) + state.rescue_child_state.run_state = self.ITERATING_TASKS + task = None + state.cur_rescue_task += 1 + + elif state.run_state == self.ITERATING_ALWAYS: + # And again, the process here is identical to ITERATING_TASKS, except + # instead we either move onto the next block in the list, or we set the + # run state to ITERATING_COMPLETE in the event of any errors, or when we + # have hit the end of the list of blocks. + if state.always_child_state: + (state.always_child_state, task) = self._get_next_task_from_state(state.always_child_state, host=host, peek=peek, in_child=True) + if self._check_failed_state(state.always_child_state): + state.always_child_state = None + self._set_failed_state(state) + else: + if task is None or state.always_child_state.run_state == self.ITERATING_COMPLETE: + state.always_child_state = None + continue + else: + if state.cur_always_task >= len(block.always): + if state.fail_state != self.FAILED_NONE: + state.run_state = self.ITERATING_COMPLETE + else: + state.cur_block += 1 + state.cur_regular_task = 0 + state.cur_rescue_task = 0 + state.cur_always_task = 0 + state.run_state = self.ITERATING_TASKS + state.tasks_child_state = None + state.rescue_child_state = None + state.always_child_state = None + state.did_rescue = False + + # we're advancing blocks, so if this was an end-of-role block we + # mark the current role complete + if block._eor and host.name in block._role._had_task_run and not in_child and not peek: + block._role._completed[host.name] = True + else: + task = block.always[state.cur_always_task] + if isinstance(task, Block) or state.always_child_state is not None: + state.always_child_state = HostState(blocks=[task]) + state.always_child_state.run_state = self.ITERATING_TASKS + task = None + state.cur_always_task += 1 + + elif state.run_state == self.ITERATING_COMPLETE: + return (state, None) + + # if something above set the task, break out of the loop now + if task: + break + + return (state, task) + + def _set_failed_state(self, state): + if state.run_state == self.ITERATING_SETUP: + state.fail_state |= self.FAILED_SETUP + state.run_state = self.ITERATING_COMPLETE + elif state.run_state == self.ITERATING_TASKS: + if state.tasks_child_state is not None: + state.tasks_child_state = self._set_failed_state(state.tasks_child_state) + else: + state.fail_state |= self.FAILED_TASKS + if state._blocks[state.cur_block].rescue: + state.run_state = self.ITERATING_RESCUE + elif state._blocks[state.cur_block].always: + state.run_state = self.ITERATING_ALWAYS + else: + state.run_state = self.ITERATING_COMPLETE + elif state.run_state == self.ITERATING_RESCUE: + if state.rescue_child_state is not None: + state.rescue_child_state = self._set_failed_state(state.rescue_child_state) + else: + state.fail_state |= self.FAILED_RESCUE + if state._blocks[state.cur_block].always: + state.run_state = self.ITERATING_ALWAYS + else: + state.run_state = self.ITERATING_COMPLETE + elif state.run_state == self.ITERATING_ALWAYS: + if state.always_child_state is not None: + state.always_child_state = self._set_failed_state(state.always_child_state) + else: + state.fail_state |= self.FAILED_ALWAYS + state.run_state = self.ITERATING_COMPLETE + return state + + def mark_host_failed(self, host): + s = self.get_host_state(host) + display.debug("marking host %s failed, current state: %s" % (host, s)) + s = self._set_failed_state(s) + display.debug("^ failed state is now: %s" % s) + self._host_states[host.name] = s + self._play._removed_hosts.append(host.name) + + def get_failed_hosts(self): + return dict((host, True) for (host, state) in iteritems(self._host_states) if self._check_failed_state(state)) + + def _check_failed_state(self, state): + if state is None: + return False + elif state.run_state == self.ITERATING_RESCUE and self._check_failed_state(state.rescue_child_state): + return True + elif state.run_state == self.ITERATING_ALWAYS and self._check_failed_state(state.always_child_state): + return True + elif state.fail_state != self.FAILED_NONE: + if state.run_state == self.ITERATING_RESCUE and state.fail_state & self.FAILED_RESCUE == 0: + return False + elif state.run_state == self.ITERATING_ALWAYS and state.fail_state & self.FAILED_ALWAYS == 0: + return False + else: + return not state.did_rescue + elif state.run_state == self.ITERATING_TASKS and self._check_failed_state(state.tasks_child_state): + cur_block = self._blocks[state.cur_block] + if len(cur_block.rescue) > 0 and state.fail_state & self.FAILED_RESCUE == 0: + return False + else: + return True + return False + + def is_failed(self, host): + s = self.get_host_state(host) + return self._check_failed_state(s) + + def get_active_state(self, state): + ''' + Finds the active state, recursively if necessary when there are child states. + ''' + if state.run_state == self.ITERATING_TASKS and state.tasks_child_state is not None: + return self.get_active_state(state.tasks_child_state) + elif state.run_state == self.ITERATING_RESCUE and state.rescue_child_state is not None: + return self.get_active_state(state.rescue_child_state) + elif state.run_state == self.ITERATING_ALWAYS and state.always_child_state is not None: + return self.get_active_state(state.always_child_state) + return state + + def get_original_task(self, host, task): + # now a noop because we've changed the way we do caching + return (None, None) + + def _insert_tasks_into_state(self, state, task_list): + # if we've failed at all, or if the task list is empty, just return the current state + if state.fail_state != self.FAILED_NONE and state.run_state not in (self.ITERATING_RESCUE, self.ITERATING_ALWAYS) or not task_list: + return state + + if state.run_state == self.ITERATING_TASKS: + if state.tasks_child_state: + state.tasks_child_state = self._insert_tasks_into_state(state.tasks_child_state, task_list) + else: + target_block = state._blocks[state.cur_block].copy() + before = target_block.block[:state.cur_regular_task] + after = target_block.block[state.cur_regular_task:] + target_block.block = before + task_list + after + state._blocks[state.cur_block] = target_block + elif state.run_state == self.ITERATING_RESCUE: + if state.rescue_child_state: + state.rescue_child_state = self._insert_tasks_into_state(state.rescue_child_state, task_list) + else: + target_block = state._blocks[state.cur_block].copy() + before = target_block.rescue[:state.cur_rescue_task] + after = target_block.rescue[state.cur_rescue_task:] + target_block.rescue = before + task_list + after + state._blocks[state.cur_block] = target_block + elif state.run_state == self.ITERATING_ALWAYS: + if state.always_child_state: + state.always_child_state = self._insert_tasks_into_state(state.always_child_state, task_list) + else: + target_block = state._blocks[state.cur_block].copy() + before = target_block.always[:state.cur_always_task] + after = target_block.always[state.cur_always_task:] + target_block.always = before + task_list + after + state._blocks[state.cur_block] = target_block + return state + + def add_tasks(self, host, task_list): + self._host_states[host.name] = self._insert_tasks_into_state(self.get_host_state(host), task_list) diff --git a/env_27/lib/python2.7/site-packages/ansible/executor/playbook_executor.py b/env_27/lib/python2.7/site-packages/ansible/executor/playbook_executor.py new file mode 100644 index 0000000..59b1783 --- /dev/null +++ b/env_27/lib/python2.7/site-packages/ansible/executor/playbook_executor.py @@ -0,0 +1,291 @@ +# (c) 2012-2014, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +import os + +from ansible import constants as C +from ansible.executor.task_queue_manager import TaskQueueManager +from ansible.module_utils._text import to_native, to_text +from ansible.playbook import Playbook +from ansible.template import Templar +from ansible.utils.helpers import pct_to_int +from ansible.module_utils.parsing.convert_bool import boolean +from ansible.utils.path import makedirs_safe +from ansible.utils.ssh_functions import check_for_controlpersist + +try: + from __main__ import display +except ImportError: + from ansible.utils.display import Display + display = Display() + + +class PlaybookExecutor: + + ''' + This is the primary class for executing playbooks, and thus the + basis for bin/ansible-playbook operation. + ''' + + def __init__(self, playbooks, inventory, variable_manager, loader, options, passwords): + self._playbooks = playbooks + self._inventory = inventory + self._variable_manager = variable_manager + self._loader = loader + self._options = options + self.passwords = passwords + self._unreachable_hosts = dict() + + if options.listhosts or options.listtasks or options.listtags or options.syntax: + self._tqm = None + else: + self._tqm = TaskQueueManager(inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=self.passwords) + + # Note: We run this here to cache whether the default ansible ssh + # executable supports control persist. Sometime in the future we may + # need to enhance this to check that ansible_ssh_executable specified + # in inventory is also cached. We can't do this caching at the point + # where it is used (in task_executor) because that is post-fork and + # therefore would be discarded after every task. + check_for_controlpersist(C.ANSIBLE_SSH_EXECUTABLE) + + def run(self): + ''' + Run the given playbook, based on the settings in the play which + may limit the runs to serialized groups, etc. + ''' + + result = 0 + entrylist = [] + entry = {} + try: + for playbook_path in self._playbooks: + pb = Playbook.load(playbook_path, variable_manager=self._variable_manager, loader=self._loader) + # FIXME: move out of inventory self._inventory.set_playbook_basedir(os.path.realpath(os.path.dirname(playbook_path))) + + if self._tqm is None: # we are doing a listing + entry = {'playbook': playbook_path} + entry['plays'] = [] + else: + # make sure the tqm has callbacks loaded + self._tqm.load_callbacks() + self._tqm.send_callback('v2_playbook_on_start', pb) + + i = 1 + plays = pb.get_plays() + display.vv(u'%d plays in %s' % (len(plays), to_text(playbook_path))) + + for play in plays: + if play._included_path is not None: + self._loader.set_basedir(play._included_path) + else: + self._loader.set_basedir(pb._basedir) + + # clear any filters which may have been applied to the inventory + self._inventory.remove_restriction() + + # Allow variables to be used in vars_prompt fields. + all_vars = self._variable_manager.get_vars(play=play) + templar = Templar(loader=self._loader, variables=all_vars) + setattr(play, 'vars_prompt', templar.template(play.vars_prompt)) + + if play.vars_prompt: + for var in play.vars_prompt: + vname = var['name'] + prompt = var.get("prompt", vname) + default = var.get("default", None) + private = boolean(var.get("private", True)) + confirm = boolean(var.get("confirm", False)) + encrypt = var.get("encrypt", None) + salt_size = var.get("salt_size", None) + salt = var.get("salt", None) + + if vname not in self._variable_manager.extra_vars: + if self._tqm: + self._tqm.send_callback('v2_playbook_on_vars_prompt', vname, private, prompt, encrypt, confirm, salt_size, salt, default) + play.vars[vname] = display.do_var_prompt(vname, private, prompt, encrypt, confirm, salt_size, salt, default) + else: # we are either in --list-