Initial commit

.github/workflows/collection-continuous-integration.yml

@@ -0,0 +1,308 @@
+name: Collection test suite
+
+on:
+  push:
+  pull_request:
+  schedule:
+  - cron: 3 0 * * *  # Run daily at 0:03 UTC
+
+jobs:
+  build-collection-artifact:
+    name: Build collection
+    runs-on: ${{ matrix.runner-os }}
+    strategy:
+      matrix:
+        runner-os:
+        - ubuntu-latest
+        ansible-version:
+        - git+https://github.com/ansible/ansible.git@devel
+        runner-python-version:
+        - 3.8
+    steps:
+    - name: Check out ${{ github.repository }} on disk
+      uses: actions/checkout@master
+    - name: Set up Python ${{ matrix.runner-python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.runner-python-version }}
+    - name: Set up pip cache
+      uses: actions/cache@v1
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('tests/sanity/requirements.txt') }}-${{ hashFiles('tests/unit/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          ${{ runner.os }}-
+    - name: Install Ansible ${{ matrix.ansible-version }}
+      run: >-
+        python -m
+        pip
+        install
+        --user
+        ${{ matrix.ansible-version }}
+    - name: Build a collection tarball
+      run: >-
+        ~/.local/bin/ansible-galaxy
+        collection
+        build
+        --output-path
+        "${GITHUB_WORKSPACE}/.cache/collection-tarballs"
+    - name: Store migrated collection artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: >-
+          collection
+        path: .cache/collection-tarballs
+
+  sanity-test-collection-via-vms:
+    name: Sanity in VM ${{ matrix.os.vm || 'ubuntu-latest' }}
+    needs:
+    - build-collection-artifact
+    runs-on: ${{ matrix.os.vm || 'ubuntu-latest' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ansible-version:
+        - git+https://github.com/ansible/ansible.git@devel
+        os:
+        - vm: ubuntu-latest
+        - vm: ubuntu-16.04
+        - vm: macos-latest
+        python-version:
+        - 3.8
+        - 3.7
+        - 3.6
+        - 3.5
+        - 2.7
+    steps:
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Set up pip cache
+      uses: actions/cache@v1
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ github.ref }}-sanity-VMs
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          ${{ runner.os }}-
+    - name: Install Ansible ${{ matrix.ansible-version }}
+      run: >-
+        python -m
+        pip
+        install
+        --user
+        ${{ matrix.ansible-version }}
+    - name: Download migrated collection artifacts
+      uses: actions/download-artifact@v1
+      with:
+        name: >-
+          collection
+        path: .cache/collection-tarballs
+    - name: Install the collection tarball
+      run: >-
+        ~/.local/bin/ansible-galaxy
+        collection
+        install
+        .cache/collection-tarballs/*.tar.gz
+    - name: Run collection sanity tests
+      run: >-
+        ~/.local/bin/ansible-test
+        sanity
+        --color
+        --requirements
+        --venv
+        --python
+        "${{ matrix.python-version }}"
+        -vvv
+      working-directory: >-
+        /${{ runner.os == 'Linux' && 'home' || 'Users' }}/runner/.ansible/collections/ansible_collections/community/general
+
+  sanity-test-collection-via-containers:
+    name: Sanity in container via Python ${{ matrix.python-version }}
+    needs:
+    - build-collection-artifact
+    runs-on: ${{ matrix.runner-os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        runner-os:
+        - ubuntu-latest
+        runner-python-version:
+        - 3.8
+        ansible-version:
+        - git+https://github.com/ansible/ansible.git@devel
+        python-version:
+        - 3.8
+        - 2.7
+        - 3.7
+        - 3.6
+        - 3.5
+        - 2.6
+    steps:
+    - name: Set up Python ${{ matrix.runner-python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.runner-python-version }}
+    - name: Set up pip cache
+      uses: actions/cache@v1
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ github.ref }}-sanity-containers
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          ${{ runner.os }}-
+    - name: Install Ansible ${{ matrix.ansible-version }}
+      run: >-
+        python -m
+        pip
+        install
+        --user
+        ${{ matrix.ansible-version }}
+    - name: Download migrated collection artifacts
+      uses: actions/download-artifact@v1
+      with:
+        name: >-
+          collection
+        path: .cache/collection-tarballs
+    - name: Install the collection tarball
+      run: >-
+        ~/.local/bin/ansible-galaxy
+        collection
+        install
+        .cache/collection-tarballs/*.tar.gz
+    - name: Run collection sanity tests
+      run: >-
+        ~/.local/bin/ansible-test
+        sanity
+        --color
+        --requirements
+        --docker
+        --python
+        "${{ matrix.python-version }}"
+        -vvv
+      working-directory: >-
+        /home/runner/.ansible/collections/ansible_collections/community/general
+
+  unit-test-collection-via-vms:
+    name: Units in VM ${{ matrix.os.vm || 'ubuntu-latest' }}
+    needs:
+    - build-collection-artifact
+    runs-on: ${{ matrix.os.vm || 'ubuntu-latest' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ansible-version:
+        - git+https://github.com/ansible/ansible.git@devel
+        os:
+        - vm: ubuntu-latest
+        - vm: ubuntu-16.04
+        - vm: macos-latest
+        python-version:
+        - 3.8
+        - 3.7
+        - 3.6
+        - 3.5
+        - 2.7
+    steps:
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Set up pip cache
+      uses: actions/cache@v1
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ github.ref }}-units-VMs
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          ${{ runner.os }}-
+    - name: Install Ansible ${{ matrix.ansible-version }}
+      run: >-
+        python -m
+        pip
+        install
+        --user
+        ${{ matrix.ansible-version }}
+    - name: Download migrated collection artifacts
+      uses: actions/download-artifact@v1
+      with:
+        name: >-
+          collection
+        path: .cache/collection-tarballs
+    - name: Install the collection tarball
+      run: >-
+        ~/.local/bin/ansible-galaxy
+        collection
+        install
+        .cache/collection-tarballs/*.tar.gz
+    - name: Run collection unit tests
+      run: |
+        [[ ! -d 'tests/unit' ]] && echo This collection does not have unit tests. Skipping... || \
+        ~/.local/bin/ansible-test units --color --coverage --requirements --venv --python "${{ matrix.python-version }}" -vvv
+      working-directory: >-
+        /${{ runner.os == 'Linux' && 'home' || 'Users' }}/runner/.ansible/collections/ansible_collections/community/general
+
+  unit-test-collection-via-containers:
+    name: Units in container ${{ matrix.container-image }}
+    needs:
+    - build-collection-artifact
+    runs-on: ${{ matrix.runner-os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        runner-os:
+        - ubuntu-latest
+        runner-python-version:
+        - 3.8
+        ansible-version:
+        - git+https://github.com/ansible/ansible.git@devel
+        container-image:
+        - fedora31
+        - ubuntu1804
+        - centos8
+        - opensuse15
+        - fedora30
+        - centos7
+        - opensuse15py2
+        - ubuntu1604
+        - centos6
+    steps:
+    - name: Set up Python ${{ matrix.runner-python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.runner-python-version }}
+    - name: Set up pip cache
+      uses: actions/cache@v1
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ github.ref }}-units-containers
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          ${{ runner.os }}-
+    - name: Install Ansible ${{ matrix.ansible-version }}
+      run: >-
+        python -m
+        pip
+        install
+        --user
+        ${{ matrix.ansible-version }}
+    - name: Download migrated collection artifacts
+      uses: actions/download-artifact@v1
+      with:
+        name: >-
+          collection
+        path: .cache/collection-tarballs
+    - name: Install the collection tarball
+      run: >-
+        ~/.local/bin/ansible-galaxy
+        collection
+        install
+        .cache/collection-tarballs/*.tar.gz
+    - name: Run collection unit tests
+      run: |
+        [[ ! -d 'tests/unit' ]] && echo This collection does not have unit tests. Skipping... || \
+        ~/.local/bin/ansible-test units --color --coverage --requirements --docker "${{ matrix.container-image }}" -vvv
+      working-directory: >-
+        /home/runner/.ansible/collections/ansible_collections/community/general

.gitignore

@@ -0,0 +1,387 @@
+
+# Created by https://www.gitignore.io/api/git,linux,pydev,python,windows,pycharm+all,jupyternotebook,vim,webstorm,emacs,dotenv
+# Edit at https://www.gitignore.io/?templates=git,linux,pydev,python,windows,pycharm+all,jupyternotebook,vim,webstorm,emacs,dotenv
+
+### dotenv ###
+.env
+
+### Emacs ###
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# Org-mode
+.org-id-locations
+*_archive
+
+# flymake-mode
+*_flymake.*
+
+# eshell files
+/eshell/history
+/eshell/lastdir
+
+# elpa packages
+/elpa/
+
+# reftex files
+*.rel
+
+# AUCTeX auto folder
+/auto/
+
+# cask packages
+.cask/
+dist/
+
+# Flycheck
+flycheck_*.el
+
+# server auth directory
+/server/
+
+# projectiles files
+.projectile
+
+# directory configuration
+.dir-locals.el
+
+# network security
+/network-security.data
+
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+#!! ERROR: jupyternotebook is undefined. Use list command to see defined gitignore types !!#
+
+### Linux ###
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### PyCharm+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### PyCharm+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+.idea/
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### pydev ###
+.pydevproject
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# Mr Developer
+.mr.developer.cfg
+.project
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+### Vim ###
+# Swap
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# Session
+Session.vim
+Sessionx.vim
+
+# Temporary
+.netrwhist
+# Auto-generated tag files
+tags
+# Persistent undo
+[._]*.un~
+
+### WebStorm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+
+# Generated files
+
+# Sensitive or high-churn files
+
+# Gradle
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+
+# Mongo Explorer plugin
+
+# File-based project format
+
+# IntelliJ
+
+# mpeltonen/sbt-idea plugin
+
+# JIRA plugin
+
+# Cursive Clojure plugin
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+
+# Editor-based Rest Client
+
+# Android studio 3.1+ serialized cache file
+
+### WebStorm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator/
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.gitignore.io/api/git,linux,pydev,python,windows,pycharm+all,jupyternotebook,vim,webstorm,emacs,dotenv

COPYING

@@ -0,0 +1,675 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ 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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 <http://www.gnu.org/licenses/>.
+
+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:
+
+    <program>  Copyright (C) <year>  <name of author>
+    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
+<http://www.gnu.org/licenses/>.
+
+  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
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+

README.md

@@ -0,0 +1,4 @@
+[![GitHub Actions CI/CD build status — Collection test suite](https://github.com/ansible-collection-migration/community.general/workflows/Collection%20test%20suite/badge.svg?branch=master)](https://github.com/ansible-collection-migration/community.general/actions?query=workflow%3A%22Collection%20test%20suite%22)
+
+Ansible Collection: community.general
+=================================================

galaxy.yml

@@ -0,0 +1,28 @@
+namespace: community
+name: general
+version: 0.1.0
+readme: README.md
+authors: null
+description: null
+license: GPL-3.0-or-later
+license_file: COPYING
+tags: null
+dependencies:
+  netapp.ontap: '>=0.1.0'
+  community.kubernetes: '>=0.1.0'
+  ovirt.ovirt: '>=0.1.0'
+  ansible.netcommon: '>=0.1.0'
+  cisco.mso: '>=0.1.0'
+  ansible.posix: '>=0.1.0'
+  cisco.aci: '>=0.1.0'
+  cisco.intersight: '>=0.1.0'
+  check_point.mgmt: '>=0.1.0'
+  fortinet.fortios: '>=0.1.0'
+  openstack.cloud: '>=0.1.0'
+  google.cloud: '>=0.1.0'
+  f5networks.f5_modules: '>=0.1.0'
+repository: git@github.com:ansible-collection-migration/community.general.git
+documentation: https://github.com/ansible-collection-migration/community.general/tree/master/docs
+homepage: https://github.com/ansible-collection-migration/community.general
+issues: https://github.com/ansible-collection-migration/community.general/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc
+type: flatmap

meta/action_groups.yml

@@ -0,0 +1,66 @@
+docker:
+- docker_swarm
+- docker_image_facts
+- docker_service
+- docker_compose
+- docker_config
+- docker_container
+- docker_container_info
+- docker_host_info
+- docker_image
+- docker_image_info
+- docker_login
+- docker_network
+- docker_network_info
+- docker_node
+- docker_node_info
+- docker_prune
+- docker_secret
+- docker_swarm
+- docker_swarm_info
+- docker_swarm_service
+- docker_swarm_service_info
+- docker_volume
+- docker_volume_info
+k8s:
+- kubevirt_cdi_upload
+- kubevirt_preset
+- kubevirt_pvc
+- kubevirt_rs
+- kubevirt_template
+- kubevirt_vm
+os:
+- os_flavor_facts
+- os_image_facts
+- os_keystone_domain_facts
+- os_networks_facts
+- os_port_facts
+- os_project_facts
+- os_server_facts
+- os_subnets_facts
+- os_user_facts
+ovirt:
+- ovirt_affinity_label_facts
+- ovirt_api_facts
+- ovirt_cluster_facts
+- ovirt_datacenter_facts
+- ovirt_disk_facts
+- ovirt_event_facts
+- ovirt_external_provider_facts
+- ovirt_group_facts
+- ovirt_host_facts
+- ovirt_host_storage_facts
+- ovirt_network_facts
+- ovirt_nic_facts
+- ovirt_permission_facts
+- ovirt_quota_facts
+- ovirt_scheduling_policy_facts
+- ovirt_snapshot_facts
+- ovirt_storage_domain_facts
+- ovirt_storage_template_facts
+- ovirt_storage_vm_facts
+- ovirt_tag_facts
+- ovirt_template_facts
+- ovirt_user_facts
+- ovirt_vm_facts
+- ovirt_vmpool_facts

meta/routing.yml

@@ -0,0 +1,962 @@
+plugin_routing:
+  modules:
+    ali_instance_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    cs_instance_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    cs_zone_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_account_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_certificate_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_domain_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_firewall_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_floating_ip_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_load_balancer_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_region_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_size_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_snapshot_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_sshkey_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_tag_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    digital_ocean_volume_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    docker_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    docker_service:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcdns_record:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcdns_zone:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gce:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_backend_service:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_bigquery_dataset_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_bigquery_table_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_cloudbuild_trigger_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_address_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_backend_bucket_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_backend_service_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_disk_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_firewall_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_forwarding_rule_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_global_address_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_global_forwarding_rule_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_health_check_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_http_health_check_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_https_health_check_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_instance_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_instance_group_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_instance_group_manager_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_instance_template_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_interconnect_attachment_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_network_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_region_disk_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_route_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_router_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_ssl_certificate_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_ssl_policy_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_subnetwork_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_target_http_proxy_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_target_https_proxy_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_target_pool_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_target_ssl_proxy_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_target_tcp_proxy_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_target_vpn_gateway_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_url_map_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_compute_vpn_tunnel_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_container_cluster_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_container_node_pool_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_dns_managed_zone_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_dns_resource_record_set_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_forwarding_rule:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_healthcheck:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_iam_role_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_iam_service_account_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_pubsub_subscription_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_pubsub_topic_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_redis_instance_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_resourcemanager_project_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_sourcerepo_repository_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_spanner_database_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_spanner_instance_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_sql_database_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_sql_instance_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_sql_user_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_target_proxy:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_tpu_node_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcp_url_map:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcpubsub_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gcspanner:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    memset_memstore_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    memset_server_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    online_server_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    online_user_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    one_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_flavor_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_keystone_domain_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_networks_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_port_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_project_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_server_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_subnets_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    os_user_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_affinity_label_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_api_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_cluster_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_datacenter_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_disk_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_event_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_external_provider_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_group_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_host_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_host_storage_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_network_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_nic_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_permission_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_quota_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_scheduling_policy_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_snapshot_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_storage_domain_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_storage_template_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_storage_vm_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_tag_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_template_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_user_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_vm_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ovirt_vmpool_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_ip_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_organization_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_security_group_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_server_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_snapshot_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    scaleway_volume_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    smartos_image_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_account_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_dns_domain:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_dns_record:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_firewall_group:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_firewall_rule:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_server:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_ssh_key:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_startup_script:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vr_user:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_account_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_block_storage_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_dns_domain_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_firewall_group_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_network_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_os_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_plan_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_region_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_server_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_ssh_key_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_startup_script_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vultr_user_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    xenserver_guest_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    vertica_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    onepassword_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    zabbix_group_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    zabbix_host_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    ldap_attr:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    aci_intf_policy_fc:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    aci_intf_policy_l2:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    aci_intf_policy_lldp:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    aci_intf_policy_mcp:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    aci_intf_policy_port_channel:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    aci_intf_policy_port_security:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_asm_policy:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_device_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_gtm_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_iapplx_package:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_security_address_list:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_security_port_list:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigip_traffic_group:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    bigiq_device_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_cluster:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_ospf:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_ospfarea:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_show:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_trunk:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_vlag:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_vlan:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_vrouter:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_vrouterbgp:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_vrouterif:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    pn_vrouterlbif:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_admin:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_admpwd:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_cert_gen_ssh:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_check:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_commit:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_dag:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_dag_tags:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_import:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_interface:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_lic:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_loadcfg:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_match_rule:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_mgtconfig:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_nat_rule:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_object:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_op:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_pg:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_query_rules:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_restart:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_sag:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_security_rule:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    panos_set:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    osx_say:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    foreman:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    katello:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    hpilo_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_datacenter_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_enclosure_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_ethernet_network_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_fc_network_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_fcoe_network_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_logical_interconnect_group_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_network_set_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    oneview_san_manager_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    idrac_redfish_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    redfish_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    github_hooks:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    github_webhook_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gitlab_hooks:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    gluster_heal_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_aggregate:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_license:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_lun:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_qtree:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_svm:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_user:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_user_role:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_cdot_volume:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    na_ontap_gather_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    sf_account_manager:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    sf_check_connections:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    sf_snapshot_schedule_manager:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    sf_volume_access_group_manager:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    sf_volume_manager:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    purefa_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    purefb_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    python_requirements_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    jenkins_job_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details
+    nginx_status_facts:
+      deprecation:
+        removal_date: TBD
+        warning_text: see plugin documentation for details

plugins/action/aireos.py

@@ -0,0 +1,79 @@
+#
+# (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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import sys
+import copy
+
+from ansible import constants as C
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.community.general.plugins.module_utils.network.aireos.aireos import aireos_provider_spec
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'aireos_config' else False
+
+        if self._play_context.connection != 'local':
+            return dict(
+                failed=True,
+                msg='invalid connection specified, expected connection=local, '
+                    'got %s' % self._play_context.connection
+            )
+
+        provider = load_provider(aireos_provider_spec, self._task.args)
+
+        pc = copy.deepcopy(self._play_context)
+        pc.connection = 'network_cli'
+        pc.network_os = 'aireos'
+        pc.remote_addr = provider['host'] or self._play_context.remote_addr
+        pc.port = int(provider['port'] or self._play_context.port or 22)
+        pc.remote_user = provider['username'] or self._play_context.connection_user
+        pc.password = provider['password'] or self._play_context.password
+        command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
+
+        display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+        connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+        connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+        socket_path = connection.run()
+        display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+        if not socket_path:
+            return {'failed': True,
+                    'msg': 'unable to open shell. Please see: ' +
+                           'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+        task_vars['ansible_socket'] = socket_path
+
+        if self._play_context.become_method == 'enable':
+            self._play_context.become = False
+            self._play_context.become_method = None
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+
+        return result

plugins/action/aruba.py

@@ -0,0 +1,79 @@
+#
+# (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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import sys
+import copy
+
+from ansible import constants as C
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.community.general.plugins.module_utils.network.aruba.aruba import aruba_provider_spec
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'aruba_config' else False
+
+        if self._play_context.connection != 'local':
+            return dict(
+                failed=True,
+                msg='invalid connection specified, expected connection=local, '
+                    'got %s' % self._play_context.connection
+            )
+
+        provider = load_provider(aruba_provider_spec, self._task.args)
+
+        pc = copy.deepcopy(self._play_context)
+        pc.connection = 'network_cli'
+        pc.network_os = 'aruba'
+        pc.remote_addr = provider['host'] or self._play_context.remote_addr
+        pc.port = int(provider['port'] or self._play_context.port or 22)
+        pc.remote_user = provider['username'] or self._play_context.connection_user
+        pc.password = provider['password'] or self._play_context.password
+        pc.private_key_file = provider['ssh_keyfile'] or self._play_context.private_key_file
+        command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
+
+        display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+        connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+        connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+        socket_path = connection.run()
+        display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+        if not socket_path:
+            return {'failed': True,
+                    'msg': 'unable to open shell. Please see: ' +
+                           'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+        task_vars['ansible_socket'] = socket_path
+
+        if self._play_context.become_method == 'enable':
+            self._play_context.become = False
+            self._play_context.become_method = None
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+        return result

plugins/action/ce.py

@@ -0,0 +1,89 @@
+#
+# Copyright: (c) 2016, Red Hat Inc.
+
+# 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 sys
+import copy
+
+from ansible import constants as C
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.community.general.plugins.module_utils.network.cloudengine.ce import ce_provider_spec
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible.utils.display import Display
+
+display = Display()
+
+CLI_SUPPORTED_MODULES = ['ce_rollback', 'ce_mlag_interface', 'ce_startup', 'ce_config',
+                         'ce_command', 'ce_facts', 'ce_evpn_global', 'ce_evpn_bgp_rr',
+                         'ce_mtu', 'ce_evpn_bgp', 'ce_snmp_location', 'ce_snmp_contact',
+                         'ce_snmp_traps', 'ce_netstream_global', 'ce_netstream_aging',
+                         'ce_netstream_export', 'ce_netstream_template', 'ce_ntp_auth',
+                         'ce_stp', 'ce_vxlan_global', 'ce_vxlan_arp', 'ce_vxlan_gateway',
+                         'ce_acl_interface']
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'ce_config' else False
+        socket_path = None
+        persistent_connection = self._play_context.connection.split('.')[-1]
+
+        if self._play_context.connection == 'local':
+            provider = load_provider(ce_provider_spec, self._task.args)
+            transport = provider['transport'] or 'cli'
+
+            display.vvvv('connection transport is %s' % transport, self._play_context.remote_addr)
+
+            if transport == 'cli':
+                pc = copy.deepcopy(self._play_context)
+                pc.connection = 'network_cli'
+                pc.network_os = 'ce'
+                pc.remote_addr = provider['host'] or self._play_context.remote_addr
+                pc.port = int(provider['port'] or self._play_context.port or 22)
+                pc.remote_user = provider['username'] or self._play_context.connection_user
+                pc.password = provider['password'] or self._play_context.password
+                command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
+                self._task.args['provider'] = provider.update(
+                    host=pc.remote_addr,
+                    port=pc.port,
+                    username=pc.remote_user,
+                    password=pc.password
+                )
+                if module_name in ['ce_netconf'] or module_name not in CLI_SUPPORTED_MODULES:
+                    pc.connection = 'netconf'
+                display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+                connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+                connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+                socket_path = connection.run()
+                display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+                if not socket_path:
+                    return {'failed': True,
+                            'msg': 'unable to open shell. Please see: ' +
+                                   'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+                task_vars['ansible_socket'] = socket_path
+                # make sure a transport value is set in args
+                self._task.args['transport'] = transport
+                self._task.args['provider'] = provider
+        elif persistent_connection in ('netconf', 'network_cli'):
+            provider = self._task.args.get('provider', {})
+            if any(provider.values()):
+                display.warning('provider is unnecessary when using %s and will be ignored' % self._play_context.connection)
+                del self._task.args['provider']
+
+            if (persistent_connection == 'network_cli' and module_name not in CLI_SUPPORTED_MODULES) or \
+                    (persistent_connection == 'netconf' and module_name in CLI_SUPPORTED_MODULES):
+                return {'failed': True, 'msg': "Connection type '%s' is not valid for '%s' module."
+                        % (self._play_context.connection, self._task.action)}
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+        return result

plugins/action/ce_template.py

@@ -0,0 +1,104 @@
+#
+# Copyright 2015 Peter Sprygada <psprygada@ansible.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+import time
+import glob
+from ansible.module_utils.six.moves.urllib.parse import urlsplit
+
+from ansible.module_utils._text import to_text
+from ansible_collections.community.general.plugins.action.ce import ActionModule as _ActionModule
+
+
+class ActionModule(_ActionModule):
+
+    def run(self, tmp=None, task_vars=None):
+
+        try:
+            self._handle_template()
+        except (ValueError, AttributeError) as exc:
+            return dict(failed=True, msg=exc.message)
+
+        result = super(ActionModule, self).run(tmp, task_vars)
+        del tmp  # tmp no longer has any effect
+
+        if self._task.args.get('backup') and result.get('__backup__'):
+            # User requested backup and no error occurred in module.
+            # NOTE: If there is a parameter error, __backup__ key may not be in results.
+            self._write_backup(task_vars['inventory_hostname'], result['__backup__'])
+
+        if '__backup__' in result:
+            del result['__backup__']
+
+        return result
+
+    def _get_working_path(self):
+        cwd = self._loader.get_basedir()
+        if self._task._role is not None:
+            cwd = self._task._role._role_path
+        return cwd
+
+    def _write_backup(self, host, contents):
+        backup_path = self._get_working_path() + '/backup'
+        if not os.path.exists(backup_path):
+            os.mkdir(backup_path)
+        for fn in glob.glob('%s/%s*' % (backup_path, host)):
+            os.remove(fn)
+        tstamp = time.strftime("%Y-%m-%d@%H:%M:%S", time.localtime(time.time()))
+        filename = '%s/%s_config.%s' % (backup_path, host, tstamp)
+        open(filename, 'w').write(contents)
+
+    def _handle_template(self):
+        src = self._task.args.get('src')
+        if not src:
+            raise ValueError('missing required arguments: src')
+
+        working_path = self._get_working_path()
+
+        if os.path.isabs(src) or urlsplit(src).scheme:
+            source = src
+        else:
+            source = self._loader.path_dwim_relative(working_path, 'templates', src)
+            if not source:
+                source = self._loader.path_dwim_relative(working_path, src)
+
+        if not os.path.exists(source):
+            return
+
+        try:
+            with open(source, 'r') as f:
+                template_data = to_text(f.read())
+        except IOError:
+            return dict(failed=True, msg='unable to load src file')
+
+        # Create a template search path in the following order:
+        # [working_path, self_role_path, dependent_role_paths, dirname(source)]
+        searchpath = [working_path]
+        if self._task._role is not None:
+            searchpath.append(self._task._role._role_path)
+            if hasattr(self._task, "_block:"):
+                dep_chain = self._task._block.get_dep_chain()
+                if dep_chain is not None:
+                    for role in dep_chain:
+                        searchpath.append(role._role_path)
+        searchpath.append(os.path.dirname(source))
+        with self._templar.set_temporary_context(searchpath=searchpath):
+            self._task.args['src'] = self._templar.template(template_data)

plugins/action/cnos.py

@@ -0,0 +1,69 @@
+# (C) 2017 Red Hat Inc.
+# Copyright (C) 2017 Lenovo.
+#
+# GNU General Public License v3.0+
+#
+# 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.
+#
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Contains Action Plugin methods for CNOS Config Module
+# Lenovo Networking
+#
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import sys
+import copy
+
+from ansible import constants as C
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.community.general.plugins.module_utils.network.cnos.cnos import cnos_provider_spec
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'cnos_config' else False
+
+        if self._play_context.connection == 'local':
+            provider = load_provider(cnos_provider_spec, self._task.args)
+            pc = copy.deepcopy(self._play_context)
+            pc.connection = 'network_cli'
+            pc.network_os = 'cnos'
+            pc.remote_addr = provider['host'] or self._play_context.remote_addr
+            pc.port = provider['port'] or self._play_context.port or 22
+            pc.remote_user = provider['username'] or self._play_context.connection_user
+            pc.password = provider['password'] or self._play_context.password
+            pc.private_key_file = provider['ssh_keyfile'] or self._play_context.private_key_file
+            command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
+            pc.become = provider['authorize'] or True
+            pc.become_pass = provider['auth_pass']
+            pc.become_method = 'enable'
+
+            display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+            connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+            connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+            socket_path = connection.run()
+            display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+            if not socket_path:
+                return {'failed': True,
+                        'msg': 'unable to open shell. Please see: ' +
+                               'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+            task_vars['ansible_socket'] = socket_path
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+        return result

plugins/action/edgeos_config.py

@@ -0,0 +1,36 @@
+#
+# Copyright 2018 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        self._config_module = True
+
+        if self._play_context.connection.split('.')[-1] != 'network_cli':
+            return {'failed': True, 'msg': 'Connection type %s is not valid for this module. Must use fully qualified'
+                                           ' name of network_cli connection type.' % self._play_context.connection}
+
+        return super(ActionModule, self).run(task_vars=task_vars)

plugins/action/enos.py

@@ -0,0 +1,69 @@
+# (C) 2017 Red Hat Inc.
+# Copyright (C) 2017 Lenovo.
+#
+# GNU General Public License v3.0+
+#
+# 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.
+#
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Contains Action Plugin methods for ENOS Config Module
+# Lenovo Networking
+#
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import sys
+import copy
+
+from ansible import constants as C
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.community.general.plugins.module_utils.network.enos.enos import enos_provider_spec
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'enos_config' else False
+
+        if self._play_context.connection == 'local':
+            provider = load_provider(enos_provider_spec, self._task.args)
+            pc = copy.deepcopy(self._play_context)
+            pc.connection = 'network_cli'
+            pc.network_os = 'enos'
+            pc.remote_addr = provider['host'] or self._play_context.remote_addr
+            pc.port = provider['port'] or self._play_context.port or 22
+            pc.remote_user = provider['username'] or self._play_context.connection_user
+            pc.password = provider['password'] or self._play_context.password
+            pc.private_key_file = provider['ssh_keyfile'] or self._play_context.private_key_file
+            command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
+            pc.become = provider['authorize'] or True
+            pc.become_pass = provider['auth_pass']
+            pc.become_method = 'enable'
+
+            display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+            connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+            connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+            socket_path = connection.run()
+            display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+            if not socket_path:
+                return {'failed': True,
+                        'msg': 'unable to open shell. Please see: ' +
+                               'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+            task_vars['ansible_socket'] = socket_path
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+        return result

plugins/action/exos.py

@@ -0,0 +1,45 @@
+#
+# Copyright 2015 Peter Sprygada <psprygada@ansible.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+
+
+class ActionModule(ActionNetworkModule):
+
+    EXOS_NETWORK_CLI_MODULES = (
+        'exos_facts',
+        'exos_config',
+        'exos_command')
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'exos_config' else False
+        persistent_connection = self._play_context.connection.split('.')[-1]
+
+        if persistent_connection not in ('network_cli', 'httpapi'):
+            return {'failed': True, 'msg': 'Connection type %s is not valid for this module' % self._play_context.connection}
+
+        if persistent_connection == 'network_cli' and module_name not in self.EXOS_NETWORK_CLI_MODULES:
+            return {'failed': True, 'msg': "Connection type %s is not valid for this module" % self._play_context.connection}
+
+        return super(ActionModule, self).run(task_vars=task_vars)

plugins/action/ironware.py

@@ -0,0 +1,80 @@
+#
+# (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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import sys
+import copy
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible_collections.community.general.plugins.module_utils.network.ironware.ironware import ironware_provider_spec
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'ironware_config' else False
+        persistent_connection = self._play_context.connection.split('.')[-1]
+
+        if persistent_connection == 'network_cli':
+            provider = self._task.args.get('provider', {})
+            if any(provider.values()):
+                display.warning('provider is unnecessary when using network_cli and will be ignored')
+                del self._task.args['provider']
+        elif self._play_context.connection == 'local':
+            provider = load_provider(ironware_provider_spec, self._task.args)
+            pc = copy.deepcopy(self._play_context)
+            pc.connection = 'network_cli'
+            pc.network_os = 'ironware'
+            pc.remote_addr = provider['host'] or self._play_context.remote_addr
+            pc.port = int(provider['port'] or self._play_context.port or 22)
+            pc.remote_user = provider['username'] or self._play_context.connection_user
+            pc.password = provider['password'] or self._play_context.password
+            pc.private_key_file = provider['ssh_keyfile'] or self._play_context.private_key_file
+            pc.become = provider['authorize'] or False
+            if pc.become:
+                pc.become_method = 'enable'
+            pc.become_pass = provider['auth_pass']
+
+            display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+            connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+
+            command_timeout = int(provider['timeout']) if provider['timeout'] else connection.get_option('persistent_command_timeout')
+            connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+            socket_path = connection.run()
+            display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+            if not socket_path:
+                return {'failed': True,
+                        'msg': 'unable to open shell. Please see: ' +
+                               'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+            task_vars['ansible_socket'] = socket_path
+        else:
+            return {'failed': True, 'msg': 'Connection type %s is not valid for this module' % self._play_context.connection}
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+        return result

plugins/action/nos_config.py

@@ -0,0 +1,31 @@
+#
+# (c) 2018 Extreme Networks 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        self._config_module = True
+        return super(ActionModule, self).run(task_vars=task_vars)

plugins/action/onyx_config.py

@@ -0,0 +1,31 @@
+#
+# (c) 2017, 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        self._config_module = True
+        return super(ActionModule, self).run(task_vars=task_vars)

plugins/action/slxos.py

@@ -0,0 +1,40 @@
+#
+# (c) 2018 Extreme Networks 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import re
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+
+PRIVATE_KEYS_RE = re.compile('__.+__')
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'slxos_config' else False
+        persistent_connection = self._play_context.connection.split('.')[-1]
+
+        if persistent_connection not in ('network_cli'):
+            return {'failed': True, 'msg': 'Connection type %s is not valid for this module' % self._play_context.connection}
+        return super(ActionModule, self).run(task_vars=task_vars)

plugins/action/sros.py

@@ -0,0 +1,77 @@
+#
+# (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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import sys
+import copy
+
+from ansible import constants as C
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+from ansible_collections.community.general.plugins.module_utils.network.sros.sros import sros_provider_spec
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import load_provider
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        persistent_connection = self._play_context.connection.split('.')[-1]
+
+        self._config_module = True if module_name == 'sros_config' else False
+        if persistent_connection == 'network_cli':
+            provider = self._task.args.get('provider', {})
+            if any(provider.values()):
+                display.warning('provider is unnecessary when using network_cli and will be ignored')
+                del self._task.args['provider']
+        elif self._play_context.connection == 'local':
+            provider = load_provider(sros_provider_spec, self._task.args)
+
+            pc = copy.deepcopy(self._play_context)
+            pc.connection = 'network_cli'
+            pc.network_os = 'sros'
+            pc.remote_addr = provider['host'] or self._play_context.remote_addr
+            pc.port = int(provider['port'] or self._play_context.port or 22)
+            pc.remote_user = provider['username'] or self._play_context.connection_user
+            pc.password = provider['password'] or self._play_context.password
+            pc.private_key_file = provider['ssh_keyfile'] or self._play_context.private_key_file
+            command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
+
+            display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
+            connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin, task_uuid=self._task._uuid)
+            connection.set_options(direct={'persistent_command_timeout': command_timeout})
+
+            socket_path = connection.run()
+            display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
+            if not socket_path:
+                return {'failed': True,
+                        'msg': 'unable to open shell. Please see: ' +
+                        'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}
+
+            task_vars['ansible_socket'] = socket_path
+        else:
+            return {'failed': True, 'msg': 'Connection type %s is not valid for this module' % self._play_context.connection}
+
+        result = super(ActionModule, self).run(task_vars=task_vars)
+        return result

plugins/action/voss.py

@@ -0,0 +1,36 @@
+#
+# (c) 2018 Extreme Networks 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible_collections.ansible.netcommon.plugins.action.network import ActionModule as ActionNetworkModule
+
+
+class ActionModule(ActionNetworkModule):
+
+    def run(self, tmp=None, task_vars=None):
+        del tmp  # tmp no longer has any effect
+
+        module_name = self._task.action.split('.')[-1]
+        self._config_module = True if module_name == 'voss_config' else False
+        persistent_connection = self._play_context.connection.split('.')[-1]
+
+        if persistent_connection not in ('network_cli'):
+            return {'failed': True, 'msg': 'Connection type %s is not valid for this module' % self._play_context.connection}
+        return super(ActionModule, self).run(task_vars=task_vars)

plugins/become/doas.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: doas
+    short_description: Do As user
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the doas utility.
+    author: ansible (@core)
+    options:
+        become_user:
+            description: User you 'become' to execute the task
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: doas_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_doas_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_DOAS_USER
+        become_exe:
+            description: Doas executable
+            default: doas
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: doas_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_doas_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_DOAS_EXE
+        become_flags:
+            description: Options to pass to doas
+            default:
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: doas_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_doas_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_DOAS_FLAGS
+        become_pass:
+            description: password for doas prompt
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_doas_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_DOAS_PASS
+            ini:
+              - section: doas_become_plugin
+                key: password
+        prompt_l10n:
+            description:
+                - List of localized strings to match for prompt detection
+                - If empty we'll use the built in one
+            default: []
+            ini:
+              - section: doas_become_plugin
+                key: localized_prompts
+            vars:
+              - name: ansible_doas_prompt_l10n
+            env:
+              - name: ANSIBLE_DOAS_PROMPT_L10N
+'''
+
+import re
+
+from ansible.module_utils._text import to_bytes
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.doas'
+
+    # messages for detecting prompted password issues
+    fail = ('Permission denied',)
+    missing = ('Authorization required',)
+
+    def check_password_prompt(self, b_output):
+        ''' checks if the expected password prompt exists in b_output '''
+
+        # FIXME: more accurate would be: 'doas (%s@' % remote_user
+        # however become plugins don't have that information currently
+        b_prompts = [to_bytes(p) for p in self.get_option('prompt_l10n')] or [br'doas \(', br'Password:']
+        b_prompt = b"|".join(b_prompts)
+
+        return bool(re.match(b_prompt, b_output))
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        self.prompt = True
+
+        become_exe = self.get_option('become_exe') or self.name
+
+        flags = self.get_option('become_flags') or ''
+        if not self.get_option('become_pass') and '-n' not in flags:
+            flags += ' -n'
+
+        user = self.get_option('become_user') or ''
+        if user:
+            user = '-u %s' % (user)
+
+        success_cmd = self._build_success_command(cmd, shell, noexe=True)
+        executable = getattr(shell, 'executable', shell.SHELL_FAMILY)
+
+        return '%s %s %s %s -c %s' % (become_exe, flags, user, executable, success_cmd)

plugins/become/dzdo.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: dzdo
+    short_description: Centrify's Direct Authorize
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the dzdo utility.
+    author: ansible (@core)
+    options:
+        become_user:
+            description: User you 'become' to execute the task
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: dzdo_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_dzdo_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_DZDO_USER
+        become_exe:
+            description: Dzdo executable
+            default: dzdo
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: dzdo_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_dzdo_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_DZDO_EXE
+        become_flags:
+            description: Options to pass to dzdo
+            default: -H -S -n
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: dzdo_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_dzdo_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_DZDO_FLAGS
+        become_pass:
+            description: Options to pass to dzdo
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_dzdo_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_DZDO_PASS
+            ini:
+              - section: dzdo_become_plugin
+                key: password
+'''
+
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.dzdo'
+
+    # messages for detecting prompted password issues
+    fail = ('Sorry, try again.',)
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        becomecmd = self.get_option('become_exe') or self.name
+
+        flags = self.get_option('become_flags') or ''
+        if self.get_option('become_pass'):
+            self.prompt = '[dzdo via ansible, key=%s] password:' % self._id
+            flags = '%s -p "%s"' % (flags.replace('-n', ''), self.prompt)
+
+        user = self.get_option('become_user') or ''
+        if user:
+            user = '-u %s' % (user)
+
+        return ' '.join([becomecmd, flags, user, self._build_success_command(cmd, shell)])

plugins/become/ksu.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: ksu
+    short_description: Kerberos substitute user
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the ksu utility.
+    author: ansible (@core)
+    options:
+        become_user:
+            description: User you 'become' to execute the task
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: ksu_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_ksu_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_KSU_USER
+            required: True
+        become_exe:
+            description: Su executable
+            default: ksu
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: ksu_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_ksu_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_KSU_EXE
+        become_flags:
+            description: Options to pass to ksu
+            default: ''
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: ksu_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_ksu_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_KSU_FLAGS
+        become_pass:
+            description: ksu password
+            required: False
+            vars:
+              - name: ansible_ksu_pass
+              - name: ansible_become_pass
+              - name: ansible_become_password
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_KSU_PASS
+            ini:
+              - section: ksu_become_plugin
+                key: password
+        prompt_l10n:
+            description:
+                - List of localized strings to match for prompt detection
+                - If empty we'll use the built in one
+            default: []
+            ini:
+              - section: ksu_become_plugin
+                key: localized_prompts
+            vars:
+              - name: ansible_ksu_prompt_l10n
+            env:
+              - name: ANSIBLE_KSU_PROMPT_L10N
+'''
+
+import re
+
+from ansible.module_utils._text import to_bytes
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.ksu'
+
+    # messages for detecting prompted password issues
+    fail = ('Password incorrect',)
+    missing = ('No password given',)
+
+    def check_password_prompt(self, b_output):
+        ''' checks if the expected password prompt exists in b_output '''
+
+        prompts = self.get_option('prompt_l10n') or ["Kerberos password for .*@.*:"]
+        b_prompt = b"|".join(to_bytes(p) for p in prompts)
+
+        return bool(re.match(b_prompt, b_output))
+
+    def build_become_command(self, cmd, shell):
+
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        # Prompt handling for ``ksu`` is more complicated, this
+        # is used to satisfy the connection plugin
+        self.prompt = True
+
+        if not cmd:
+            return cmd
+
+        exe = self.get_option('become_exe') or self.name
+        flags = self.get_option('become_flags') or ''
+        user = self.get_option('become_user') or ''
+        return '%s %s %s -e %s ' % (exe, user, flags, self._build_success_command(cmd, shell))

plugins/become/machinectl.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: machinectl
+    short_description: Systemd's machinectl privilege escalation
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the machinectl utility.
+    author: ansible (@core)
+    options:
+        become_user:
+            description: User you 'become' to execute the task
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: machinectl_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_machinectl_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_MACHINECTL_USER
+        become_exe:
+            description: Machinectl executable
+            default: machinectl
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: machinectl_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_machinectl_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_MACHINECTL_EXE
+        become_flags:
+            description: Options to pass to machinectl
+            default: ''
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: machinectl_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_machinectl_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_MACHINECTL_FLAGS
+        become_pass:
+            description: Password for machinectl
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_machinectl_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_MACHINECTL_PASS
+            ini:
+              - section: machinectl_become_plugin
+                key: password
+'''
+
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.machinectl'
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        become = self.get_option('become_exe') or self.name
+        flags = self.get_option('become_flags') or ''
+        user = self.get_option('become_user') or ''
+        return '%s -q shell %s %s@ %s' % (become, flags, user, cmd)

plugins/become/pbrun.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: pbrun
+    short_description: PowerBroker run
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the pbrun utility.
+    author: ansible (@core)
+    options:
+        become_user:
+            description: User you 'become' to execute the task
+            default: ''
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: pbrun_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_pbrun_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_PBRUN_USER
+        become_exe:
+            description: Sudo executable
+            default: pbrun
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: pbrun_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_pbrun_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_PBRUN_EXE
+        become_flags:
+            description: Options to pass to pbrun
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: pbrun_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_pbrun_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_PBRUN_FLAGS
+        become_pass:
+            description: Password for pbrun
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_pbrun_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_PBRUN_PASS
+            ini:
+              - section: pbrun_become_plugin
+                key: password
+        wrap_exe:
+            description: Toggle to wrap the command pbrun calls in 'shell -c' or not
+            default: False
+            type: bool
+            ini:
+              - section: pbrun_become_plugin
+                key: wrap_execution
+            vars:
+              - name: ansible_pbrun_wrap_execution
+            env:
+              - name: ANSIBLE_PBRUN_WRAP_EXECUTION
+'''
+
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.pbrun'
+
+    prompt = 'Password:'
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        become_exe = self.get_option('become_exe') or self.name
+        flags = self.get_option('become_flags') or ''
+        user = self.get_option('become_user') or ''
+        if user:
+            user = '-u %s' % (user)
+        noexe = not self.get_option('wrap_exe')
+
+        return ' '.join([become_exe, flags, user, self._build_success_command(cmd, shell, noexe=noexe)])

plugins/become/pfexec.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: pfexec
+    short_description: profile based execution
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the pfexec utility.
+    author: ansible (@core)
+    options:
+        become_user:
+            description:
+                - User you 'become' to execute the task
+                - This plugin ignores this setting as pfexec uses it's own ``exec_attr`` to figure this out,
+                  but it is supplied here for Ansible to make decisions needed for the task execution, like file permissions.
+            default: root
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: pfexec_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_pfexec_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_PFEXEC_USER
+        become_exe:
+            description: Sudo executable
+            default: pfexec
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: pfexec_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_pfexec_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_PFEXEC_EXE
+        become_flags:
+            description: Options to pass to pfexec
+            default: -H -S -n
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: pfexec_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_pfexec_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_PFEXEC_FLAGS
+        become_pass:
+            description: pfexec password
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_pfexec_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_PFEXEC_PASS
+            ini:
+              - section: pfexec_become_plugin
+                key: password
+        wrap_exe:
+            description: Toggle to wrap the command pfexec calls in 'shell -c' or not
+            default: False
+            type: bool
+            ini:
+              - section: pfexec_become_plugin
+                key: wrap_execution
+            vars:
+              - name: ansible_pfexec_wrap_execution
+            env:
+              - name: ANSIBLE_PFEXEC_WRAP_EXECUTION
+    note:
+      - This plugin ignores ``become_user`` as pfexec uses it's own ``exec_attr`` to figure this out.
+'''
+
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.pfexec'
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        exe = self.get_option('become_exe') or self.name
+        flags = self.get_option('become_flags')
+        noexe = not self.get_option('wrap_exe')
+        return '%s %s "%s"' % (exe, flags, self._build_success_command(cmd, shell, noexe=noexe))

plugins/become/pmrun.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: pmrun
+    short_description: Privilege Manager run
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the pmrun utility.
+    author: ansible (@core)
+    options:
+        become_exe:
+            description: Sudo executable
+            default: pmrun
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: pmrun_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_pmrun_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_PMRUN_EXE
+        become_flags:
+            description: Options to pass to pmrun
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: pmrun_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_pmrun_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_PMRUN_FLAGS
+        become_pass:
+            description: pmrun password
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_pmrun_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_PMRUN_PASS
+            ini:
+              - section: pmrun_become_plugin
+                key: password
+    notes:
+      - This plugin ignores the become_user supplied and uses pmrun's own configuration to select the user.
+'''
+
+from ansible.plugins.become import BecomeBase
+from ansible.module_utils.six.moves import shlex_quote
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.pmrun'
+    prompt = 'Enter UPM user password:'
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        become = self.get_option('become_exe') or self.name
+        flags = self.get_option('become_flags') or ''
+        return '%s %s %s' % (become, flags, shlex_quote(self._build_success_command(cmd, shell)))

plugins/become/sesu.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+    become: sesu
+    short_description: CA Privileged Access Manager
+    description:
+        - This become plugins allows your remote/login user to execute commands as another user via the sesu utility.
+    author: ansible (@nekonyuu)
+    options:
+        become_user:
+            description: User you 'become' to execute the task
+            ini:
+              - section: privilege_escalation
+                key: become_user
+              - section: sesu_become_plugin
+                key: user
+            vars:
+              - name: ansible_become_user
+              - name: ansible_sesu_user
+            env:
+              - name: ANSIBLE_BECOME_USER
+              - name: ANSIBLE_SESU_USER
+        become_exe:
+            description: sesu executable
+            default: sesu
+            ini:
+              - section: privilege_escalation
+                key: become_exe
+              - section: sesu_become_plugin
+                key: executable
+            vars:
+              - name: ansible_become_exe
+              - name: ansible_sesu_exe
+            env:
+              - name: ANSIBLE_BECOME_EXE
+              - name: ANSIBLE_SESU_EXE
+        become_flags:
+            description: Options to pass to sesu
+            default: -H -S -n
+            ini:
+              - section: privilege_escalation
+                key: become_flags
+              - section: sesu_become_plugin
+                key: flags
+            vars:
+              - name: ansible_become_flags
+              - name: ansible_sesu_flags
+            env:
+              - name: ANSIBLE_BECOME_FLAGS
+              - name: ANSIBLE_SESU_FLAGS
+        become_pass:
+            description: Password to pass to sesu
+            required: False
+            vars:
+              - name: ansible_become_password
+              - name: ansible_become_pass
+              - name: ansible_sesu_pass
+            env:
+              - name: ANSIBLE_BECOME_PASS
+              - name: ANSIBLE_SESU_PASS
+            ini:
+              - section: sesu_become_plugin
+                key: password
+'''
+
+from ansible.plugins.become import BecomeBase
+
+
+class BecomeModule(BecomeBase):
+
+    name = 'community.general.sesu'
+
+    _prompt = 'Please enter your password:'
+    fail = missing = ('Sorry, try again with sesu.',)
+
+    def build_become_command(self, cmd, shell):
+        super(BecomeModule, self).build_become_command(cmd, shell)
+
+        if not cmd:
+            return cmd
+
+        become = self.get_option('become_exe') or self.name
+        flags = self.get_option('become_flags') or ''
+        user = self.get_option('become_user') or ''
+        return '%s %s %s -c %s' % (become, flags, user, self._build_success_command(cmd, shell))

plugins/cache/jsonfile.py

@@ -0,0 +1,62 @@
+# (c) 2014, Brian Coca, Josh Drake, et al
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    cache: jsonfile
+    short_description: JSON formatted files.
+    description:
+        - This cache uses JSON formatted, per host, files saved to the filesystem.
+    author: Ansible Core (@ansible-core)
+    options:
+      _uri:
+        required: True
+        description:
+          - Path in which the cache plugin will save the JSON files
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_CONNECTION
+        ini:
+          - key: fact_caching_connection
+            section: defaults
+      _prefix:
+        description: User defined prefix to use when creating the JSON files
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_PREFIX
+        ini:
+          - key: fact_caching_prefix
+            section: defaults
+      _timeout:
+        default: 86400
+        description: Expiration timeout in seconds for the cache plugin data. Set to 0 to never expire
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_TIMEOUT
+        ini:
+          - key: fact_caching_timeout
+            section: defaults
+        type: integer
+'''
+
+import codecs
+import json
+
+from ansible.parsing.ajson import AnsibleJSONEncoder, AnsibleJSONDecoder
+from ansible.plugins.cache import BaseFileCacheModule
+
+
+class CacheModule(BaseFileCacheModule):
+    """
+    A caching module backed by json files.
+    """
+
+    def _load(self, filepath):
+        # Valid JSON is always UTF-8 encoded.
+        with codecs.open(filepath, 'r', encoding='utf-8') as f:
+            return json.load(f, cls=AnsibleJSONDecoder)
+
+    def _dump(self, value, filepath):
+        with codecs.open(filepath, 'w', encoding='utf-8') as f:
+            f.write(json.dumps(value, cls=AnsibleJSONEncoder, sort_keys=True, indent=4))

plugins/cache/memcached.py

@@ -0,0 +1,242 @@
+# (c) 2014, Brian Coca, Josh Drake, et al
+# (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
+
+DOCUMENTATION = '''
+    cache: memcached
+    short_description: Use memcached DB for cache
+    description:
+        - This cache uses JSON formatted, per host records saved in memcached.
+    requirements:
+      - memcache (python lib)
+    options:
+      _uri:
+        description:
+          - List of connection information for the memcached DBs
+        default: ['127.0.0.1:11211']
+        type: list
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_CONNECTION
+        ini:
+          - key: fact_caching_connection
+            section: defaults
+      _prefix:
+        description: User defined prefix to use when creating the DB entries
+        default: ansible_facts
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_PREFIX
+        ini:
+          - key: fact_caching_prefix
+            section: defaults
+      _timeout:
+        default: 86400
+        description: Expiration timeout in seconds for the cache plugin data. Set to 0 to never expire
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_TIMEOUT
+        ini:
+          - key: fact_caching_timeout
+            section: defaults
+        type: integer
+'''
+
+import collections
+import os
+import time
+from multiprocessing import Lock
+from itertools import chain
+
+from ansible import constants as C
+from ansible.errors import AnsibleError
+from ansible.module_utils.common._collections_compat import MutableSet
+from ansible.plugins.cache import BaseCacheModule
+from ansible.utils.display import Display
+
+try:
+    import memcache
+except ImportError:
+    raise AnsibleError("python-memcached is required for the memcached fact cache")
+
+display = Display()
+
+
+class ProxyClientPool(object):
+    """
+    Memcached connection pooling for thread/fork safety. Inspired by py-redis
+    connection pool.
+
+    Available connections are maintained in a deque and released in a FIFO manner.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.max_connections = kwargs.pop('max_connections', 1024)
+        self.connection_args = args
+        self.connection_kwargs = kwargs
+        self.reset()
+
+    def reset(self):
+        self.pid = os.getpid()
+        self._num_connections = 0
+        self._available_connections = collections.deque(maxlen=self.max_connections)
+        self._locked_connections = set()
+        self._lock = Lock()
+
+    def _check_safe(self):
+        if self.pid != os.getpid():
+            with self._lock:
+                if self.pid == os.getpid():
+                    # bail out - another thread already acquired the lock
+                    return
+                self.disconnect_all()
+                self.reset()
+
+    def get_connection(self):
+        self._check_safe()
+        try:
+            connection = self._available_connections.popleft()
+        except IndexError:
+            connection = self.create_connection()
+        self._locked_connections.add(connection)
+        return connection
+
+    def create_connection(self):
+        if self._num_connections >= self.max_connections:
+            raise RuntimeError("Too many memcached connections")
+        self._num_connections += 1
+        return memcache.Client(*self.connection_args, **self.connection_kwargs)
+
+    def release_connection(self, connection):
+        self._check_safe()
+        self._locked_connections.remove(connection)
+        self._available_connections.append(connection)
+
+    def disconnect_all(self):
+        for conn in chain(self._available_connections, self._locked_connections):
+            conn.disconnect_all()
+
+    def __getattr__(self, name):
+        def wrapped(*args, **kwargs):
+            return self._proxy_client(name, *args, **kwargs)
+        return wrapped
+
+    def _proxy_client(self, name, *args, **kwargs):
+        conn = self.get_connection()
+
+        try:
+            return getattr(conn, name)(*args, **kwargs)
+        finally:
+            self.release_connection(conn)
+
+
+class CacheModuleKeys(MutableSet):
+    """
+    A set subclass that keeps track of insertion time and persists
+    the set in memcached.
+    """
+    PREFIX = 'ansible_cache_keys'
+
+    def __init__(self, cache, *args, **kwargs):
+        self._cache = cache
+        self._keyset = dict(*args, **kwargs)
+
+    def __contains__(self, key):
+        return key in self._keyset
+
+    def __iter__(self):
+        return iter(self._keyset)
+
+    def __len__(self):
+        return len(self._keyset)
+
+    def add(self, key):
+        self._keyset[key] = time.time()
+        self._cache.set(self.PREFIX, self._keyset)
+
+    def discard(self, key):
+        del self._keyset[key]
+        self._cache.set(self.PREFIX, self._keyset)
+
+    def remove_by_timerange(self, s_min, s_max):
+        for k in self._keyset.keys():
+            t = self._keyset[k]
+            if s_min < t < s_max:
+                del self._keyset[k]
+        self._cache.set(self.PREFIX, self._keyset)
+
+
+class CacheModule(BaseCacheModule):
+
+    def __init__(self, *args, **kwargs):
+        connection = ['127.0.0.1:11211']
+
+        try:
+            super(CacheModule, self).__init__(*args, **kwargs)
+            if self.get_option('_uri'):
+                connection = self.get_option('_uri')
+            self._timeout = self.get_option('_timeout')
+            self._prefix = self.get_option('_prefix')
+        except KeyError:
+            display.deprecated('Rather than importing CacheModules directly, '
+                               'use ansible.plugins.loader.cache_loader', version='2.12')
+            if C.CACHE_PLUGIN_CONNECTION:
+                connection = C.CACHE_PLUGIN_CONNECTION.split(',')
+            self._timeout = C.CACHE_PLUGIN_TIMEOUT
+            self._prefix = C.CACHE_PLUGIN_PREFIX
+
+        self._cache = {}
+        self._db = ProxyClientPool(connection, debug=0)
+        self._keys = CacheModuleKeys(self._db, self._db.get(CacheModuleKeys.PREFIX) or [])
+
+    def _make_key(self, key):
+        return "{0}{1}".format(self._prefix, key)
+
+    def _expire_keys(self):
+        if self._timeout > 0:
+            expiry_age = time.time() - self._timeout
+            self._keys.remove_by_timerange(0, expiry_age)
+
+    def get(self, key):
+        if key not in self._cache:
+            value = self._db.get(self._make_key(key))
+            # guard against the key not being removed from the keyset;
+            # this could happen in cases where the timeout value is changed
+            # between invocations
+            if value is None:
+                self.delete(key)
+                raise KeyError
+            self._cache[key] = value
+
+        return self._cache.get(key)
+
+    def set(self, key, value):
+        self._db.set(self._make_key(key), value, time=self._timeout, min_compress_len=1)
+        self._cache[key] = value
+        self._keys.add(key)
+
+    def keys(self):
+        self._expire_keys()
+        return list(iter(self._keys))
+
+    def contains(self, key):
+        self._expire_keys()
+        return key in self._keys
+
+    def delete(self, key):
+        del self._cache[key]
+        self._db.delete(self._make_key(key))
+        self._keys.discard(key)
+
+    def flush(self):
+        for key in self.keys():
+            self.delete(key)
+
+    def copy(self):
+        return self._keys.copy()
+
+    def __getstate__(self):
+        return dict()
+
+    def __setstate__(self, data):
+        self.__init__()

plugins/cache/pickle.py

@@ -0,0 +1,67 @@
+# (c) 2017, Brian Coca
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    cache: pickle
+    short_description: Pickle formatted files.
+    description:
+        - This cache uses Python's pickle serialization format, in per host files, saved to the filesystem.
+    author: Brian Coca (@bcoca)
+    options:
+      _uri:
+        required: True
+        description:
+          - Path in which the cache plugin will save the files
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_CONNECTION
+        ini:
+          - key: fact_caching_connection
+            section: defaults
+      _prefix:
+        description: User defined prefix to use when creating the files
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_PREFIX
+        ini:
+          - key: fact_caching_prefix
+            section: defaults
+      _timeout:
+        default: 86400
+        description: Expiration timeout in seconds for the cache plugin data. Set to 0 to never expire
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_TIMEOUT
+        ini:
+          - key: fact_caching_timeout
+            section: defaults
+'''
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+from ansible.module_utils.six import PY3
+from ansible.plugins.cache import BaseFileCacheModule
+
+
+class CacheModule(BaseFileCacheModule):
+    """
+    A caching module backed by pickle files.
+    """
+
+    def _load(self, filepath):
+        # Pickle is a binary format
+        with open(filepath, 'rb') as f:
+            if PY3:
+                return pickle.load(f, encoding='bytes')
+            else:
+                return pickle.load(f)
+
+    def _dump(self, value, filepath):
+        with open(filepath, 'wb') as f:
+            # Use pickle protocol 2 which is compatible with Python 2.3+.
+            pickle.dump(value, f, protocol=2)

plugins/cache/redis.py

@@ -0,0 +1,155 @@
+# (c) 2014, Brian Coca, Josh Drake, et al
+# (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
+
+DOCUMENTATION = '''
+    cache: redis
+    short_description: Use Redis DB for cache
+    description:
+        - This cache uses JSON formatted, per host records saved in Redis.
+    requirements:
+      - redis>=2.4.5 (python lib)
+    options:
+      _uri:
+        description:
+          - A colon separated string of connection information for Redis.
+        required: True
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_CONNECTION
+        ini:
+          - key: fact_caching_connection
+            section: defaults
+      _prefix:
+        description: User defined prefix to use when creating the DB entries
+        default: ansible_facts
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_PREFIX
+        ini:
+          - key: fact_caching_prefix
+            section: defaults
+      _timeout:
+        default: 86400
+        description: Expiration timeout in seconds for the cache plugin data. Set to 0 to never expire
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_TIMEOUT
+        ini:
+          - key: fact_caching_timeout
+            section: defaults
+        type: integer
+'''
+
+import time
+import json
+
+from ansible import constants as C
+from ansible.errors import AnsibleError
+from ansible.parsing.ajson import AnsibleJSONEncoder, AnsibleJSONDecoder
+from ansible.plugins.cache import BaseCacheModule
+from ansible.utils.display import Display
+
+try:
+    from redis import StrictRedis, VERSION
+except ImportError:
+    raise AnsibleError("The 'redis' python module (version 2.4.5 or newer) is required for the redis fact cache, 'pip install redis'")
+
+display = Display()
+
+
+class CacheModule(BaseCacheModule):
+    """
+    A caching module backed by redis.
+
+    Keys are maintained in a zset with their score being the timestamp
+    when they are inserted. This allows for the usage of 'zremrangebyscore'
+    to expire keys. This mechanism is used or a pattern matched 'scan' for
+    performance.
+    """
+    def __init__(self, *args, **kwargs):
+        connection = []
+
+        try:
+            super(CacheModule, self).__init__(*args, **kwargs)
+            if self.get_option('_uri'):
+                connection = self.get_option('_uri').split(':')
+            self._timeout = float(self.get_option('_timeout'))
+            self._prefix = self.get_option('_prefix')
+        except KeyError:
+            display.deprecated('Rather than importing CacheModules directly, '
+                               'use ansible.plugins.loader.cache_loader', version='2.12')
+            if C.CACHE_PLUGIN_CONNECTION:
+                connection = C.CACHE_PLUGIN_CONNECTION.split(':')
+            self._timeout = float(C.CACHE_PLUGIN_TIMEOUT)
+            self._prefix = C.CACHE_PLUGIN_PREFIX
+
+        self._cache = {}
+        self._db = StrictRedis(*connection)
+        self._keys_set = 'ansible_cache_keys'
+
+    def _make_key(self, key):
+        return self._prefix + key
+
+    def get(self, key):
+
+        if key not in self._cache:
+            value = self._db.get(self._make_key(key))
+            # guard against the key not being removed from the zset;
+            # this could happen in cases where the timeout value is changed
+            # between invocations
+            if value is None:
+                self.delete(key)
+                raise KeyError
+            self._cache[key] = json.loads(value, cls=AnsibleJSONDecoder)
+
+        return self._cache.get(key)
+
+    def set(self, key, value):
+
+        value2 = json.dumps(value, cls=AnsibleJSONEncoder, sort_keys=True, indent=4)
+        if self._timeout > 0:  # a timeout of 0 is handled as meaning 'never expire'
+            self._db.setex(self._make_key(key), int(self._timeout), value2)
+        else:
+            self._db.set(self._make_key(key), value2)
+
+        if VERSION[0] == 2:
+            self._db.zadd(self._keys_set, time.time(), key)
+        else:
+            self._db.zadd(self._keys_set, {key: time.time()})
+        self._cache[key] = value
+
+    def _expire_keys(self):
+        if self._timeout > 0:
+            expiry_age = time.time() - self._timeout
+            self._db.zremrangebyscore(self._keys_set, 0, expiry_age)
+
+    def keys(self):
+        self._expire_keys()
+        return self._db.zrange(self._keys_set, 0, -1)
+
+    def contains(self, key):
+        self._expire_keys()
+        return (self._db.zrank(self._keys_set, key) is not None)
+
+    def delete(self, key):
+        if key in self._cache:
+            del self._cache[key]
+        self._db.delete(self._make_key(key))
+        self._db.zrem(self._keys_set, key)
+
+    def flush(self):
+        for key in self.keys():
+            self.delete(key)
+
+    def copy(self):
+        # TODO: there is probably a better way to do this in redis
+        ret = dict()
+        for key in self.keys():
+            ret[key] = self.get(key)
+        return ret
+
+    def __getstate__(self):
+        return dict()
+
+    def __setstate__(self, data):
+        self.__init__()

plugins/cache/yaml.py

@@ -0,0 +1,64 @@
+# (c) 2017, Brian Coca
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    cache: yaml
+    short_description: YAML formatted files.
+    description:
+        - This cache uses YAML formatted, per host, files saved to the filesystem.
+    author: Brian Coca (@bcoca)
+    options:
+      _uri:
+        required: True
+        description:
+          - Path in which the cache plugin will save the files
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_CONNECTION
+        ini:
+          - key: fact_caching_connection
+            section: defaults
+      _prefix:
+        description: User defined prefix to use when creating the files
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_PREFIX
+        ini:
+          - key: fact_caching_prefix
+            section: defaults
+      _timeout:
+        default: 86400
+        description: Expiration timeout in seconds for the cache plugin data. Set to 0 to never expire
+        env:
+          - name: ANSIBLE_CACHE_PLUGIN_TIMEOUT
+        ini:
+          - key: fact_caching_timeout
+            section: defaults
+        type: integer
+'''
+
+
+import codecs
+
+import yaml
+
+from ansible.parsing.yaml.loader import AnsibleLoader
+from ansible.parsing.yaml.dumper import AnsibleDumper
+from ansible.plugins.cache import BaseFileCacheModule
+
+
+class CacheModule(BaseFileCacheModule):
+    """
+    A caching module backed by yaml files.
+    """
+
+    def _load(self, filepath):
+        with codecs.open(filepath, 'r', encoding='utf-8') as f:
+            return AnsibleLoader(f).get_single_data()
+
+    def _dump(self, value, filepath):
+        with codecs.open(filepath, 'w', encoding='utf-8') as f:
+            yaml.dump(value, f, Dumper=AnsibleDumper, default_flow_style=False)

plugins/callback/actionable.py

@@ -0,0 +1,60 @@
+# (c) 2015, Andrew Gaffney <andrew@agaffney.org>
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: actionable
+    type: stdout
+    short_description: shows only items that need attention
+    description:
+      - Use this callback when you dont care about OK nor Skipped.
+      - This callback suppresses any non Failed or Changed status.
+    deprecated:
+        why: The 'default' callback plugin now supports this functionality
+        removed_in: '2.11'
+        alternative: "'default' callback plugin with 'display_skipped_hosts = no' and 'display_ok_hosts = no' options"
+    extends_documentation_fragment:
+      - default_callback
+    requirements:
+      - set as stdout callback in configuration
+    # Override defaults from 'default' callback plugin
+    options:
+      display_skipped_hosts:
+        name: Show skipped hosts
+        description: "Toggle to control displaying skipped task/host results in a task"
+        type: bool
+        default: no
+        env:
+          - name: DISPLAY_SKIPPED_HOSTS
+            deprecated:
+              why: environment variables without "ANSIBLE_" prefix are deprecated
+              version: "2.12"
+              alternatives: the "ANSIBLE_DISPLAY_SKIPPED_HOSTS" environment variable
+          - name: ANSIBLE_DISPLAY_SKIPPED_HOSTS
+        ini:
+          - key: display_skipped_hosts
+            section: defaults
+      display_ok_hosts:
+        name: Show 'ok' hosts
+        description: "Toggle to control displaying 'ok' task/host results in a task"
+        type: bool
+        default: no
+        env:
+          - name: ANSIBLE_DISPLAY_OK_HOSTS
+        ini:
+          - key: display_ok_hosts
+            section: defaults
+'''
+
+from ansible.plugins.callback.default import CallbackModule as CallbackModule_default
+
+
+class CallbackModule(CallbackModule_default):
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.actionable'

plugins/callback/cgroup_memory_recap.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+# (c) 2018 Matt Martz <matt@sivel.net>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+DOCUMENTATION = '''
+    callback: cgroup_memory_recap
+    callback_type: aggregate
+    requirements:
+      - whitelist in configuration
+      - cgroups
+    short_description: Profiles maximum memory usage of tasks and full execution using cgroups
+    description:
+        - This is an ansible callback plugin that profiles maximum memory usage of ansible and individual tasks, and displays a recap at the end using cgroups
+    notes:
+        - Requires ansible to be run from within a cgroup, such as with C(cgexec -g memory:ansible_profile ansible-playbook ...)
+        - This cgroup should only be used by ansible to get accurate results
+        - To create the cgroup, first use a command such as C(sudo cgcreate -a ec2-user:ec2-user -t ec2-user:ec2-user -g memory:ansible_profile)
+    options:
+      max_mem_file:
+        required: True
+        description: Path to cgroups C(memory.max_usage_in_bytes) file. Example C(/sys/fs/cgroup/memory/ansible_profile/memory.max_usage_in_bytes)
+        env:
+          - name: CGROUP_MAX_MEM_FILE
+        ini:
+          - section: callback_cgroupmemrecap
+            key: max_mem_file
+      cur_mem_file:
+        required: True
+        description: Path to C(memory.usage_in_bytes) file. Example C(/sys/fs/cgroup/memory/ansible_profile/memory.usage_in_bytes)
+        env:
+          - name: CGROUP_CUR_MEM_FILE
+        ini:
+          - section: callback_cgroupmemrecap
+            key: cur_mem_file
+'''
+
+import time
+import threading
+
+from ansible.plugins.callback import CallbackBase
+
+
+class MemProf(threading.Thread):
+    """Python thread for recording memory usage"""
+    def __init__(self, path, obj=None):
+        threading.Thread.__init__(self)
+        self.obj = obj
+        self.path = path
+        self.results = []
+        self.running = True
+
+    def run(self):
+        while self.running:
+            with open(self.path) as f:
+                val = f.read()
+            self.results.append(int(val.strip()) / 1024 / 1024)
+            time.sleep(0.001)
+
+
+class CallbackModule(CallbackBase):
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.cgroup_memory_recap'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+        super(CallbackModule, self).__init__(display)
+
+        self._task_memprof = None
+
+        self.task_results = []
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.cgroup_max_file = self.get_option('max_mem_file')
+        self.cgroup_current_file = self.get_option('cur_mem_file')
+
+        with open(self.cgroup_max_file, 'w+') as f:
+            f.write('0')
+
+    def _profile_memory(self, obj=None):
+        prev_task = None
+        results = None
+        try:
+            self._task_memprof.running = False
+            results = self._task_memprof.results
+            prev_task = self._task_memprof.obj
+        except AttributeError:
+            pass
+
+        if obj is not None:
+            self._task_memprof = MemProf(self.cgroup_current_file, obj=obj)
+            self._task_memprof.start()
+
+        if results is not None:
+            self.task_results.append((prev_task, max(results)))
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self._profile_memory(task)
+
+    def v2_playbook_on_stats(self, stats):
+        self._profile_memory()
+
+        with open(self.cgroup_max_file) as f:
+            max_results = int(f.read().strip()) / 1024 / 1024
+
+        self._display.banner('CGROUP MEMORY RECAP')
+        self._display.display('Execution Maximum: %0.2fMB\n\n' % max_results)
+
+        for task, memory in self.task_results:
+            self._display.display('%s (%s): %0.2fMB' % (task.get_name(), task._uuid, memory))

plugins/callback/context_demo.py

@@ -0,0 +1,52 @@
+# (C) 2012, Michael DeHaan, <michael.dehaan@gmail.com>
+# (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
+
+DOCUMENTATION = '''
+    callback: context_demo
+    type: aggregate
+    short_description: demo callback that adds play/task context
+    description:
+      - Displays some play and task context along with normal output
+      - This is mostly for demo purposes
+    requirements:
+      - whitelist in configuration
+'''
+
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+    """
+    This is a very trivial example of how any callback function can get at play and task objects.
+    play will be 'None' for runner invocations, and task will be None for 'setup' invocations.
+    """
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.context_demo'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, *args, **kwargs):
+        super(CallbackModule, self).__init__(*args, **kwargs)
+        self.task = None
+        self.play = None
+
+    def v2_on_any(self, *args, **kwargs):
+        self._display.display("--- play: {0} task: {1} ---".format(getattr(self.play, 'name', None), self.task))
+
+        self._display.display("     --- ARGS ")
+        for i, a in enumerate(args):
+            self._display.display('     %s: %s' % (i, a))
+
+        self._display.display("      --- KWARGS ")
+        for k in kwargs:
+            self._display.display('     %s: %s' % (k, kwargs[k]))
+
+    def v2_playbook_on_play_start(self, play):
+        self.play = play
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self.task = task

plugins/callback/counter_enabled.py

@@ -0,0 +1,246 @@
+# (c) 2018, Ivan Aragones Muniesa <ivan.aragones.muniesa@gmail.com>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+'''
+    Counter enabled Ansible callback plugin (See DOCUMENTATION for more information)
+'''
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+from ansible import constants as C
+from ansible.plugins.callback import CallbackBase
+from ansible.utils.color import colorize, hostcolor
+from ansible.template import Templar
+from ansible.playbook.task_include import TaskInclude
+
+DOCUMENTATION = '''
+    callback: counter_enabled
+    type: stdout
+    short_description: adds counters to the output items (tasks and hosts/task)
+    description:
+      - Use this callback when you need a kind of progress bar on a large environments.
+      - You will know how many tasks has the playbook to run, and which one is actually running.
+      - You will know how many hosts may run a task, and which of them is actually running.
+    extends_documentation_fragment:
+      - default_callback
+    requirements:
+      - set as stdout callback in ansible.cfg  (stdout_callback = counter_enabled)
+'''
+
+
+class CallbackModule(CallbackBase):
+
+    '''
+    This is the default callback interface, which simply prints messages
+    to stdout when new callback events are received.
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.counter_enabled'
+
+    _task_counter = 1
+    _task_total = 0
+    _host_counter = 1
+    _host_total = 0
+
+    def __init__(self):
+        super(CallbackModule, self).__init__()
+
+        self._playbook = ""
+        self._play = ""
+
+    def _all_vars(self, host=None, task=None):
+        # host and task need to be specified in case 'magic variables' (host vars, group vars, etc)
+        # need to be loaded as well
+        return self._play.get_variable_manager().get_vars(
+            play=self._play,
+            host=host,
+            task=task
+        )
+
+    def v2_playbook_on_start(self, playbook):
+        self._playbook = playbook
+
+    def v2_playbook_on_play_start(self, play):
+        name = play.get_name().strip()
+        if not name:
+            msg = u"play"
+        else:
+            msg = u"PLAY [%s]" % name
+
+        self._play = play
+
+        self._display.banner(msg)
+        self._play = play
+
+        self._host_total = len(self._all_vars()['vars']['ansible_play_hosts_all'])
+        self._task_total = len(self._play.get_tasks()[0])
+
+    def v2_playbook_on_stats(self, stats):
+        self._display.banner("PLAY RECAP")
+
+        hosts = sorted(stats.processed.keys())
+        for host in hosts:
+            stat = stats.summarize(host)
+
+            self._display.display(u"%s : %s %s %s %s %s %s" % (
+                hostcolor(host, stat),
+                colorize(u'ok', stat['ok'], C.COLOR_OK),
+                colorize(u'changed', stat['changed'], C.COLOR_CHANGED),
+                colorize(u'unreachable', stat['unreachable'], C.COLOR_UNREACHABLE),
+                colorize(u'failed', stat['failures'], C.COLOR_ERROR),
+                colorize(u'rescued', stat['rescued'], C.COLOR_OK),
+                colorize(u'ignored', stat['ignored'], C.COLOR_WARN)),
+                screen_only=True
+            )
+
+            self._display.display(u"%s : %s %s %s %s %s %s" % (
+                hostcolor(host, stat, False),
+                colorize(u'ok', stat['ok'], None),
+                colorize(u'changed', stat['changed'], None),
+                colorize(u'unreachable', stat['unreachable'], None),
+                colorize(u'failed', stat['failures'], None),
+                colorize(u'rescued', stat['rescued'], None),
+                colorize(u'ignored', stat['ignored'], None)),
+                log_only=True
+            )
+
+        self._display.display("", screen_only=True)
+
+        # print custom stats
+        if self._plugin_options.get('show_custom_stats', C.SHOW_CUSTOM_STATS) and stats.custom:
+            # fallback on constants for inherited plugins missing docs
+            self._display.banner("CUSTOM STATS: ")
+            # per host
+            # TODO: come up with 'pretty format'
+            for k in sorted(stats.custom.keys()):
+                if k == '_run':
+                    continue
+                self._display.display('\t%s: %s' % (k, self._dump_results(stats.custom[k], indent=1).replace('\n', '')))
+
+            # print per run custom stats
+            if '_run' in stats.custom:
+                self._display.display("", screen_only=True)
+                self._display.display('\tRUN: %s' % self._dump_results(stats.custom['_run'], indent=1).replace('\n', ''))
+            self._display.display("", screen_only=True)
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        args = ''
+        # args can be specified as no_log in several places: in the task or in
+        # the argument spec.  We can check whether the task is no_log but the
+        # argument spec can't be because that is only run on the target
+        # machine and we haven't run it there yet at this time.
+        #
+        # So we give people a config option to affect display of the args so
+        # that they can secure this if they feel that their stdout is insecure
+        # (shoulder surfing, logging stdout straight to a file, etc).
+        if not task.no_log and C.DISPLAY_ARGS_TO_STDOUT:
+            args = ', '.join(('%s=%s' % a for a in task.args.items()))
+            args = ' %s' % args
+        self._display.banner("TASK %d/%d [%s%s]" % (self._task_counter, self._task_total, task.get_name().strip(), args))
+        if self._display.verbosity >= 2:
+            path = task.get_path()
+            if path:
+                self._display.display("task path: %s" % path, color=C.COLOR_DEBUG)
+        self._host_counter = 0
+        self._task_counter += 1
+
+    def v2_runner_on_ok(self, result):
+
+        self._host_counter += 1
+
+        delegated_vars = result._result.get('_ansible_delegated_vars', None)
+
+        if self._play.strategy == 'free' and self._last_task_banner != result._task._uuid:
+            self._print_task_banner(result._task)
+
+        if isinstance(result._task, TaskInclude):
+            return
+        elif result._result.get('changed', False):
+            if delegated_vars:
+                msg = "changed: %d/%d [%s -> %s]" % (self._host_counter, self._host_total, result._host.get_name(), delegated_vars['ansible_host'])
+            else:
+                msg = "changed: %d/%d [%s]" % (self._host_counter, self._host_total, result._host.get_name())
+            color = C.COLOR_CHANGED
+        else:
+            if delegated_vars:
+                msg = "ok: %d/%d [%s -> %s]" % (self._host_counter, self._host_total, result._host.get_name(), delegated_vars['ansible_host'])
+            else:
+                msg = "ok: %d/%d [%s]" % (self._host_counter, self._host_total, result._host.get_name())
+            color = C.COLOR_OK
+
+        self._handle_warnings(result._result)
+
+        if result._task.loop and 'results' in result._result:
+            self._process_items(result)
+        else:
+            self._clean_results(result._result, result._task.action)
+
+            if self._run_is_verbose(result):
+                msg += " => %s" % (self._dump_results(result._result),)
+            self._display.display(msg, color=color)
+
+    def v2_runner_on_failed(self, result, ignore_errors=False):
+
+        self._host_counter += 1
+
+        delegated_vars = result._result.get('_ansible_delegated_vars', None)
+        self._clean_results(result._result, result._task.action)
+
+        if self._play.strategy == 'free' and self._last_task_banner != result._task._uuid:
+            self._print_task_banner(result._task)
+
+        self._handle_exception(result._result)
+        self._handle_warnings(result._result)
+
+        if result._task.loop and 'results' in result._result:
+            self._process_items(result)
+
+        else:
+            if delegated_vars:
+                self._display.display("fatal: %d/%d [%s -> %s]: FAILED! => %s" % (self._host_counter, self._host_total,
+                                                                                  result._host.get_name(), delegated_vars['ansible_host'],
+                                                                                  self._dump_results(result._result)),
+                                      color=C.COLOR_ERROR)
+            else:
+                self._display.display("fatal: %d/%d [%s]: FAILED! => %s" % (self._host_counter, self._host_total,
+                                                                            result._host.get_name(), self._dump_results(result._result)),
+                                      color=C.COLOR_ERROR)
+
+        if ignore_errors:
+            self._display.display("...ignoring", color=C.COLOR_SKIP)
+
+    def v2_runner_on_skipped(self, result):
+        self._host_counter += 1
+
+        if self._plugin_options.get('show_skipped_hosts', C.DISPLAY_SKIPPED_HOSTS):  # fallback on constants for inherited plugins missing docs
+
+            self._clean_results(result._result, result._task.action)
+
+            if self._play.strategy == 'free' and self._last_task_banner != result._task._uuid:
+                self._print_task_banner(result._task)
+
+            if result._task.loop and 'results' in result._result:
+                self._process_items(result)
+            else:
+                msg = "skipping: %d/%d [%s]" % (self._host_counter, self._host_total, result._host.get_name())
+                if self._run_is_verbose(result):
+                    msg += " => %s" % self._dump_results(result._result)
+                self._display.display(msg, color=C.COLOR_SKIP)
+
+    def v2_runner_on_unreachable(self, result):
+        self._host_counter += 1
+
+        if self._play.strategy == 'free' and self._last_task_banner != result._task._uuid:
+            self._print_task_banner(result._task)
+
+        delegated_vars = result._result.get('_ansible_delegated_vars', None)
+        if delegated_vars:
+            self._display.display("fatal: %d/%d [%s -> %s]: UNREACHABLE! => %s" % (self._host_counter, self._host_total,
+                                                                                   result._host.get_name(), delegated_vars['ansible_host'],
+                                                                                   self._dump_results(result._result)),
+                                  color=C.COLOR_UNREACHABLE)
+        else:
+            self._display.display("fatal: %d/%d [%s]: UNREACHABLE! => %s" % (self._host_counter, self._host_total,
+                                                                             result._host.get_name(), self._dump_results(result._result)),
+                                  color=C.COLOR_UNREACHABLE)

plugins/callback/dense.py

@@ -0,0 +1,501 @@
+# (c) 2016, Dag Wieers <dag@wieers.com>
+# (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
+
+DOCUMENTATION = '''
+callback: dense
+type: stdout
+short_description: minimal stdout output
+extends_documentation_fragment:
+- default_callback
+description:
+- When in verbose mode it will act the same as the default callback
+author:
+- Dag Wieers (@dagwieers)
+requirements:
+- set as stdout in configuration
+'''
+
+HAS_OD = False
+try:
+    from collections import OrderedDict
+    HAS_OD = True
+except ImportError:
+    pass
+
+from ansible.module_utils.six import binary_type, text_type
+from ansible.module_utils.common._collections_compat import MutableMapping, MutableSequence
+from ansible.plugins.callback.default import CallbackModule as CallbackModule_default
+from ansible.utils.color import colorize, hostcolor
+from ansible.utils.display import Display
+
+import sys
+
+display = Display()
+
+
+# Design goals:
+#
+#  + On screen there should only be relevant stuff
+#    - How far are we ? (during run, last line)
+#    - What issues occurred
+#    - What changes occurred
+#    - Diff output (in diff-mode)
+#
+#  + If verbosity increases, act as default output
+#    So that users can easily switch to default for troubleshooting
+#
+#  + Rewrite the output during processing
+#    - We use the cursor to indicate where in the task we are.
+#      Output after the prompt is the output of the previous task.
+#    - If we would clear the line at the start of a task, there would often
+#      be no information at all, so we leave it until it gets updated
+#
+#  + Use the same color-conventions of Ansible
+#
+#  + Ensure the verbose output (-v) is also dense.
+#    Remove information that is not essential (eg. timestamps, status)
+
+
+# TODO:
+#
+#  + Properly test for terminal capabilities, and fall back to default
+#  + Modify Ansible mechanism so we don't need to use sys.stdout directly
+#  + Find an elegant solution for progress bar line wrapping
+
+
+# FIXME: Importing constants as C simply does not work, beats me :-/
+# from ansible import constants as C
+class C:
+    COLOR_HIGHLIGHT = 'white'
+    COLOR_VERBOSE = 'blue'
+    COLOR_WARN = 'bright purple'
+    COLOR_ERROR = 'red'
+    COLOR_DEBUG = 'dark gray'
+    COLOR_DEPRECATE = 'purple'
+    COLOR_SKIP = 'cyan'
+    COLOR_UNREACHABLE = 'bright red'
+    COLOR_OK = 'green'
+    COLOR_CHANGED = 'yellow'
+
+
+# Taken from Dstat
+class vt100:
+    black = '\033[0;30m'
+    darkred = '\033[0;31m'
+    darkgreen = '\033[0;32m'
+    darkyellow = '\033[0;33m'
+    darkblue = '\033[0;34m'
+    darkmagenta = '\033[0;35m'
+    darkcyan = '\033[0;36m'
+    gray = '\033[0;37m'
+
+    darkgray = '\033[1;30m'
+    red = '\033[1;31m'
+    green = '\033[1;32m'
+    yellow = '\033[1;33m'
+    blue = '\033[1;34m'
+    magenta = '\033[1;35m'
+    cyan = '\033[1;36m'
+    white = '\033[1;37m'
+
+    blackbg = '\033[40m'
+    redbg = '\033[41m'
+    greenbg = '\033[42m'
+    yellowbg = '\033[43m'
+    bluebg = '\033[44m'
+    magentabg = '\033[45m'
+    cyanbg = '\033[46m'
+    whitebg = '\033[47m'
+
+    reset = '\033[0;0m'
+    bold = '\033[1m'
+    reverse = '\033[2m'
+    underline = '\033[4m'
+
+    clear = '\033[2J'
+#    clearline = '\033[K'
+    clearline = '\033[2K'
+    save = '\033[s'
+    restore = '\033[u'
+    save_all = '\0337'
+    restore_all = '\0338'
+    linewrap = '\033[7h'
+    nolinewrap = '\033[7l'
+
+    up = '\033[1A'
+    down = '\033[1B'
+    right = '\033[1C'
+    left = '\033[1D'
+
+
+colors = dict(
+    ok=vt100.darkgreen,
+    changed=vt100.darkyellow,
+    skipped=vt100.darkcyan,
+    ignored=vt100.cyanbg + vt100.red,
+    failed=vt100.darkred,
+    unreachable=vt100.red,
+)
+
+states = ('skipped', 'ok', 'changed', 'failed', 'unreachable')
+
+
+class CallbackModule_dense(CallbackModule_default):
+
+    '''
+    This is the dense callback interface, where screen estate is still valued.
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'dense'
+
+    def __init__(self):
+
+        # From CallbackModule
+        self._display = display
+
+        if HAS_OD:
+
+            self.disabled = False
+            self.super_ref = super(CallbackModule, self)
+            self.super_ref.__init__()
+
+            # Attributes to remove from results for more density
+            self.removed_attributes = (
+                #                'changed',
+                'delta',
+                #                'diff',
+                'end',
+                'failed',
+                'failed_when_result',
+                'invocation',
+                'start',
+                'stdout_lines',
+            )
+
+            # Initiate data structures
+            self.hosts = OrderedDict()
+            self.keep = False
+            self.shown_title = False
+            self.count = dict(play=0, handler=0, task=0)
+            self.type = 'foo'
+
+            # Start immediately on the first line
+            sys.stdout.write(vt100.reset + vt100.save + vt100.clearline)
+            sys.stdout.flush()
+        else:
+            display.warning("The 'dense' callback plugin requires OrderedDict which is not available in this version of python, disabling.")
+            self.disabled = True
+
+    def __del__(self):
+        sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+
+    def _add_host(self, result, status):
+        name = result._host.get_name()
+
+        # Add a new status in case a failed task is ignored
+        if status == 'failed' and result._task.ignore_errors:
+            status = 'ignored'
+
+        # Check if we have to update an existing state (when looping over items)
+        if name not in self.hosts:
+            self.hosts[name] = dict(state=status)
+        elif states.index(self.hosts[name]['state']) < states.index(status):
+            self.hosts[name]['state'] = status
+
+        # Store delegated hostname, if needed
+        delegated_vars = result._result.get('_ansible_delegated_vars', None)
+        if delegated_vars:
+            self.hosts[name]['delegate'] = delegated_vars['ansible_host']
+
+        # Print progress bar
+        self._display_progress(result)
+
+#        # Ensure that tasks with changes/failures stay on-screen, and during diff-mode
+#        if status in ['changed', 'failed', 'unreachable'] or (result.get('_diff_mode', False) and result._resultget('diff', False)):
+        # Ensure that tasks with changes/failures stay on-screen
+        if status in ['changed', 'failed', 'unreachable']:
+            self.keep = True
+
+            if self._display.verbosity == 1:
+                # Print task title, if needed
+                self._display_task_banner()
+                self._display_results(result, status)
+
+    def _clean_results(self, result):
+        # Remove non-essential attributes
+        for attr in self.removed_attributes:
+            if attr in result:
+                del(result[attr])
+
+        # Remove empty attributes (list, dict, str)
+        for attr in result.copy():
+            if isinstance(result[attr], (MutableSequence, MutableMapping, binary_type, text_type)):
+                if not result[attr]:
+                    del(result[attr])
+
+    def _handle_exceptions(self, result):
+        if 'exception' in result:
+            # Remove the exception from the result so it's not shown every time
+            del result['exception']
+
+            if self._display.verbosity == 1:
+                return "An exception occurred during task execution. To see the full traceback, use -vvv."
+
+    def _display_progress(self, result=None):
+        # Always rewrite the complete line
+        sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline + vt100.nolinewrap + vt100.underline)
+        sys.stdout.write('%s %d:' % (self.type, self.count[self.type]))
+        sys.stdout.write(vt100.reset)
+        sys.stdout.flush()
+
+        # Print out each host in its own status-color
+        for name in self.hosts:
+            sys.stdout.write(' ')
+            if self.hosts[name].get('delegate', None):
+                sys.stdout.write(self.hosts[name]['delegate'] + '>')
+            sys.stdout.write(colors[self.hosts[name]['state']] + name + vt100.reset)
+            sys.stdout.flush()
+
+#        if result._result.get('diff', False):
+#            sys.stdout.write('\n' + vt100.linewrap)
+        sys.stdout.write(vt100.linewrap)
+
+#        self.keep = True
+
+    def _display_task_banner(self):
+        if not self.shown_title:
+            self.shown_title = True
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline + vt100.underline)
+            sys.stdout.write('%s %d: %s' % (self.type, self.count[self.type], self.task.get_name().strip()))
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+            sys.stdout.flush()
+        else:
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline)
+        self.keep = False
+
+    def _display_results(self, result, status):
+        # Leave the previous task on screen (as it has changes/errors)
+        if self._display.verbosity == 0 and self.keep:
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+        else:
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline)
+        self.keep = False
+
+        self._clean_results(result._result)
+
+        dump = ''
+        if result._task.action == 'include':
+            return
+        elif status == 'ok':
+            return
+        elif status == 'ignored':
+            dump = self._handle_exceptions(result._result)
+        elif status == 'failed':
+            dump = self._handle_exceptions(result._result)
+        elif status == 'unreachable':
+            dump = result._result['msg']
+
+        if not dump:
+            dump = self._dump_results(result._result)
+
+        if result._task.loop and 'results' in result._result:
+            self._process_items(result)
+        else:
+            sys.stdout.write(colors[status] + status + ': ')
+
+            delegated_vars = result._result.get('_ansible_delegated_vars', None)
+            if delegated_vars:
+                sys.stdout.write(vt100.reset + result._host.get_name() + '>' + colors[status] + delegated_vars['ansible_host'])
+            else:
+                sys.stdout.write(result._host.get_name())
+
+            sys.stdout.write(': ' + dump + '\n')
+            sys.stdout.write(vt100.reset + vt100.save + vt100.clearline)
+            sys.stdout.flush()
+
+        if status == 'changed':
+            self._handle_warnings(result._result)
+
+    def v2_playbook_on_play_start(self, play):
+        # Leave the previous task on screen (as it has changes/errors)
+        if self._display.verbosity == 0 and self.keep:
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline + vt100.bold)
+        else:
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline + vt100.bold)
+
+        # Reset at the start of each play
+        self.keep = False
+        self.count.update(dict(handler=0, task=0))
+        self.count['play'] += 1
+        self.play = play
+
+        # Write the next play on screen IN UPPERCASE, and make it permanent
+        name = play.get_name().strip()
+        if not name:
+            name = 'unnamed'
+        sys.stdout.write('PLAY %d: %s' % (self.count['play'], name.upper()))
+        sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+        sys.stdout.flush()
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        # Leave the previous task on screen (as it has changes/errors)
+        if self._display.verbosity == 0 and self.keep:
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline + vt100.underline)
+        else:
+            # Do not clear line, since we want to retain the previous output
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.underline)
+
+        # Reset at the start of each task
+        self.keep = False
+        self.shown_title = False
+        self.hosts = OrderedDict()
+        self.task = task
+        self.type = 'task'
+
+        # Enumerate task if not setup (task names are too long for dense output)
+        if task.get_name() != 'setup':
+            self.count['task'] += 1
+
+        # Write the next task on screen (behind the prompt is the previous output)
+        sys.stdout.write('%s %d.' % (self.type, self.count[self.type]))
+        sys.stdout.write(vt100.reset)
+        sys.stdout.flush()
+
+    def v2_playbook_on_handler_task_start(self, task):
+        # Leave the previous task on screen (as it has changes/errors)
+        if self._display.verbosity == 0 and self.keep:
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline + vt100.underline)
+        else:
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline + vt100.underline)
+
+        # Reset at the start of each handler
+        self.keep = False
+        self.shown_title = False
+        self.hosts = OrderedDict()
+        self.task = task
+        self.type = 'handler'
+
+        # Enumerate handler if not setup (handler names may be too long for dense output)
+        if task.get_name() != 'setup':
+            self.count[self.type] += 1
+
+        # Write the next task on screen (behind the prompt is the previous output)
+        sys.stdout.write('%s %d.' % (self.type, self.count[self.type]))
+        sys.stdout.write(vt100.reset)
+        sys.stdout.flush()
+
+    def v2_playbook_on_cleanup_task_start(self, task):
+        # TBD
+        sys.stdout.write('cleanup.')
+        sys.stdout.flush()
+
+    def v2_runner_on_failed(self, result, ignore_errors=False):
+        self._add_host(result, 'failed')
+
+    def v2_runner_on_ok(self, result):
+        if result._result.get('changed', False):
+            self._add_host(result, 'changed')
+        else:
+            self._add_host(result, 'ok')
+
+    def v2_runner_on_skipped(self, result):
+        self._add_host(result, 'skipped')
+
+    def v2_runner_on_unreachable(self, result):
+        self._add_host(result, 'unreachable')
+
+    def v2_runner_on_include(self, included_file):
+        pass
+
+    def v2_runner_on_file_diff(self, result, diff):
+        sys.stdout.write(vt100.bold)
+        self.super_ref.v2_runner_on_file_diff(result, diff)
+        sys.stdout.write(vt100.reset)
+
+    def v2_on_file_diff(self, result):
+        sys.stdout.write(vt100.bold)
+        self.super_ref.v2_on_file_diff(result)
+        sys.stdout.write(vt100.reset)
+
+    # Old definition in v2.0
+    def v2_playbook_item_on_ok(self, result):
+        self.v2_runner_item_on_ok(result)
+
+    def v2_runner_item_on_ok(self, result):
+        if result._result.get('changed', False):
+            self._add_host(result, 'changed')
+        else:
+            self._add_host(result, 'ok')
+
+    # Old definition in v2.0
+    def v2_playbook_item_on_failed(self, result):
+        self.v2_runner_item_on_failed(result)
+
+    def v2_runner_item_on_failed(self, result):
+        self._add_host(result, 'failed')
+
+    # Old definition in v2.0
+    def v2_playbook_item_on_skipped(self, result):
+        self.v2_runner_item_on_skipped(result)
+
+    def v2_runner_item_on_skipped(self, result):
+        self._add_host(result, 'skipped')
+
+    def v2_playbook_on_no_hosts_remaining(self):
+        if self._display.verbosity == 0 and self.keep:
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+        else:
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline)
+        self.keep = False
+
+        sys.stdout.write(vt100.white + vt100.redbg + 'NO MORE HOSTS LEFT')
+        sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+        sys.stdout.flush()
+
+    def v2_playbook_on_include(self, included_file):
+        pass
+
+    def v2_playbook_on_stats(self, stats):
+        if self._display.verbosity == 0 and self.keep:
+            sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+        else:
+            sys.stdout.write(vt100.restore + vt100.reset + vt100.clearline)
+
+        # In normal mode screen output should be sufficient, summary is redundant
+        if self._display.verbosity == 0:
+            return
+
+        sys.stdout.write(vt100.bold + vt100.underline)
+        sys.stdout.write('SUMMARY')
+
+        sys.stdout.write(vt100.restore + vt100.reset + '\n' + vt100.save + vt100.clearline)
+        sys.stdout.flush()
+
+        hosts = sorted(stats.processed.keys())
+        for h in hosts:
+            t = stats.summarize(h)
+            self._display.display(
+                u"%s : %s %s %s %s %s %s" % (
+                    hostcolor(h, t),
+                    colorize(u'ok', t['ok'], C.COLOR_OK),
+                    colorize(u'changed', t['changed'], C.COLOR_CHANGED),
+                    colorize(u'unreachable', t['unreachable'], C.COLOR_UNREACHABLE),
+                    colorize(u'failed', t['failures'], C.COLOR_ERROR),
+                    colorize(u'rescued', t['rescued'], C.COLOR_OK),
+                    colorize(u'ignored', t['ignored'], C.COLOR_WARN),
+                ),
+                screen_only=True
+            )
+
+
+# When using -vv or higher, simply do the default action
+if display.verbosity >= 2 or not HAS_OD:
+    CallbackModule = CallbackModule_default
+else:
+    CallbackModule = CallbackModule_dense

plugins/callback/full_skip.py

@@ -0,0 +1,75 @@
+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: full_skip
+    type: stdout
+    short_description: suppresses tasks if all hosts skipped
+    description:
+      - Use this plugin when you do not care about any output for tasks that were completely skipped
+    deprecated:
+        why: The 'default' callback plugin now supports this functionality
+        removed_in: '2.11'
+        alternative: "'default' callback plugin with 'display_skipped_hosts = no' option"
+    extends_documentation_fragment:
+      - default_callback
+    requirements:
+      - set as stdout in configuration
+'''
+
+from ansible.plugins.callback.default import CallbackModule as CallbackModule_default
+
+
+class CallbackModule(CallbackModule_default):
+
+    '''
+    This is the default callback interface, which simply prints messages
+    to stdout when new callback events are received.
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.full_skip'
+
+    def v2_runner_on_skipped(self, result):
+        self.outlines = []
+
+    def v2_playbook_item_on_skipped(self, result):
+        self.outlines = []
+
+    def v2_runner_item_on_skipped(self, result):
+        self.outlines = []
+
+    def v2_runner_on_failed(self, result, ignore_errors=False):
+        self.display()
+        super(CallbackModule, self).v2_runner_on_failed(result, ignore_errors)
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self.outlines = []
+        self.outlines.append("TASK [%s]" % task.get_name().strip())
+        if self._display.verbosity >= 2:
+            path = task.get_path()
+            if path:
+                self.outlines.append("task path: %s" % path)
+
+    def v2_playbook_item_on_ok(self, result):
+        self.display()
+        super(CallbackModule, self).v2_playbook_item_on_ok(result)
+
+    def v2_runner_on_ok(self, result):
+        self.display()
+        super(CallbackModule, self).v2_runner_on_ok(result)
+
+    def display(self):
+        if len(self.outlines) == 0:
+            return
+        (first, rest) = self.outlines[0], self.outlines[1:]
+        self._display.banner(first)
+        for line in rest:
+            self._display.display(line)
+        self.outlines = []

plugins/callback/hipchat.py

@@ -0,0 +1,227 @@
+# (C) 2014, Matt Martz <matt@sivel.net>
+# (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
+
+DOCUMENTATION = '''
+    callback: hipchat
+    callback_type: notification
+    requirements:
+      - whitelist in configuration.
+      - prettytable (python lib)
+    short_description: post task events to hipchat
+    description:
+      - This callback plugin sends status updates to a HipChat channel during playbook execution.
+      - Before 2.4 only environment variables were available for configuring this plugin.
+    options:
+      token:
+        description: HipChat API token for v1 or v2 API.
+        required: True
+        env:
+          - name: HIPCHAT_TOKEN
+        ini:
+          - section: callback_hipchat
+            key: token
+      api_version:
+        description: HipChat API version, v1 or v2.
+        required: False
+        default: v1
+        env:
+          - name: HIPCHAT_API_VERSION
+        ini:
+          - section: callback_hipchat
+            key: api_version
+      room:
+        description: HipChat room to post in.
+        default: ansible
+        env:
+          - name: HIPCHAT_ROOM
+        ini:
+          - section: callback_hipchat
+            key: room
+      from:
+        description:  Name to post as
+        default: ansible
+        env:
+          - name: HIPCHAT_FROM
+        ini:
+          - section: callback_hipchat
+            key: from
+      notify:
+        description: Add notify flag to important messages
+        type: bool
+        default: True
+        env:
+          - name: HIPCHAT_NOTIFY
+        ini:
+          - section: callback_hipchat
+            key: notify
+
+'''
+
+import os
+import json
+
+try:
+    import prettytable
+    HAS_PRETTYTABLE = True
+except ImportError:
+    HAS_PRETTYTABLE = False
+
+from ansible.plugins.callback import CallbackBase
+from ansible.module_utils.six.moves.urllib.parse import urlencode
+from ansible.module_utils.urls import open_url
+
+
+class CallbackModule(CallbackBase):
+    """This is an example ansible callback plugin that sends status
+    updates to a HipChat channel during playbook execution.
+    """
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.hipchat'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    API_V1_URL = 'https://api.hipchat.com/v1/rooms/message'
+    API_V2_URL = 'https://api.hipchat.com/v2/'
+
+    def __init__(self):
+
+        super(CallbackModule, self).__init__()
+
+        if not HAS_PRETTYTABLE:
+            self.disabled = True
+            self._display.warning('The `prettytable` python module is not installed. '
+                                  'Disabling the HipChat callback plugin.')
+        self.printed_playbook = False
+        self.playbook_name = None
+        self.play = None
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.token = self.get_option('token')
+        self.api_version = self.get_option('api_version')
+        self.from_name = self.get_option('from')
+        self.allow_notify = self.get_option('notify')
+        self.room = self.get_option('room')
+
+        if self.token is None:
+            self.disabled = True
+            self._display.warning('HipChat token could not be loaded. The HipChat '
+                                  'token can be provided using the `HIPCHAT_TOKEN` '
+                                  'environment variable.')
+
+        # Pick the request handler.
+        if self.api_version == 'v2':
+            self.send_msg = self.send_msg_v2
+        else:
+            self.send_msg = self.send_msg_v1
+
+    def send_msg_v2(self, msg, msg_format='text', color='yellow', notify=False):
+        """Method for sending a message to HipChat"""
+
+        headers = {'Authorization': 'Bearer %s' % self.token, 'Content-Type': 'application/json'}
+
+        body = {}
+        body['room_id'] = self.room
+        body['from'] = self.from_name[:15]  # max length is 15
+        body['message'] = msg
+        body['message_format'] = msg_format
+        body['color'] = color
+        body['notify'] = self.allow_notify and notify
+
+        data = json.dumps(body)
+        url = self.API_V2_URL + "room/{room_id}/notification".format(room_id=self.room)
+        try:
+            response = open_url(url, data=data, headers=headers, method='POST')
+            return response.read()
+        except Exception as ex:
+            self._display.warning('Could not submit message to hipchat: {0}'.format(ex))
+
+    def send_msg_v1(self, msg, msg_format='text', color='yellow', notify=False):
+        """Method for sending a message to HipChat"""
+
+        params = {}
+        params['room_id'] = self.room
+        params['from'] = self.from_name[:15]  # max length is 15
+        params['message'] = msg
+        params['message_format'] = msg_format
+        params['color'] = color
+        params['notify'] = int(self.allow_notify and notify)
+
+        url = ('%s?auth_token=%s' % (self.API_V1_URL, self.token))
+        try:
+            response = open_url(url, data=urlencode(params))
+            return response.read()
+        except Exception as ex:
+            self._display.warning('Could not submit message to hipchat: {0}'.format(ex))
+
+    def v2_playbook_on_play_start(self, play):
+        """Display Playbook and play start messages"""
+
+        self.play = play
+        name = play.name
+        # This block sends information about a playbook when it starts
+        # The playbook object is not immediately available at
+        # playbook_on_start so we grab it via the play
+        #
+        # Displays info about playbook being started by a person on an
+        # inventory, as well as Tags, Skip Tags and Limits
+        if not self.printed_playbook:
+            self.playbook_name, _ = os.path.splitext(
+                os.path.basename(self.play.playbook.filename))
+            host_list = self.play.playbook.inventory.host_list
+            inventory = os.path.basename(os.path.realpath(host_list))
+            self.send_msg("%s: Playbook initiated by %s against %s" %
+                          (self.playbook_name,
+                           self.play.playbook.remote_user,
+                           inventory), notify=True)
+            self.printed_playbook = True
+            subset = self.play.playbook.inventory._subset
+            skip_tags = self.play.playbook.skip_tags
+            self.send_msg("%s:\nTags: %s\nSkip Tags: %s\nLimit: %s" %
+                          (self.playbook_name,
+                           ', '.join(self.play.playbook.only_tags),
+                           ', '.join(skip_tags) if skip_tags else None,
+                           ', '.join(subset) if subset else subset))
+
+        # This is where we actually say we are starting a play
+        self.send_msg("%s: Starting play: %s" %
+                      (self.playbook_name, name))
+
+    def playbook_on_stats(self, stats):
+        """Display info about playbook statistics"""
+        hosts = sorted(stats.processed.keys())
+
+        t = prettytable.PrettyTable(['Host', 'Ok', 'Changed', 'Unreachable',
+                                     'Failures'])
+
+        failures = False
+        unreachable = False
+
+        for h in hosts:
+            s = stats.summarize(h)
+
+            if s['failures'] > 0:
+                failures = True
+            if s['unreachable'] > 0:
+                unreachable = True
+
+            t.add_row([h] + [s[k] for k in ['ok', 'changed', 'unreachable',
+                                            'failures']])
+
+        self.send_msg("%s: Playbook complete" % self.playbook_name,
+                      notify=True)
+
+        if failures or unreachable:
+            color = 'red'
+            self.send_msg("%s: Failures detected" % self.playbook_name,
+                          color=color, notify=True)
+        else:
+            color = 'green'
+
+        self.send_msg("/code %s:\n%s" % (self.playbook_name, t), color=color)

plugins/callback/jabber.py

@@ -0,0 +1,117 @@
+# Copyright (C) 2016 maxn nikolaev.makc@gmail.com
+# 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
+
+DOCUMENTATION = '''
+    callback: jabber
+    type: notification
+    short_description: post task events to a jabber server
+    description:
+      - The chatty part of ChatOps with a Hipchat server as a target
+      - This callback plugin sends status updates to a HipChat channel during playbook execution.
+    requirements:
+      - xmpp (python lib https://github.com/ArchipelProject/xmpppy)
+    options:
+      server:
+        description: connection info to jabber server
+        required: True
+        env:
+          - name: JABBER_SERV
+      user:
+        description: Jabber user to authenticate as
+        required: True
+        env:
+          - name: JABBER_USER
+      password:
+        description: Password for the user to the jabber server
+        required: True
+        env:
+          - name: JABBER_PASS
+      to:
+        description: chat identifier that will receive the message
+        required: True
+        env:
+          - name: JABBER_TO
+'''
+
+import os
+
+HAS_XMPP = True
+try:
+    import xmpp
+except ImportError:
+    HAS_XMPP = False
+
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.jabber'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+
+        super(CallbackModule, self).__init__(display=display)
+
+        if not HAS_XMPP:
+            self._display.warning("The required python xmpp library (xmpppy) is not installed. "
+                                  "pip install git+https://github.com/ArchipelProject/xmpppy")
+            self.disabled = True
+
+        self.serv = os.getenv('JABBER_SERV')
+        self.j_user = os.getenv('JABBER_USER')
+        self.j_pass = os.getenv('JABBER_PASS')
+        self.j_to = os.getenv('JABBER_TO')
+
+        if (self.j_user or self.j_pass or self.serv or self.j_to) is None:
+            self.disabled = True
+            self._display.warning('Jabber CallBack wants the JABBER_SERV, JABBER_USER, JABBER_PASS and JABBER_TO environment variables')
+
+    def send_msg(self, msg):
+        """Send message"""
+        jid = xmpp.JID(self.j_user)
+        client = xmpp.Client(self.serv, debug=[])
+        client.connect(server=(self.serv, 5222))
+        client.auth(jid.getNode(), self.j_pass, resource=jid.getResource())
+        message = xmpp.Message(self.j_to, msg)
+        message.setAttr('type', 'chat')
+        client.send(message)
+        client.disconnect()
+
+    def v2_runner_on_ok(self, result):
+        self._clean_results(result._result, result._task.action)
+        self.debug = self._dump_results(result._result)
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self.task = task
+
+    def v2_playbook_on_play_start(self, play):
+        """Display Playbook and play start messages"""
+        self.play = play
+        name = play.name
+        self.send_msg("Ansible starting play: %s" % (name))
+
+    def playbook_on_stats(self, stats):
+        name = self.play
+        hosts = sorted(stats.processed.keys())
+        failures = False
+        unreachable = False
+        for h in hosts:
+            s = stats.summarize(h)
+            if s['failures'] > 0:
+                failures = True
+            if s['unreachable'] > 0:
+                unreachable = True
+
+        if failures or unreachable:
+            out = self.debug
+            self.send_msg("%s: Failures detected \n%s \nHost: %s\n Failed at:\n%s" % (name, self.task, h, out))
+        else:
+            out = self.debug
+            self.send_msg("Great! \n Playbook %s completed:\n%s \n Last task debug:\n %s" % (name, s, out))

plugins/callback/log_plays.py

@@ -0,0 +1,108 @@
+# (C) 2012, Michael DeHaan, <michael.dehaan@gmail.com>
+# (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
+
+DOCUMENTATION = '''
+    callback: log_plays
+    type: notification
+    short_description: write playbook output to log file
+    description:
+      - This callback writes playbook output to a file per host in the `/var/log/ansible/hosts` directory
+    requirements:
+     - Whitelist in configuration
+     - A writeable /var/log/ansible/hosts directory by the user executing Ansible on the controller
+    options:
+      log_folder:
+        default: /var/log/ansible/hosts
+        description: The folder where log files will be created.
+        env:
+          - name: ANSIBLE_LOG_FOLDER
+        ini:
+          - section: callback_log_plays
+            key: log_folder
+'''
+
+import os
+import time
+import json
+
+from ansible.utils.path import makedirs_safe
+from ansible.module_utils._text import to_bytes
+from ansible.module_utils.common._collections_compat import MutableMapping
+from ansible.parsing.ajson import AnsibleJSONEncoder
+from ansible.plugins.callback import CallbackBase
+
+
+# NOTE: in Ansible 1.2 or later general logging is available without
+# this plugin, just set ANSIBLE_LOG_PATH as an environment variable
+# or log_path in the DEFAULTS section of your ansible configuration
+# file.  This callback is an example of per hosts logging for those
+# that want it.
+
+
+class CallbackModule(CallbackBase):
+    """
+    logs playbook results, per host, in /var/log/ansible/hosts
+    """
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.log_plays'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    TIME_FORMAT = "%b %d %Y %H:%M:%S"
+    MSG_FORMAT = "%(now)s - %(category)s - %(data)s\n\n"
+
+    def __init__(self):
+
+        super(CallbackModule, self).__init__()
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.log_folder = self.get_option("log_folder")
+
+        if not os.path.exists(self.log_folder):
+            makedirs_safe(self.log_folder)
+
+    def log(self, host, category, data):
+        if isinstance(data, MutableMapping):
+            if '_ansible_verbose_override' in data:
+                # avoid logging extraneous data
+                data = 'omitted'
+            else:
+                data = data.copy()
+                invocation = data.pop('invocation', None)
+                data = json.dumps(data, cls=AnsibleJSONEncoder)
+                if invocation is not None:
+                    data = json.dumps(invocation) + " => %s " % data
+
+        path = os.path.join(self.log_folder, host)
+        now = time.strftime(self.TIME_FORMAT, time.localtime())
+
+        msg = to_bytes(self.MSG_FORMAT % dict(now=now, category=category, data=data))
+        with open(path, "ab") as fd:
+            fd.write(msg)
+
+    def runner_on_failed(self, host, res, ignore_errors=False):
+        self.log(host, 'FAILED', res)
+
+    def runner_on_ok(self, host, res):
+        self.log(host, 'OK', res)
+
+    def runner_on_skipped(self, host, item=None):
+        self.log(host, 'SKIPPED', '...')
+
+    def runner_on_unreachable(self, host, res):
+        self.log(host, 'UNREACHABLE', res)
+
+    def runner_on_async_failed(self, host, res, jid):
+        self.log(host, 'ASYNC_FAILED', res)
+
+    def playbook_on_import_for_host(self, host, imported_file):
+        self.log(host, 'IMPORTED', imported_file)
+
+    def playbook_on_not_import_for_host(self, host, missing_file):
+        self.log(host, 'NOTIMPORTED', missing_file)

plugins/callback/logdna.py

@@ -0,0 +1,207 @@
+# (c) 2018, Samir Musali <samir.musali@logdna.com>
+# 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
+
+DOCUMENTATION = '''
+    callback: logdna
+    callback_type: aggregate
+    short_description: Sends playbook logs to LogDNA
+    description:
+      - This callback will report logs from playbook actions, tasks, and events to LogDNA (https://app.logdna.com)
+    requirements:
+      - LogDNA Python Library (https://github.com/logdna/python)
+      - whitelisting in configuration
+    options:
+      conf_key:
+        required: True
+        description: LogDNA Ingestion Key
+        type: string
+        env:
+          - name: LOGDNA_INGESTION_KEY
+        ini:
+          - section: callback_logdna
+            key: conf_key
+      plugin_ignore_errors:
+        required: False
+        description: Whether to ignore errors on failing or not
+        type: boolean
+        env:
+          - name: ANSIBLE_IGNORE_ERRORS
+        ini:
+          - section: callback_logdna
+            key: plugin_ignore_errors
+        default: False
+      conf_hostname:
+        required: False
+        description: Alternative Host Name; the current host name by default
+        type: string
+        env:
+          - name: LOGDNA_HOSTNAME
+        ini:
+          - section: callback_logdna
+            key: conf_hostname
+      conf_tags:
+        required: False
+        description: Tags
+        type: string
+        env:
+          - name: LOGDNA_TAGS
+        ini:
+          - section: callback_logdna
+            key: conf_tags
+        default: ansible
+'''
+
+import logging
+import json
+import socket
+from uuid import getnode
+from ansible.plugins.callback import CallbackBase
+from ansible.parsing.ajson import AnsibleJSONEncoder
+
+try:
+    from logdna import LogDNAHandler
+    HAS_LOGDNA = True
+except ImportError:
+    HAS_LOGDNA = False
+
+
+# Getting MAC Address of system:
+def get_mac():
+    mac = "%012x" % getnode()
+    return ":".join(map(lambda index: mac[index:index + 2], range(int(len(mac) / 2))))
+
+
+# Getting hostname of system:
+def get_hostname():
+    return str(socket.gethostname()).split('.local')[0]
+
+
+# Getting IP of system:
+def get_ip():
+    try:
+        return socket.gethostbyname(get_hostname())
+    except Exception:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            s.connect(('10.255.255.255', 1))
+            IP = s.getsockname()[0]
+        except Exception:
+            IP = '127.0.0.1'
+        finally:
+            s.close()
+        return IP
+
+
+# Is it JSON?
+def isJSONable(obj):
+    try:
+        json.dumps(obj, sort_keys=True, cls=AnsibleJSONEncoder)
+        return True
+    except Exception:
+        return False
+
+
+# LogDNA Callback Module:
+class CallbackModule(CallbackBase):
+
+    CALLBACK_VERSION = 0.1
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.logdna'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+        super(CallbackModule, self).__init__(display=display)
+
+        self.disabled = True
+        self.playbook_name = None
+        self.playbook = None
+        self.conf_key = None
+        self.plugin_ignore_errors = None
+        self.conf_hostname = None
+        self.conf_tags = None
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.conf_key = self.get_option('conf_key')
+        self.plugin_ignore_errors = self.get_option('plugin_ignore_errors')
+        self.conf_hostname = self.get_option('conf_hostname')
+        self.conf_tags = self.get_option('conf_tags')
+        self.mac = get_mac()
+        self.ip = get_ip()
+
+        if self.conf_hostname is None:
+            self.conf_hostname = get_hostname()
+
+        self.conf_tags = self.conf_tags.split(',')
+
+        if HAS_LOGDNA:
+            self.log = logging.getLogger('logdna')
+            self.log.setLevel(logging.INFO)
+            self.options = {'hostname': self.conf_hostname, 'mac': self.mac, 'index_meta': True}
+            self.log.addHandler(LogDNAHandler(self.conf_key, self.options))
+            self.disabled = False
+        else:
+            self.disabled = True
+            self._display.warning('WARNING:\nPlease, install LogDNA Python Package: `pip install logdna`')
+
+    def metaIndexing(self, meta):
+        invalidKeys = []
+        ninvalidKeys = 0
+        for key, value in meta.items():
+            if not isJSONable(value):
+                invalidKeys.append(key)
+                ninvalidKeys += 1
+        if ninvalidKeys > 0:
+            for key in invalidKeys:
+                del meta[key]
+            meta['__errors'] = 'These keys have been sanitized: ' + ', '.join(invalidKeys)
+        return meta
+
+    def sanitizeJSON(self, data):
+        try:
+            return json.loads(json.dumps(data, sort_keys=True, cls=AnsibleJSONEncoder))
+        except Exception:
+            return {'warnings': ['JSON Formatting Issue', json.dumps(data, sort_keys=True, cls=AnsibleJSONEncoder)]}
+
+    def flush(self, log, options):
+        if HAS_LOGDNA:
+            self.log.info(json.dumps(log), options)
+
+    def sendLog(self, host, category, logdata):
+        options = {'app': 'ansible', 'meta': {'playbook': self.playbook_name, 'host': host, 'category': category}}
+        logdata['info'].pop('invocation', None)
+        warnings = logdata['info'].pop('warnings', None)
+        if warnings is not None:
+            self.flush({'warn': warnings}, options)
+        self.flush(logdata, options)
+
+    def v2_playbook_on_start(self, playbook):
+        self.playbook = playbook
+        self.playbook_name = playbook._file_name
+
+    def v2_playbook_on_stats(self, stats):
+        result = dict()
+        for host in stats.processed.keys():
+            result[host] = stats.summarize(host)
+        self.sendLog(self.conf_hostname, 'STATS', {'info': self.sanitizeJSON(result)})
+
+    def runner_on_failed(self, host, res, ignore_errors=False):
+        if self.plugin_ignore_errors:
+            ignore_errors = self.plugin_ignore_errors
+        self.sendLog(host, 'FAILED', {'info': self.sanitizeJSON(res), 'ignore_errors': ignore_errors})
+
+    def runner_on_ok(self, host, res):
+        self.sendLog(host, 'OK', {'info': self.sanitizeJSON(res)})
+
+    def runner_on_unreachable(self, host, res):
+        self.sendLog(host, 'UNREACHABLE', {'info': self.sanitizeJSON(res)})
+
+    def runner_on_async_failed(self, host, res, jid):
+        self.sendLog(host, 'ASYNC_FAILED', {'info': self.sanitizeJSON(res), 'job_id': jid})
+
+    def runner_on_async_ok(self, host, res, jid):
+        self.sendLog(host, 'ASYNC_OK', {'info': self.sanitizeJSON(res), 'job_id': jid})

plugins/callback/logentries.py

@@ -0,0 +1,329 @@
+# (c) 2015, Logentries.com, Jimmy Tang <jimmy.tang@logentries.com>
+# (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
+
+DOCUMENTATION = '''
+    callback: logentries
+    type: notification
+    short_description: Sends events to Logentries
+    description:
+      - This callback plugin will generate JSON objects and send them to Logentries via TCP for auditing/debugging purposes.
+      - Before 2.4, if you wanted to use an ini configuration, the file must be placed in the same directory as this plugin and named logentries.ini
+      - In 2.4 and above you can just put it in the main Ansible configuration file.
+    requirements:
+      - whitelisting in configuration
+      - certifi (python library)
+      - flatdict (python library), if you want to use the 'flatten' option
+    options:
+      api:
+        description: URI to the Logentries API
+        env:
+          - name: LOGENTRIES_API
+        default: data.logentries.com
+        ini:
+          - section: callback_logentries
+            key: api
+      port:
+        description: HTTP port to use when connecting to the API
+        env:
+            - name: LOGENTRIES_PORT
+        default: 80
+        ini:
+          - section: callback_logentries
+            key: port
+      tls_port:
+        description: Port to use when connecting to the API when TLS is enabled
+        env:
+            - name: LOGENTRIES_TLS_PORT
+        default: 443
+        ini:
+          - section: callback_logentries
+            key: tls_port
+      token:
+        description: The logentries "TCP token"
+        env:
+          - name: LOGENTRIES_ANSIBLE_TOKEN
+        required: True
+        ini:
+          - section: callback_logentries
+            key: token
+      use_tls:
+        description:
+          - Toggle to decide whether to use TLS to encrypt the communications with the API server
+        env:
+          - name: LOGENTRIES_USE_TLS
+        default: False
+        type: boolean
+        ini:
+          - section: callback_logentries
+            key: use_tls
+      flatten:
+        description: flatten complex data structures into a single dictionary with complex keys
+        type: boolean
+        default: False
+        env:
+          - name: LOGENTRIES_FLATTEN
+        ini:
+          - section: callback_logentries
+            key: flatten
+'''
+
+EXAMPLES = '''
+examples: >
+  To enable, add this to your ansible.cfg file in the defaults block
+
+    [defaults]
+    callback_whitelist = logentries
+
+  Either set the environment variables
+    export LOGENTRIES_API=data.logentries.com
+    export LOGENTRIES_PORT=10000
+    export LOGENTRIES_ANSIBLE_TOKEN=dd21fc88-f00a-43ff-b977-e3a4233c53af
+
+  Or in the main Ansible config file
+    [callback_logentries]
+    api = data.logentries.com
+    port = 10000
+    tls_port = 20000
+    use_tls = no
+    token = dd21fc88-f00a-43ff-b977-e3a4233c53af
+    flatten = False
+'''
+
+import os
+import socket
+import random
+import time
+import uuid
+
+try:
+    import certifi
+    HAS_CERTIFI = True
+except ImportError:
+    HAS_CERTIFI = False
+
+try:
+    import flatdict
+    HAS_FLATDICT = True
+except ImportError:
+    HAS_FLATDICT = False
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible.plugins.callback import CallbackBase
+
+# Todo:
+#  * Better formatting of output before sending out to logentries data/api nodes.
+
+
+class PlainTextSocketAppender(object):
+    def __init__(self, display, LE_API='data.logentries.com', LE_PORT=80, LE_TLS_PORT=443):
+
+        self.LE_API = LE_API
+        self.LE_PORT = LE_PORT
+        self.LE_TLS_PORT = LE_TLS_PORT
+        self.MIN_DELAY = 0.1
+        self.MAX_DELAY = 10
+        # Error message displayed when an incorrect Token has been detected
+        self.INVALID_TOKEN = "\n\nIt appears the LOGENTRIES_TOKEN parameter you entered is incorrect!\n\n"
+        # Unicode Line separator character   \u2028
+        self.LINE_SEP = u'\u2028'
+
+        self._display = display
+        self._conn = None
+
+    def open_connection(self):
+        self._conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._conn.connect((self.LE_API, self.LE_PORT))
+
+    def reopen_connection(self):
+        self.close_connection()
+
+        root_delay = self.MIN_DELAY
+        while True:
+            try:
+                self.open_connection()
+                return
+            except Exception as e:
+                self._display.vvvv(u"Unable to connect to Logentries: %s" % to_text(e))
+
+            root_delay *= 2
+            if root_delay > self.MAX_DELAY:
+                root_delay = self.MAX_DELAY
+
+            wait_for = root_delay + random.uniform(0, root_delay)
+
+            try:
+                self._display.vvvv("sleeping %s before retry" % wait_for)
+                time.sleep(wait_for)
+            except KeyboardInterrupt:
+                raise
+
+    def close_connection(self):
+        if self._conn is not None:
+            self._conn.close()
+
+    def put(self, data):
+        # Replace newlines with Unicode line separator
+        # for multi-line events
+        data = to_text(data, errors='surrogate_or_strict')
+        multiline = data.replace(u'\n', self.LINE_SEP)
+        multiline += u"\n"
+        # Send data, reconnect if needed
+        while True:
+            try:
+                self._conn.send(to_bytes(multiline, errors='surrogate_or_strict'))
+            except socket.error:
+                self.reopen_connection()
+                continue
+            break
+
+        self.close_connection()
+
+
+try:
+    import ssl
+    HAS_SSL = True
+except ImportError:  # for systems without TLS support.
+    SocketAppender = PlainTextSocketAppender
+    HAS_SSL = False
+else:
+
+    class TLSSocketAppender(PlainTextSocketAppender):
+        def open_connection(self):
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock = ssl.wrap_socket(
+                sock=sock,
+                keyfile=None,
+                certfile=None,
+                server_side=False,
+                cert_reqs=ssl.CERT_REQUIRED,
+                ssl_version=getattr(
+                    ssl, 'PROTOCOL_TLSv1_2', ssl.PROTOCOL_TLSv1),
+                ca_certs=certifi.where(),
+                do_handshake_on_connect=True,
+                suppress_ragged_eofs=True, )
+            sock.connect((self.LE_API, self.LE_TLS_PORT))
+            self._conn = sock
+
+    SocketAppender = TLSSocketAppender
+
+
+class CallbackModule(CallbackBase):
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.logentries'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self):
+
+        # TODO: allow for alternate posting methods (REST/UDP/agent/etc)
+        super(CallbackModule, self).__init__()
+
+        # verify dependencies
+        if not HAS_SSL:
+            self._display.warning("Unable to import ssl module. Will send over port 80.")
+
+        if not HAS_CERTIFI:
+            self.disabled = True
+            self._display.warning('The `certifi` python module is not installed.\nDisabling the Logentries callback plugin.')
+
+        self.le_jobid = str(uuid.uuid4())
+
+        # FIXME: make configurable, move to options
+        self.timeout = 10
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        # get options
+        try:
+            self.api_url = self.get_option('api')
+            self.api_port = self.get_option('port')
+            self.api_tls_port = self.get_option('tls_port')
+            self.use_tls = self.get_option('use_tls')
+            self.flatten = self.get_option('flatten')
+        except KeyError as e:
+            self._display.warning(u"Missing option for Logentries callback plugin: %s" % to_text(e))
+            self.disabled = True
+
+        try:
+            self.token = self.get_option('token')
+        except KeyError as e:
+            self._display.warning('Logentries token was not provided, this is required for this callback to operate, disabling')
+            self.disabled = True
+
+        if self.flatten and not HAS_FLATDICT:
+            self.disabled = True
+            self._display.warning('You have chosen to flatten and the `flatdict` python module is not installed.\nDisabling the Logentries callback plugin.')
+
+        self._initialize_connections()
+
+    def _initialize_connections(self):
+
+        if not self.disabled:
+            if self.use_tls:
+                self._display.vvvv("Connecting to %s:%s with TLS" % (self.api_url, self.api_tls_port))
+                self._appender = TLSSocketAppender(display=self._display, LE_API=self.api_url, LE_TLS_PORT=self.api_tls_port)
+            else:
+                self._display.vvvv("Connecting to %s:%s" % (self.api_url, self.api_port))
+                self._appender = PlainTextSocketAppender(display=self._display, LE_API=self.api_url, LE_PORT=self.api_port)
+            self._appender.reopen_connection()
+
+    def emit_formatted(self, record):
+        if self.flatten:
+            results = flatdict.FlatDict(record)
+            self.emit(self._dump_results(results))
+        else:
+            self.emit(self._dump_results(record))
+
+    def emit(self, record):
+        msg = record.rstrip('\n')
+        msg = "{0} {1}".format(self.token, msg)
+        self._appender.put(msg)
+        self._display.vvvv("Sent event to logentries")
+
+    def _set_info(self, host, res):
+        return {'le_jobid': self.le_jobid, 'hostname': host, 'results': res}
+
+    def runner_on_ok(self, host, res):
+        results = self._set_info(host, res)
+        results['status'] = 'OK'
+        self.emit_formatted(results)
+
+    def runner_on_failed(self, host, res, ignore_errors=False):
+        results = self._set_info(host, res)
+        results['status'] = 'FAILED'
+        self.emit_formatted(results)
+
+    def runner_on_skipped(self, host, item=None):
+        results = self._set_info(host, item)
+        del results['results']
+        results['status'] = 'SKIPPED'
+        self.emit_formatted(results)
+
+    def runner_on_unreachable(self, host, res):
+        results = self._set_info(host, res)
+        results['status'] = 'UNREACHABLE'
+        self.emit_formatted(results)
+
+    def runner_on_async_failed(self, host, res, jid):
+        results = self._set_info(host, res)
+        results['jid'] = jid
+        results['status'] = 'ASYNC_FAILED'
+        self.emit_formatted(results)
+
+    def v2_playbook_on_play_start(self, play):
+        results = {}
+        results['le_jobid'] = self.le_jobid
+        results['started_by'] = os.getlogin()
+        if play.name:
+            results['play'] = play.name
+        results['hosts'] = play.hosts
+        self.emit_formatted(results)
+
+    def playbook_on_stats(self, stats):
+        """ close connection """
+        self._appender.close_connection()

plugins/callback/logstash.py

@@ -0,0 +1,228 @@
+# (C) 2016, Ievgen Khmelenko <ujenmr@gmail.com>
+# (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
+
+DOCUMENTATION = '''
+    callback: logstash
+    type: notification
+    short_description: Sends events to Logstash
+    description:
+      - This callback will report facts and task events to Logstash https://www.elastic.co/products/logstash
+    requirements:
+      - whitelisting in configuration
+      - logstash (python library)
+    options:
+      server:
+        description: Address of the Logstash server
+        env:
+          - name: LOGSTASH_SERVER
+        default: localhost
+      port:
+        description: Port on which logstash is listening
+        env:
+            - name: LOGSTASH_PORT
+        default: 5000
+      type:
+        description: Message type
+        env:
+          - name: LOGSTASH_TYPE
+        default: ansible
+'''
+
+import os
+import json
+import socket
+import uuid
+from datetime import datetime
+
+import logging
+
+try:
+    import logstash
+    HAS_LOGSTASH = True
+except ImportError:
+    HAS_LOGSTASH = False
+
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+    """
+    ansible logstash callback plugin
+    ansible.cfg:
+        callback_plugins   = <path_to_callback_plugins_folder>
+        callback_whitelist = logstash
+    and put the plugin in <path_to_callback_plugins_folder>
+
+    logstash config:
+        input {
+            tcp {
+                port => 5000
+                codec => json
+            }
+        }
+
+    Requires:
+        python-logstash
+
+    This plugin makes use of the following environment variables:
+        LOGSTASH_SERVER   (optional): defaults to localhost
+        LOGSTASH_PORT     (optional): defaults to 5000
+        LOGSTASH_TYPE     (optional): defaults to ansible
+    """
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.logstash'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self):
+        super(CallbackModule, self).__init__()
+
+        if not HAS_LOGSTASH:
+            self.disabled = True
+            self._display.warning("The required python-logstash is not installed. "
+                                  "pip install python-logstash")
+        else:
+            self.logger = logging.getLogger('python-logstash-logger')
+            self.logger.setLevel(logging.DEBUG)
+
+            self.handler = logstash.TCPLogstashHandler(
+                os.getenv('LOGSTASH_SERVER', 'localhost'),
+                int(os.getenv('LOGSTASH_PORT', 5000)),
+                version=1,
+                message_type=os.getenv('LOGSTASH_TYPE', 'ansible')
+            )
+
+            self.logger.addHandler(self.handler)
+            self.hostname = socket.gethostname()
+            self.session = str(uuid.uuid1())
+            self.errors = 0
+        self.start_time = datetime.utcnow()
+
+    def v2_playbook_on_start(self, playbook):
+        self.playbook = playbook._file_name
+        data = {
+            'status': "OK",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "start",
+            'ansible_playbook': self.playbook,
+        }
+        self.logger.info("ansible start", extra=data)
+
+    def v2_playbook_on_stats(self, stats):
+        end_time = datetime.utcnow()
+        runtime = end_time - self.start_time
+        summarize_stat = {}
+        for host in stats.processed.keys():
+            summarize_stat[host] = stats.summarize(host)
+
+        if self.errors == 0:
+            status = "OK"
+        else:
+            status = "FAILED"
+
+        data = {
+            'status': status,
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "finish",
+            'ansible_playbook': self.playbook,
+            'ansible_playbook_duration': runtime.total_seconds(),
+            'ansible_result': json.dumps(summarize_stat),
+        }
+        self.logger.info("ansible stats", extra=data)
+
+    def v2_runner_on_ok(self, result, **kwargs):
+        data = {
+            'status': "OK",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "task",
+            'ansible_playbook': self.playbook,
+            'ansible_host': result._host.name,
+            'ansible_task': result._task,
+            'ansible_result': self._dump_results(result._result)
+        }
+        self.logger.info("ansible ok", extra=data)
+
+    def v2_runner_on_skipped(self, result, **kwargs):
+        data = {
+            'status': "SKIPPED",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "task",
+            'ansible_playbook': self.playbook,
+            'ansible_task': result._task,
+            'ansible_host': result._host.name
+        }
+        self.logger.info("ansible skipped", extra=data)
+
+    def v2_playbook_on_import_for_host(self, result, imported_file):
+        data = {
+            'status': "IMPORTED",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "import",
+            'ansible_playbook': self.playbook,
+            'ansible_host': result._host.name,
+            'imported_file': imported_file
+        }
+        self.logger.info("ansible import", extra=data)
+
+    def v2_playbook_on_not_import_for_host(self, result, missing_file):
+        data = {
+            'status': "NOT IMPORTED",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "import",
+            'ansible_playbook': self.playbook,
+            'ansible_host': result._host.name,
+            'missing_file': missing_file
+        }
+        self.logger.info("ansible import", extra=data)
+
+    def v2_runner_on_failed(self, result, **kwargs):
+        data = {
+            'status': "FAILED",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "task",
+            'ansible_playbook': self.playbook,
+            'ansible_host': result._host.name,
+            'ansible_task': result._task,
+            'ansible_result': self._dump_results(result._result)
+        }
+        self.errors += 1
+        self.logger.error("ansible failed", extra=data)
+
+    def v2_runner_on_unreachable(self, result, **kwargs):
+        data = {
+            'status': "UNREACHABLE",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "task",
+            'ansible_playbook': self.playbook,
+            'ansible_host': result._host.name,
+            'ansible_task': result._task,
+            'ansible_result': self._dump_results(result._result)
+        }
+        self.logger.error("ansible unreachable", extra=data)
+
+    def v2_runner_on_async_failed(self, result, **kwargs):
+        data = {
+            'status': "FAILED",
+            'host': self.hostname,
+            'session': self.session,
+            'ansible_type': "task",
+            'ansible_playbook': self.playbook,
+            'ansible_host': result._host.name,
+            'ansible_task': result._task,
+            'ansible_result': self._dump_results(result._result)
+        }
+        self.errors += 1
+        self.logger.error("ansible async", extra=data)

plugins/callback/mail.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+
+# Copyright: (c) 2012, Dag Wieers <dag@wieers.com>
+# 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
+
+DOCUMENTATION = '''
+callback: mail
+type: notification
+short_description: Sends failure events via email
+description:
+- This callback will report failures via email
+author:
+- Dag Wieers (@dagwieers)
+requirements:
+- whitelisting in configuration
+options:
+  mta:
+    description: Mail Transfer Agent, server that accepts SMTP
+    env:
+        - name: SMTPHOST
+    ini:
+        - section: callback_mail
+          key: smtphost
+    default: localhost
+  mtaport:
+    description: Mail Transfer Agent Port, port at which server SMTP
+    ini:
+        - section: callback_mail
+          key: smtpport
+    default: 25
+  to:
+    description: Mail recipient
+    ini:
+        - section: callback_mail
+          key: to
+    default: root
+  sender:
+    description: Mail sender
+    ini:
+        - section: callback_mail
+          key: sender
+  cc:
+    description: CC'd recipient
+    ini:
+        - section: callback_mail
+          key: cc
+  bcc:
+    description: BCC'd recipient
+    ini:
+        - section: callback_mail
+          key: bcc
+note:
+- "TODO: expand configuration options now that plugins can leverage Ansible's configuration"
+'''
+
+import json
+import os
+import re
+import smtplib
+
+from ansible.module_utils.six import string_types
+from ansible.module_utils._text import to_bytes
+from ansible.parsing.ajson import AnsibleJSONEncoder
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+    ''' This Ansible callback plugin mails errors to interested parties. '''
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.mail'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+        super(CallbackModule, self).__init__(display=display)
+        self.sender = None
+        self.to = 'root'
+        self.smtphost = os.getenv('SMTPHOST', 'localhost')
+        self.smtpport = 25
+        self.cc = None
+        self.bcc = None
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.sender = self.get_option('sender')
+        self.to = self.get_option('to')
+        self.smtphost = self.get_option('mta')
+        self.smtpport = int(self.get_option('mtaport'))
+        self.cc = self.get_option('cc')
+        self.bcc = self.get_option('bcc')
+
+    def mail(self, subject='Ansible error mail', body=None):
+        if body is None:
+            body = subject
+
+        smtp = smtplib.SMTP(self.smtphost, port=self.smtpport)
+
+        b_sender = to_bytes(self.sender)
+        b_to = to_bytes(self.to)
+        b_cc = to_bytes(self.cc)
+        b_bcc = to_bytes(self.bcc)
+        b_subject = to_bytes(subject)
+        b_body = to_bytes(body)
+
+        b_content = b'From: %s\n' % b_sender
+        b_content += b'To: %s\n' % b_to
+        if self.cc:
+            b_content += b'Cc: %s\n' % b_cc
+        b_content += b'Subject: %s\n\n' % b_subject
+        b_content += b_body
+
+        b_addresses = b_to.split(b',')
+        if self.cc:
+            b_addresses += b_cc.split(b',')
+        if self.bcc:
+            b_addresses += b_bcc.split(b',')
+
+        for b_address in b_addresses:
+            smtp.sendmail(b_sender, b_address, b_content)
+
+        smtp.quit()
+
+    def subject_msg(self, multiline, failtype, linenr):
+        return '%s: %s' % (failtype, multiline.strip('\r\n').splitlines()[linenr])
+
+    def indent(self, multiline, indent=8):
+        return re.sub('^', ' ' * indent, multiline, flags=re.MULTILINE)
+
+    def body_blob(self, multiline, texttype):
+        ''' Turn some text output in a well-indented block for sending in a mail body '''
+        intro = 'with the following %s:\n\n' % texttype
+        blob = ''
+        for line in multiline.strip('\r\n').splitlines():
+            blob += '%s\n' % line
+        return intro + self.indent(blob) + '\n'
+
+    def mail_result(self, result, failtype):
+        host = result._host.get_name()
+        if not self.sender:
+            self.sender = '"Ansible: %s" <root>' % host
+
+        # Add subject
+        if self.itembody:
+            subject = self.itemsubject
+        elif result._result.get('failed_when_result') is True:
+            subject = "Failed due to 'failed_when' condition"
+        elif result._result.get('msg'):
+            subject = self.subject_msg(result._result['msg'], failtype, 0)
+        elif result._result.get('stderr'):
+            subject = self.subject_msg(result._result['stderr'], failtype, -1)
+        elif result._result.get('stdout'):
+            subject = self.subject_msg(result._result['stdout'], failtype, -1)
+        elif result._result.get('exception'):  # Unrelated exceptions are added to output :-/
+            subject = self.subject_msg(result._result['exception'], failtype, -1)
+        else:
+            subject = '%s: %s' % (failtype, result._task.name or result._task.action)
+
+        # Make playbook name visible (e.g. in Outlook/Gmail condensed view)
+        body = 'Playbook: %s\n' % os.path.basename(self.playbook._file_name)
+        if result._task.name:
+            body += 'Task: %s\n' % result._task.name
+        body += 'Module: %s\n' % result._task.action
+        body += 'Host: %s\n' % host
+        body += '\n'
+
+        # Add task information (as much as possible)
+        body += 'The following task failed:\n\n'
+        if 'invocation' in result._result:
+            body += self.indent('%s: %s\n' % (result._task.action, json.dumps(result._result['invocation']['module_args'], indent=4)))
+        elif result._task.name:
+            body += self.indent('%s (%s)\n' % (result._task.name, result._task.action))
+        else:
+            body += self.indent('%s\n' % result._task.action)
+        body += '\n'
+
+        # Add item / message
+        if self.itembody:
+            body += self.itembody
+        elif result._result.get('failed_when_result') is True:
+            body += "due to the following condition:\n\n" + self.indent('failed_when:\n- ' + '\n- '.join(result._task.failed_when)) + '\n\n'
+        elif result._result.get('msg'):
+            body += self.body_blob(result._result['msg'], 'message')
+
+        # Add stdout / stderr / exception / warnings / deprecations
+        if result._result.get('stdout'):
+            body += self.body_blob(result._result['stdout'], 'standard output')
+        if result._result.get('stderr'):
+            body += self.body_blob(result._result['stderr'], 'error output')
+        if result._result.get('exception'):  # Unrelated exceptions are added to output :-/
+            body += self.body_blob(result._result['exception'], 'exception')
+        if result._result.get('warnings'):
+            for i in range(len(result._result.get('warnings'))):
+                body += self.body_blob(result._result['warnings'][i], 'exception %d' % (i + 1))
+        if result._result.get('deprecations'):
+            for i in range(len(result._result.get('deprecations'))):
+                body += self.body_blob(result._result['deprecations'][i], 'exception %d' % (i + 1))
+
+        body += 'and a complete dump of the error:\n\n'
+        body += self.indent('%s: %s' % (failtype, json.dumps(result._result, cls=AnsibleJSONEncoder, indent=4)))
+
+        self.mail(subject=subject, body=body)
+
+    def v2_playbook_on_start(self, playbook):
+        self.playbook = playbook
+        self.itembody = ''
+
+    def v2_runner_on_failed(self, result, ignore_errors=False):
+        if ignore_errors:
+            return
+
+        self.mail_result(result, 'Failed')
+
+    def v2_runner_on_unreachable(self, result):
+        self.mail_result(result, 'Unreachable')
+
+    def v2_runner_on_async_failed(self, result):
+        self.mail_result(result, 'Async failure')
+
+    def v2_runner_item_on_failed(self, result):
+        # Pass item information to task failure
+        self.itemsubject = result._result['msg']
+        self.itembody += self.body_blob(json.dumps(result._result, cls=AnsibleJSONEncoder, indent=4), "failed item dump '%(item)s'" % result._result)

plugins/callback/nrdp.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+# (c) 2018 Remi Verchere <remi@verchere.fr>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: nrdp
+    type: notification
+    author: "Remi VERCHERE (@rverchere)"
+    short_description: post task result to a nagios server through nrdp
+    description:
+        - this callback send playbook result to nagios
+        - nagios shall use NRDP to recive passive events
+        - the passive check is sent to a dedicated host/service for ansible
+    options:
+        url:
+            description: url of the nrdp server
+            required: True
+            env:
+                - name : NRDP_URL
+            ini:
+                - section: callback_nrdp
+                  key: url
+        validate_certs:
+            description: (bool) validate the SSL certificate of the nrdp server. (For HTTPS url)
+            env:
+                - name: NRDP_VALIDATE_CERTS
+            ini:
+                - section: callback_nrdp
+                  key: validate_nrdp_certs
+                - section: callback_nrdp
+                  key: validate_certs
+            default: False
+            aliases: [ validate_nrdp_certs ]
+        token:
+            description: token to be allowed to push nrdp events
+            required: True
+            env:
+                - name: NRDP_TOKEN
+            ini:
+                - section: callback_nrdp
+                  key: token
+        hostname:
+            description: hostname where the passive check is linked to
+            required: True
+            env:
+                - name : NRDP_HOSTNAME
+            ini:
+                - section: callback_nrdp
+                  key: hostname
+        servicename:
+            description: service where the passive check is linked to
+            required: True
+            env:
+                - name : NRDP_SERVICENAME
+            ini:
+                - section: callback_nrdp
+                  key: servicename
+'''
+
+import os
+import json
+
+from ansible.module_utils.six.moves.urllib.parse import urlencode
+from ansible.module_utils.urls import open_url
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+    '''
+    send ansible-playbook to Nagios server using nrdp protocol
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.nrdp'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    # Nagios states
+    OK = 0
+    WARNING = 1
+    CRITICAL = 2
+    UNKNOWN = 3
+
+    def __init__(self):
+        super(CallbackModule, self).__init__()
+
+        self.printed_playbook = False
+        self.playbook_name = None
+        self.play = None
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.url = self.get_option('url')
+        if not self.url.endswith('/'):
+            self.url += '/'
+        self.token = self.get_option('token')
+        self.hostname = self.get_option('hostname')
+        self.servicename = self.get_option('servicename')
+        self.validate_nrdp_certs = self.get_option('validate_certs')
+
+        if (self.url or self.token or self.hostname or
+                self.servicename) is None:
+            self._display.warning("NRDP callback wants the NRDP_URL,"
+                                  " NRDP_TOKEN, NRDP_HOSTNAME,"
+                                  " NRDP_SERVICENAME"
+                                  " environment variables'."
+                                  " The NRDP callback plugin is disabled.")
+            self.disabled = True
+
+    def _send_nrdp(self, state, msg):
+        '''
+        nrpd service check send XMLDATA like this:
+        <?xml version='1.0'?>
+            <checkresults>
+                <checkresult type='service'>
+                    <hostname>somehost</hostname>
+                    <servicename>someservice</servicename>
+                    <state>1</state>
+                    <output>WARNING: Danger Will Robinson!|perfdata</output>
+                </checkresult>
+            </checkresults>
+        '''
+        xmldata = "<?xml version='1.0'?>\n"
+        xmldata += "<checkresults>\n"
+        xmldata += "<checkresult type='service'>\n"
+        xmldata += "<hostname>%s</hostname>\n" % self.hostname
+        xmldata += "<servicename>%s</servicename>\n" % self.servicename
+        xmldata += "<state>%d</state>\n" % state
+        xmldata += "<output>%s</output>\n" % msg
+        xmldata += "</checkresult>\n"
+        xmldata += "</checkresults>\n"
+
+        body = {
+            'cmd': 'submitcheck',
+            'token': self.token,
+            'XMLDATA': bytes(xmldata)
+        }
+
+        try:
+            response = open_url(self.url,
+                                data=urlencode(body),
+                                method='POST',
+                                validate_certs=self.validate_nrdp_certs)
+            return response.read()
+        except Exception as ex:
+            self._display.warning("NRDP callback cannot send result {0}".format(ex))
+
+    def v2_playbook_on_play_start(self, play):
+        '''
+        Display Playbook and play start messages
+        '''
+        self.play = play
+
+    def v2_playbook_on_stats(self, stats):
+        '''
+        Display info about playbook statistics
+        '''
+        name = self.play
+        gstats = ""
+        hosts = sorted(stats.processed.keys())
+        critical = warning = 0
+        for host in hosts:
+            stat = stats.summarize(host)
+            gstats += "'%s_ok'=%d '%s_changed'=%d \
+                       '%s_unreachable'=%d '%s_failed'=%d " % \
+                (host, stat['ok'], host, stat['changed'],
+                 host, stat['unreachable'], host, stat['failures'])
+            # Critical when failed tasks or unreachable host
+            critical += stat['failures']
+            critical += stat['unreachable']
+            # Warning when changed tasks
+            warning += stat['changed']
+
+        msg = "%s | %s" % (name, gstats)
+        if critical:
+            # Send Critical
+            self._send_nrdp(self.CRITICAL, msg)
+        elif warning:
+            # Send Warning
+            self._send_nrdp(self.WARNING, msg)
+        else:
+            # Send OK
+            self._send_nrdp(self.OK, msg)

plugins/callback/null.py

@@ -0,0 +1,29 @@
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: 'null'
+    callback_type: stdout
+    requirements:
+      - set as main display callback
+    short_description: Don't display stuff to screen
+    description:
+        - This callback prevents outputing events to screen
+'''
+
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+
+    '''
+    This callback wont print messages to stdout when new callback events are received.
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.null'

plugins/callback/osx_say.py

@@ -0,0 +1 @@
+say.py

plugins/callback/say.py

@@ -0,0 +1,113 @@
+# (c) 2012, Michael DeHaan, <michael.dehaan@gmail.com>
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: say
+    type: notification
+    requirements:
+      - whitelisting in configuration
+      - the '/usr/bin/say' command line program (standard on macOS) or 'espeak' command line program
+    short_description: notify using software speech synthesizer
+    description:
+      - This plugin will use the 'say' or 'espeak' program to "speak" about play events.
+    notes:
+      - In 2.8, this callback has been renamed from C(osx_say) into M(say).
+'''
+
+import distutils.spawn
+import platform
+import subprocess
+import os
+
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+    """
+    makes Ansible much more exciting.
+    """
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.say'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self):
+
+        super(CallbackModule, self).__init__()
+
+        self.FAILED_VOICE = None
+        self.REGULAR_VOICE = None
+        self.HAPPY_VOICE = None
+        self.LASER_VOICE = None
+
+        self.synthesizer = distutils.spawn.find_executable('say')
+        if not self.synthesizer:
+            self.synthesizer = distutils.spawn.find_executable('espeak')
+            if self.synthesizer:
+                self.FAILED_VOICE = 'klatt'
+                self.HAPPY_VOICE = 'f5'
+                self.LASER_VOICE = 'whisper'
+        elif platform.system() != 'Darwin':
+            # 'say' binary available, it might be GNUstep tool which doesn't support 'voice' parameter
+            self._display.warning("'say' executable found but system is '%s': ignoring voice parameter" % platform.system())
+        else:
+            self.FAILED_VOICE = 'Zarvox'
+            self.REGULAR_VOICE = 'Trinoids'
+            self.HAPPY_VOICE = 'Cellos'
+            self.LASER_VOICE = 'Princess'
+
+        # plugin disable itself if say is not present
+        # ansible will not call any callback if disabled is set to True
+        if not self.synthesizer:
+            self.disabled = True
+            self._display.warning("Unable to find either 'say' or 'espeak' executable, plugin %s disabled" % os.path.basename(__file__))
+
+    def say(self, msg, voice):
+        cmd = [self.synthesizer, msg]
+        if voice:
+            cmd.extend(('-v', voice))
+        subprocess.call(cmd)
+
+    def runner_on_failed(self, host, res, ignore_errors=False):
+        self.say("Failure on host %s" % host, self.FAILED_VOICE)
+
+    def runner_on_ok(self, host, res):
+        self.say("pew", self.LASER_VOICE)
+
+    def runner_on_skipped(self, host, item=None):
+        self.say("pew", self.LASER_VOICE)
+
+    def runner_on_unreachable(self, host, res):
+        self.say("Failure on host %s" % host, self.FAILED_VOICE)
+
+    def runner_on_async_ok(self, host, res, jid):
+        self.say("pew", self.LASER_VOICE)
+
+    def runner_on_async_failed(self, host, res, jid):
+        self.say("Failure on host %s" % host, self.FAILED_VOICE)
+
+    def playbook_on_start(self):
+        self.say("Running Playbook", self.REGULAR_VOICE)
+
+    def playbook_on_notify(self, host, handler):
+        self.say("pew", self.LASER_VOICE)
+
+    def playbook_on_task_start(self, name, is_conditional):
+        if not is_conditional:
+            self.say("Starting task: %s" % name, self.REGULAR_VOICE)
+        else:
+            self.say("Notifying task: %s" % name, self.REGULAR_VOICE)
+
+    def playbook_on_setup(self):
+        self.say("Gathering facts", self.REGULAR_VOICE)
+
+    def playbook_on_play_start(self, name):
+        self.say("Starting play: %s" % name, self.HAPPY_VOICE)
+
+    def playbook_on_stats(self, stats):
+        self.say("Play complete", self.HAPPY_VOICE)

plugins/callback/selective.py

@@ -0,0 +1,275 @@
+# (c) Fastly, inc 2016
+# (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
+
+DOCUMENTATION = '''
+    callback: selective
+    callback_type: stdout
+    requirements:
+      - set as main display callback
+    short_description: only print certain tasks
+    description:
+      - This callback only prints tasks that have been tagged with `print_action` or that have failed.
+        This allows operators to focus on the tasks that provide value only.
+      - Tasks that are not printed are placed with a '.'.
+      - If you increase verbosity all tasks are printed.
+    options:
+      nocolor:
+        default: False
+        description: This setting allows suppressing colorizing output
+        env:
+          - name: ANSIBLE_NOCOLOR
+          - name: ANSIBLE_SELECTIVE_DONT_COLORIZE
+        ini:
+          - section: defaults
+            key: nocolor
+        type: boolean
+'''
+
+EXAMPLES = """
+  - debug: msg="This will not be printed"
+  - debug: msg="But this will"
+    tags: [print_action]
+"""
+
+import difflib
+
+from ansible import constants as C
+from ansible.plugins.callback import CallbackBase
+from ansible.module_utils._text import to_text
+from ansible.utils.color import codeCodes
+
+DONT_COLORIZE = False
+COLORS = {
+    'normal': '\033[0m',
+    'ok': '\033[{0}m'.format(codeCodes[C.COLOR_OK]),
+    'bold': '\033[1m',
+    'not_so_bold': '\033[1m\033[34m',
+    'changed': '\033[{0}m'.format(codeCodes[C.COLOR_CHANGED]),
+    'failed': '\033[{0}m'.format(codeCodes[C.COLOR_ERROR]),
+    'endc': '\033[0m',
+    'skipped': '\033[{0}m'.format(codeCodes[C.COLOR_SKIP]),
+}
+
+
+def dict_diff(prv, nxt):
+    """Return a dict of keys that differ with another config object."""
+    keys = set(prv.keys() + nxt.keys())
+    result = {}
+    for k in keys:
+        if prv.get(k) != nxt.get(k):
+            result[k] = (prv.get(k), nxt.get(k))
+    return result
+
+
+def colorize(msg, color):
+    """Given a string add necessary codes to format the string."""
+    if DONT_COLORIZE:
+        return msg
+    else:
+        return '{0}{1}{2}'.format(COLORS[color], msg, COLORS['endc'])
+
+
+class CallbackModule(CallbackBase):
+    """selective.py callback plugin."""
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.selective'
+
+    def __init__(self, display=None):
+        """selective.py callback plugin."""
+        super(CallbackModule, self).__init__(display)
+        self.last_skipped = False
+        self.last_task_name = None
+        self.printed_last_task = False
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        global DONT_COLORIZE
+        DONT_COLORIZE = self.get_option('nocolor')
+
+    def _print_task(self, task_name=None):
+        if task_name is None:
+            task_name = self.last_task_name
+
+        if not self.printed_last_task:
+            self.printed_last_task = True
+            line_length = 120
+            if self.last_skipped:
+                print()
+            msg = colorize("# {0} {1}".format(task_name,
+                                              '*' * (line_length - len(task_name))), 'bold')
+            print(msg)
+
+    def _indent_text(self, text, indent_level):
+        lines = text.splitlines()
+        result_lines = []
+        for l in lines:
+            result_lines.append("{0}{1}".format(' ' * indent_level, l))
+        return '\n'.join(result_lines)
+
+    def _print_diff(self, diff, indent_level):
+        if isinstance(diff, dict):
+            try:
+                diff = '\n'.join(difflib.unified_diff(diff['before'].splitlines(),
+                                                      diff['after'].splitlines(),
+                                                      fromfile=diff.get('before_header',
+                                                                        'new_file'),
+                                                      tofile=diff['after_header']))
+            except AttributeError:
+                diff = dict_diff(diff['before'], diff['after'])
+        if diff:
+            diff = colorize(str(diff), 'changed')
+            print(self._indent_text(diff, indent_level + 4))
+
+    def _print_host_or_item(self, host_or_item, changed, msg, diff, is_host, error, stdout, stderr):
+        if is_host:
+            indent_level = 0
+            name = colorize(host_or_item.name, 'not_so_bold')
+        else:
+            indent_level = 4
+            if isinstance(host_or_item, dict):
+                if 'key' in host_or_item.keys():
+                    host_or_item = host_or_item['key']
+            name = colorize(to_text(host_or_item), 'bold')
+
+        if error:
+            color = 'failed'
+            change_string = colorize('FAILED!!!', color)
+        else:
+            color = 'changed' if changed else 'ok'
+            change_string = colorize("changed={0}".format(changed), color)
+
+        msg = colorize(msg, color)
+
+        line_length = 120
+        spaces = ' ' * (40 - len(name) - indent_level)
+        line = "{0}  * {1}{2}- {3}".format(' ' * indent_level, name, spaces, change_string)
+
+        if len(msg) < 50:
+            line += ' -- {0}'.format(msg)
+            print("{0} {1}---------".format(line, '-' * (line_length - len(line))))
+        else:
+            print("{0} {1}".format(line, '-' * (line_length - len(line))))
+            print(self._indent_text(msg, indent_level + 4))
+
+        if diff:
+            self._print_diff(diff, indent_level)
+        if stdout:
+            stdout = colorize(stdout, 'failed')
+            print(self._indent_text(stdout, indent_level + 4))
+        if stderr:
+            stderr = colorize(stderr, 'failed')
+            print(self._indent_text(stderr, indent_level + 4))
+
+    def v2_playbook_on_play_start(self, play):
+        """Run on start of the play."""
+        pass
+
+    def v2_playbook_on_task_start(self, task, **kwargs):
+        """Run when a task starts."""
+        self.last_task_name = task.get_name()
+        self.printed_last_task = False
+
+    def _print_task_result(self, result, error=False, **kwargs):
+        """Run when a task finishes correctly."""
+
+        if 'print_action' in result._task.tags or error or self._display.verbosity > 1:
+            self._print_task()
+            self.last_skipped = False
+            msg = to_text(result._result.get('msg', '')) or\
+                to_text(result._result.get('reason', ''))
+
+            stderr = [result._result.get('exception', None),
+                      result._result.get('module_stderr', None)]
+            stderr = "\n".join([e for e in stderr if e]).strip()
+
+            self._print_host_or_item(result._host,
+                                     result._result.get('changed', False),
+                                     msg,
+                                     result._result.get('diff', None),
+                                     is_host=True,
+                                     error=error,
+                                     stdout=result._result.get('module_stdout', None),
+                                     stderr=stderr.strip(),
+                                     )
+            if 'results' in result._result:
+                for r in result._result['results']:
+                    failed = 'failed' in r
+
+                    stderr = [r.get('exception', None), r.get('module_stderr', None)]
+                    stderr = "\n".join([e for e in stderr if e]).strip()
+
+                    self._print_host_or_item(r['item'],
+                                             r.get('changed', False),
+                                             to_text(r.get('msg', '')),
+                                             r.get('diff', None),
+                                             is_host=False,
+                                             error=failed,
+                                             stdout=r.get('module_stdout', None),
+                                             stderr=stderr.strip(),
+                                             )
+        else:
+            self.last_skipped = True
+            print('.', end="")
+
+    def v2_playbook_on_stats(self, stats):
+        """Display info about playbook statistics."""
+        print()
+        self.printed_last_task = False
+        self._print_task('STATS')
+
+        hosts = sorted(stats.processed.keys())
+        for host in hosts:
+            s = stats.summarize(host)
+
+            if s['failures'] or s['unreachable']:
+                color = 'failed'
+            elif s['changed']:
+                color = 'changed'
+            else:
+                color = 'ok'
+
+            msg = '{0}    : ok={1}\tchanged={2}\tfailed={3}\tunreachable={4}\trescued={5}\tignored={6}'.format(
+                host, s['ok'], s['changed'], s['failures'], s['unreachable'], s['rescued'], s['ignored'])
+            print(colorize(msg, color))
+
+    def v2_runner_on_skipped(self, result, **kwargs):
+        """Run when a task is skipped."""
+        if self._display.verbosity > 1:
+            self._print_task()
+            self.last_skipped = False
+
+            line_length = 120
+            spaces = ' ' * (31 - len(result._host.name) - 4)
+
+            line = "  * {0}{1}- {2}".format(colorize(result._host.name, 'not_so_bold'),
+                                            spaces,
+                                            colorize("skipped", 'skipped'),)
+
+            reason = result._result.get('skipped_reason', '') or \
+                result._result.get('skip_reason', '')
+            if len(reason) < 50:
+                line += ' -- {0}'.format(reason)
+                print("{0} {1}---------".format(line, '-' * (line_length - len(line))))
+            else:
+                print("{0} {1}".format(line, '-' * (line_length - len(line))))
+                print(self._indent_text(reason, 8))
+                print(reason)
+
+    def v2_runner_on_ok(self, result, **kwargs):
+        self._print_task_result(result, error=False, **kwargs)
+
+    def v2_runner_on_failed(self, result, **kwargs):
+        self._print_task_result(result, error=True, **kwargs)
+
+    def v2_runner_on_unreachable(self, result, **kwargs):
+        self._print_task_result(result, error=True, **kwargs)
+
+    v2_playbook_on_handler_task_start = v2_playbook_on_task_start

plugins/callback/slack.py

@@ -0,0 +1,250 @@
+# (C) 2014-2015, Matt Martz <matt@sivel.net>
+# (C) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: slack
+    callback_type: notification
+    requirements:
+      - whitelist in configuration
+      - prettytable (python library)
+    short_description: Sends play events to a Slack channel
+    description:
+        - This is an ansible callback plugin that sends status updates to a Slack channel during playbook execution.
+        - Before 2.4 only environment variables were available for configuring this plugin
+    options:
+      webhook_url:
+        required: True
+        description: Slack Webhook URL
+        env:
+          - name: SLACK_WEBHOOK_URL
+        ini:
+          - section: callback_slack
+            key: webhook_url
+      channel:
+        default: "#ansible"
+        description: Slack room to post in.
+        env:
+          - name: SLACK_CHANNEL
+        ini:
+          - section: callback_slack
+            key: channel
+      username:
+        description: Username to post as.
+        env:
+          - name: SLACK_USERNAME
+        default: ansible
+        ini:
+          - section: callback_slack
+            key: username
+      validate_certs:
+        description: validate the SSL certificate of the Slack server. (For HTTPS URLs)
+        env:
+          - name: SLACK_VALIDATE_CERTS
+        ini:
+          - section: callback_slack
+            key: validate_certs
+        default: True
+        type: bool
+'''
+
+import json
+import os
+import uuid
+
+from ansible import context
+from ansible.module_utils._text import to_text
+from ansible.module_utils.urls import open_url
+from ansible.plugins.callback import CallbackBase
+
+try:
+    import prettytable
+    HAS_PRETTYTABLE = True
+except ImportError:
+    HAS_PRETTYTABLE = False
+
+
+class CallbackModule(CallbackBase):
+    """This is an ansible callback plugin that sends status
+    updates to a Slack channel during playbook execution.
+    """
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'notification'
+    CALLBACK_NAME = 'community.general.slack'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+
+        super(CallbackModule, self).__init__(display=display)
+
+        if not HAS_PRETTYTABLE:
+            self.disabled = True
+            self._display.warning('The `prettytable` python module is not '
+                                  'installed. Disabling the Slack callback '
+                                  'plugin.')
+
+        self.playbook_name = None
+
+        # This is a 6 character identifier provided with each message
+        # This makes it easier to correlate messages when there are more
+        # than 1 simultaneous playbooks running
+        self.guid = uuid.uuid4().hex[:6]
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.webhook_url = self.get_option('webhook_url')
+        self.channel = self.get_option('channel')
+        self.username = self.get_option('username')
+        self.show_invocation = (self._display.verbosity > 1)
+        self.validate_certs = self.get_option('validate_certs')
+
+        if self.webhook_url is None:
+            self.disabled = True
+            self._display.warning('Slack Webhook URL was not provided. The '
+                                  'Slack Webhook URL can be provided using '
+                                  'the `SLACK_WEBHOOK_URL` environment '
+                                  'variable.')
+
+    def send_msg(self, attachments):
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        payload = {
+            'channel': self.channel,
+            'username': self.username,
+            'attachments': attachments,
+            'parse': 'none',
+            'icon_url': ('https://cdn2.hubspot.net/hub/330046/'
+                         'file-449187601-png/ansible_badge.png'),
+        }
+
+        data = json.dumps(payload)
+        self._display.debug(data)
+        self._display.debug(self.webhook_url)
+        try:
+            response = open_url(self.webhook_url, data=data, validate_certs=self.validate_certs,
+                                headers=headers)
+            return response.read()
+        except Exception as e:
+            self._display.warning(u'Could not submit message to Slack: %s' %
+                                  to_text(e))
+
+    def v2_playbook_on_start(self, playbook):
+        self.playbook_name = os.path.basename(playbook._file_name)
+
+        title = [
+            '*Playbook initiated* (_%s_)' % self.guid
+        ]
+
+        invocation_items = []
+        if context.CLIARGS and self.show_invocation:
+            tags = context.CLIARGS['tags']
+            skip_tags = context.CLIARGS['skip_tags']
+            extra_vars = context.CLIARGS['extra_vars']
+            subset = context.CLIARGS['subset']
+            inventory = [os.path.abspath(i) for i in context.CLIARGS['inventory']]
+
+            invocation_items.append('Inventory:  %s' % ', '.join(inventory))
+            if tags and tags != ['all']:
+                invocation_items.append('Tags:       %s' % ', '.join(tags))
+            if skip_tags:
+                invocation_items.append('Skip Tags:  %s' % ', '.join(skip_tags))
+            if subset:
+                invocation_items.append('Limit:      %s' % subset)
+            if extra_vars:
+                invocation_items.append('Extra Vars: %s' %
+                                        ' '.join(extra_vars))
+
+            title.append('by *%s*' % context.CLIARGS['remote_user'])
+
+        title.append('\n\n*%s*' % self.playbook_name)
+        msg_items = [' '.join(title)]
+        if invocation_items:
+            msg_items.append('```\n%s\n```' % '\n'.join(invocation_items))
+
+        msg = '\n'.join(msg_items)
+
+        attachments = [{
+            'fallback': msg,
+            'fields': [
+                {
+                    'value': msg
+                }
+            ],
+            'color': 'warning',
+            'mrkdwn_in': ['text', 'fallback', 'fields'],
+        }]
+
+        self.send_msg(attachments=attachments)
+
+    def v2_playbook_on_play_start(self, play):
+        """Display Play start messages"""
+
+        name = play.name or 'Play name not specified (%s)' % play._uuid
+        msg = '*Starting play* (_%s_)\n\n*%s*' % (self.guid, name)
+        attachments = [
+            {
+                'fallback': msg,
+                'text': msg,
+                'color': 'warning',
+                'mrkdwn_in': ['text', 'fallback', 'fields'],
+            }
+        ]
+        self.send_msg(attachments=attachments)
+
+    def v2_playbook_on_stats(self, stats):
+        """Display info about playbook statistics"""
+
+        hosts = sorted(stats.processed.keys())
+
+        t = prettytable.PrettyTable(['Host', 'Ok', 'Changed', 'Unreachable',
+                                     'Failures', 'Rescued', 'Ignored'])
+
+        failures = False
+        unreachable = False
+
+        for h in hosts:
+            s = stats.summarize(h)
+
+            if s['failures'] > 0:
+                failures = True
+            if s['unreachable'] > 0:
+                unreachable = True
+
+            t.add_row([h] + [s[k] for k in ['ok', 'changed', 'unreachable',
+                                            'failures', 'rescued', 'ignored']])
+
+        attachments = []
+        msg_items = [
+            '*Playbook Complete* (_%s_)' % self.guid
+        ]
+        if failures or unreachable:
+            color = 'danger'
+            msg_items.append('\n*Failed!*')
+        else:
+            color = 'good'
+            msg_items.append('\n*Success!*')
+
+        msg_items.append('```\n%s\n```' % t)
+
+        msg = '\n'.join(msg_items)
+
+        attachments.append({
+            'fallback': msg,
+            'fields': [
+                {
+                    'value': msg
+                }
+            ],
+            'color': color,
+            'mrkdwn_in': ['text', 'fallback', 'fields']
+        })
+
+        self.send_msg(attachments=attachments)

plugins/callback/splunk.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+# 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 <http://www.gnu.org/licenses/>.
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: splunk
+    type: aggregate
+    short_description: Sends task result events to Splunk HTTP Event Collector
+    author: "Stuart Hirst <support@convergingdata.com>"
+    description:
+      - This callback plugin will send task results as JSON formatted events to a Splunk HTTP collector.
+      - The companion Splunk Monitoring & Diagnostics App is available here "https://splunkbase.splunk.com/app/4023/"
+      - Credit to "Ryan Currah (@ryancurrah)" for original source upon which this is based.
+    requirements:
+      - Whitelisting this callback plugin
+      - 'Create a HTTP Event Collector in Splunk'
+      - 'Define the url and token in ansible.cfg'
+    options:
+      url:
+        description: URL to the Splunk HTTP collector source
+        env:
+          - name: SPLUNK_URL
+        ini:
+          - section: callback_splunk
+            key: url
+      authtoken:
+        description: Token to authenticate the connection to the Splunk HTTP collector
+        env:
+          - name: SPLUNK_AUTHTOKEN
+        ini:
+          - section: callback_splunk
+            key: authtoken
+'''
+
+EXAMPLES = '''
+examples: >
+  To enable, add this to your ansible.cfg file in the defaults block
+    [defaults]
+    callback_whitelist = splunk
+  Set the environment variable
+    export SPLUNK_URL=http://mysplunkinstance.datapaas.io:8088/services/collector/event
+    export SPLUNK_AUTHTOKEN=f23blad6-5965-4537-bf69-5b5a545blabla88
+  Set the ansible.cfg variable in the callback_splunk block
+    [callback_splunk]
+    url = http://mysplunkinstance.datapaas.io:8088/services/collector/event
+    authtoken = f23blad6-5965-4537-bf69-5b5a545blabla88
+'''
+
+import json
+import uuid
+import socket
+import getpass
+
+from datetime import datetime
+from os.path import basename
+
+from ansible.module_utils.urls import open_url
+from ansible.parsing.ajson import AnsibleJSONEncoder
+from ansible.plugins.callback import CallbackBase
+
+
+class SplunkHTTPCollectorSource(object):
+    def __init__(self):
+        self.ansible_check_mode = False
+        self.ansible_playbook = ""
+        self.ansible_version = ""
+        self.session = str(uuid.uuid4())
+        self.host = socket.gethostname()
+        self.ip_address = socket.gethostbyname(socket.gethostname())
+        self.user = getpass.getuser()
+
+    def send_event(self, url, authtoken, state, result, runtime):
+        if result._task_fields['args'].get('_ansible_check_mode') is True:
+            self.ansible_check_mode = True
+
+        if result._task_fields['args'].get('_ansible_version'):
+            self.ansible_version = \
+                result._task_fields['args'].get('_ansible_version')
+
+        if result._task._role:
+            ansible_role = str(result._task._role)
+        else:
+            ansible_role = None
+
+        if 'args' in result._task_fields:
+            del result._task_fields['args']
+
+        data = {}
+        data['uuid'] = result._task._uuid
+        data['session'] = self.session
+        data['status'] = state
+        data['timestamp'] = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S '
+                                                       '+0000')
+        data['host'] = self.host
+        data['ip_address'] = self.ip_address
+        data['user'] = self.user
+        data['runtime'] = runtime
+        data['ansible_version'] = self.ansible_version
+        data['ansible_check_mode'] = self.ansible_check_mode
+        data['ansible_host'] = result._host.name
+        data['ansible_playbook'] = self.ansible_playbook
+        data['ansible_role'] = ansible_role
+        data['ansible_task'] = result._task_fields
+        data['ansible_result'] = result._result
+
+        # This wraps the json payload in and outer json event needed by Splunk
+        jsondata = json.dumps(data, cls=AnsibleJSONEncoder, sort_keys=True)
+        jsondata = '{"event":' + jsondata + "}"
+
+        open_url(
+            url,
+            jsondata,
+            headers={
+                'Content-type': 'application/json',
+                'Authorization': 'Splunk ' + authtoken
+            },
+            method='POST'
+        )
+
+
+class CallbackModule(CallbackBase):
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.splunk'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+        super(CallbackModule, self).__init__(display=display)
+        self.start_datetimes = {}  # Collect task start times
+        self.url = None
+        self.authtoken = None
+        self.splunk = SplunkHTTPCollectorSource()
+
+    def _runtime(self, result):
+        return (
+            datetime.utcnow() -
+            self.start_datetimes[result._task._uuid]
+        ).total_seconds()
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.url = self.get_option('url')
+
+        if self.url is None:
+            self.disabled = True
+            self._display.warning('Splunk HTTP collector source URL was '
+                                  'not provided. The Splunk HTTP collector '
+                                  'source URL can be provided using the '
+                                  '`SPLUNK_URL` environment variable or '
+                                  'in the ansible.cfg file.')
+
+        self.authtoken = self.get_option('authtoken')
+
+        if self.authtoken is None:
+            self.disabled = True
+            self._display.warning('Splunk HTTP collector requires an authentication'
+                                  'token. The Splunk HTTP collector '
+                                  'authentication token can be provided using the '
+                                  '`SPLUNK_AUTHTOKEN` environment variable or '
+                                  'in the ansible.cfg file.')
+
+    def v2_playbook_on_start(self, playbook):
+        self.splunk.ansible_playbook = basename(playbook._file_name)
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self.start_datetimes[task._uuid] = datetime.utcnow()
+
+    def v2_playbook_on_handler_task_start(self, task):
+        self.start_datetimes[task._uuid] = datetime.utcnow()
+
+    def v2_runner_on_ok(self, result, **kwargs):
+        self.splunk.send_event(
+            self.url,
+            self.authtoken,
+            'OK',
+            result,
+            self._runtime(result)
+        )
+
+    def v2_runner_on_skipped(self, result, **kwargs):
+        self.splunk.send_event(
+            self.url,
+            self.authtoken,
+            'SKIPPED',
+            result,
+            self._runtime(result)
+        )
+
+    def v2_runner_on_failed(self, result, **kwargs):
+        self.splunk.send_event(
+            self.url,
+            self.authtoken,
+            'FAILED',
+            result,
+            self._runtime(result)
+        )
+
+    def runner_on_async_failed(self, result, **kwargs):
+        self.splunk.send_event(
+            self.url,
+            self.authtoken,
+            'FAILED',
+            result,
+            self._runtime(result)
+        )
+
+    def v2_runner_on_unreachable(self, result, **kwargs):
+        self.splunk.send_event(
+            self.url,
+            self.authtoken,
+            'UNREACHABLE',
+            result,
+            self._runtime(result)
+        )

plugins/callback/stderr.py

@@ -0,0 +1,70 @@
+# (c) 2017, Frederic Van Espen <github@freh.be>
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: stderr
+    callback_type: stdout
+    requirements:
+      - set as main display callback
+    short_description: Splits output, sending failed tasks to stderr
+    deprecated:
+        why: The 'default' callback plugin now supports this functionality
+        removed_in: '2.11'
+        alternative: "'default' callback plugin with 'display_failed_stderr = yes' option"
+    extends_documentation_fragment:
+      - default_callback
+    description:
+        - This is the stderr callback plugin, it behaves like the default callback plugin but sends error output to stderr.
+        - Also it does not output skipped host/task/item status
+'''
+
+from ansible import constants as C
+from ansible.plugins.callback.default import CallbackModule as CallbackModule_default
+
+
+class CallbackModule(CallbackModule_default):
+
+    '''
+    This is the stderr callback plugin, which reuses the default
+    callback plugin but sends error output to stderr.
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.stderr'
+
+    def __init__(self):
+
+        self.super_ref = super(CallbackModule, self)
+        self.super_ref.__init__()
+
+    def v2_runner_on_failed(self, result, ignore_errors=False):
+
+        delegated_vars = result._result.get('_ansible_delegated_vars', None)
+        self._clean_results(result._result, result._task.action)
+
+        if self._play.strategy == 'free' and self._last_task_banner != result._task._uuid:
+            self._print_task_banner(result._task)
+
+        self._handle_exception(result._result, use_stderr=True)
+        self._handle_warnings(result._result)
+
+        if result._task.loop and 'results' in result._result:
+            self._process_items(result)
+
+        else:
+            if delegated_vars:
+                self._display.display("fatal: [%s -> %s]: FAILED! => %s" % (result._host.get_name(), delegated_vars['ansible_host'],
+                                                                            self._dump_results(result._result)), color=C.COLOR_ERROR,
+                                      stderr=True)
+            else:
+                self._display.display("fatal: [%s]: FAILED! => %s" % (result._host.get_name(), self._dump_results(result._result)),
+                                      color=C.COLOR_ERROR, stderr=True)
+
+        if ignore_errors:
+            self._display.display("...ignoring", color=C.COLOR_SKIP)

plugins/callback/sumologic.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+# 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 <http://www.gnu.org/licenses/>.
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+callback: sumologic
+type: aggregate
+short_description: Sends task result events to Sumologic
+author: "Ryan Currah (@ryancurrah)"
+description:
+  - This callback plugin will send task results as JSON formatted events to a Sumologic HTTP collector source
+requirements:
+  - Whitelisting this callback plugin
+  - 'Create a HTTP collector source in Sumologic and specify a custom timestamp format of C(yyyy-MM-dd HH:mm:ss ZZZZ) and a custom timestamp locator
+    of C("timestamp": "(.*)")'
+options:
+  url:
+    description: URL to the Sumologic HTTP collector source
+    env:
+      - name: SUMOLOGIC_URL
+    ini:
+      - section: callback_sumologic
+        key: url
+'''
+
+EXAMPLES = '''
+examples: >
+  To enable, add this to your ansible.cfg file in the defaults block
+    [defaults]
+    callback_whitelist = sumologic
+
+  Set the environment variable
+    export SUMOLOGIC_URL=https://endpoint1.collection.us2.sumologic.com/receiver/v1/http/R8moSv1d8EW9LAUFZJ6dbxCFxwLH6kfCdcBfddlfxCbLuL-BN5twcTpMk__pYy_cDmp==
+
+  Set the ansible.cfg variable in the callback_sumologic block
+    [callback_sumologic]
+    url = https://endpoint1.collection.us2.sumologic.com/receiver/v1/http/R8moSv1d8EW9LAUFZJ6dbxCFxwLH6kfCdcBfddlfxCbLuL-BN5twcTpMk__pYy_cDmp==
+'''
+
+import json
+import uuid
+import socket
+import getpass
+
+from datetime import datetime
+from os.path import basename
+
+from ansible.module_utils.urls import open_url
+from ansible.parsing.ajson import AnsibleJSONEncoder
+from ansible.plugins.callback import CallbackBase
+
+
+class SumologicHTTPCollectorSource(object):
+    def __init__(self):
+        self.ansible_check_mode = False
+        self.ansible_playbook = ""
+        self.ansible_version = ""
+        self.session = str(uuid.uuid4())
+        self.host = socket.gethostname()
+        self.ip_address = socket.gethostbyname(socket.gethostname())
+        self.user = getpass.getuser()
+
+    def send_event(self, url, state, result, runtime):
+        if result._task_fields['args'].get('_ansible_check_mode') is True:
+            self.ansible_check_mode = True
+
+        if result._task_fields['args'].get('_ansible_version'):
+            self.ansible_version = \
+                result._task_fields['args'].get('_ansible_version')
+
+        if result._task._role:
+            ansible_role = str(result._task._role)
+        else:
+            ansible_role = None
+
+        if 'args' in result._task_fields:
+            del result._task_fields['args']
+
+        data = {}
+        data['uuid'] = result._task._uuid
+        data['session'] = self.session
+        data['status'] = state
+        data['timestamp'] = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S '
+                                                       '+0000')
+        data['host'] = self.host
+        data['ip_address'] = self.ip_address
+        data['user'] = self.user
+        data['runtime'] = runtime
+        data['ansible_version'] = self.ansible_version
+        data['ansible_check_mode'] = self.ansible_check_mode
+        data['ansible_host'] = result._host.name
+        data['ansible_playbook'] = self.ansible_playbook
+        data['ansible_role'] = ansible_role
+        data['ansible_task'] = result._task_fields
+        data['ansible_result'] = result._result
+
+        open_url(
+            url,
+            data=json.dumps(data, cls=AnsibleJSONEncoder, sort_keys=True),
+            headers={
+                'Content-type': 'application/json',
+                'X-Sumo-Host': data['ansible_host']
+            },
+            method='POST'
+        )
+
+
+class CallbackModule(CallbackBase):
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.sumologic'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self, display=None):
+        super(CallbackModule, self).__init__(display=display)
+        self.start_datetimes = {}  # Collect task start times
+        self.url = None
+        self.sumologic = SumologicHTTPCollectorSource()
+
+    def _runtime(self, result):
+        return (
+            datetime.utcnow() -
+            self.start_datetimes[result._task._uuid]
+        ).total_seconds()
+
+    def set_options(self, task_keys=None, var_options=None, direct=None):
+        super(CallbackModule, self).set_options(task_keys=task_keys, var_options=var_options, direct=direct)
+
+        self.url = self.get_option('url')
+
+        if self.url is None:
+            self.disabled = True
+            self._display.warning('Sumologic HTTP collector source URL was '
+                                  'not provided. The Sumologic HTTP collector '
+                                  'source URL can be provided using the '
+                                  '`SUMOLOGIC_URL` environment variable or '
+                                  'in the ansible.cfg file.')
+
+    def v2_playbook_on_start(self, playbook):
+        self.sumologic.ansible_playbook = basename(playbook._file_name)
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self.start_datetimes[task._uuid] = datetime.utcnow()
+
+    def v2_playbook_on_handler_task_start(self, task):
+        self.start_datetimes[task._uuid] = datetime.utcnow()
+
+    def v2_runner_on_ok(self, result, **kwargs):
+        self.sumologic.send_event(
+            self.url,
+            'OK',
+            result,
+            self._runtime(result)
+        )
+
+    def v2_runner_on_skipped(self, result, **kwargs):
+        self.sumologic.send_event(
+            self.url,
+            'SKIPPED',
+            result,
+            self._runtime(result)
+        )
+
+    def v2_runner_on_failed(self, result, **kwargs):
+        self.sumologic.send_event(
+            self.url,
+            'FAILED',
+            result,
+            self._runtime(result)
+        )
+
+    def runner_on_async_failed(self, result, **kwargs):
+        self.sumologic.send_event(
+            self.url,
+            'FAILED',
+            result,
+            self._runtime(result)
+        )
+
+    def v2_runner_on_unreachable(self, result, **kwargs):
+        self.sumologic.send_event(
+            self.url,
+            'UNREACHABLE',
+            result,
+            self._runtime(result)
+        )

plugins/callback/syslog_json.py

@@ -0,0 +1,104 @@
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: syslog_json
+    callback_type: notification
+    requirements:
+      - whitelist in configuration
+    short_description: sends JSON events to syslog
+    description:
+      - This plugin logs ansible-playbook and ansible runs to a syslog server in JSON format
+      - Before 2.9 only environment variables were available for configuration
+    options:
+      server:
+        description: syslog server that will receive the event
+        env:
+        - name: SYSLOG_SERVER
+        default: localhost
+        ini:
+          - section: callback_syslog_json
+            key: syslog_server
+      port:
+        description: port on which the syslog server is listening
+        env:
+          - name: SYSLOG_PORT
+        default: 514
+        ini:
+          - section: callback_syslog_json
+            key: syslog_port
+      facility:
+        description: syslog facility to log as
+        env:
+          - name: SYSLOG_FACILITY
+        default: user
+        ini:
+          - section: callback_syslog_json
+            key: syslog_facility
+'''
+
+import os
+import json
+
+import logging
+import logging.handlers
+
+import socket
+
+from ansible.plugins.callback import CallbackBase
+
+
+class CallbackModule(CallbackBase):
+    """
+    logs ansible-playbook and ansible runs to a syslog server in json format
+    """
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'aggregate'
+    CALLBACK_NAME = 'community.general.syslog_json'
+    CALLBACK_NEEDS_WHITELIST = True
+
+    def __init__(self):
+
+        super(CallbackModule, self).__init__()
+
+        self.set_options()
+
+        syslog_host = self.get_option("server")
+        syslog_port = int(self.get_option("port"))
+        syslog_facility = self.get_option("facility")
+
+        self.logger = logging.getLogger('ansible logger')
+        self.logger.setLevel(logging.DEBUG)
+
+        self.handler = logging.handlers.SysLogHandler(
+            address=(syslog_host, syslog_port),
+            facility=syslog_facility
+        )
+        self.logger.addHandler(self.handler)
+        self.hostname = socket.gethostname()
+
+    def runner_on_failed(self, host, res, ignore_errors=False):
+        self.logger.error('%s ansible-command: task execution FAILED; host: %s; message: %s', self.hostname, host, self._dump_results(res))
+
+    def runner_on_ok(self, host, res):
+        self.logger.info('%s ansible-command: task execution OK; host: %s; message: %s', self.hostname, host, self._dump_results(res))
+
+    def runner_on_skipped(self, host, item=None):
+        self.logger.info('%s ansible-command: task execution SKIPPED; host: %s; message: %s', self.hostname, host, 'skipped')
+
+    def runner_on_unreachable(self, host, res):
+        self.logger.error('%s ansible-command: task execution UNREACHABLE; host: %s; message: %s', self.hostname, host, self._dump_results(res))
+
+    def runner_on_async_failed(self, host, res, jid):
+        self.logger.error('%s ansible-command: task execution FAILED; host: %s; message: %s', self.hostname, host, self._dump_results(res))
+
+    def playbook_on_import_for_host(self, host, imported_file):
+        self.logger.info('%s ansible-command: playbook IMPORTED; host: %s; message: imported file %s', self.hostname, host, imported_file)
+
+    def playbook_on_not_import_for_host(self, host, missing_file):
+        self.logger.info('%s ansible-command: playbook NOT IMPORTED; host: %s; message: missing file %s', self.hostname, host, missing_file)

plugins/callback/unixy.py

@@ -0,0 +1,246 @@
+# Copyright: (c) 2017, Allyson Bowles <@akatch>
+# Copyright: (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: unixy
+    type: stdout
+    author: Allyson Bowles <@akatch>
+    short_description: condensed Ansible output
+    description:
+      - Consolidated Ansible output in the style of LINUX/UNIX startup logs.
+    extends_documentation_fragment:
+      - default_callback
+    requirements:
+      - set as stdout in configuration
+'''
+
+from os.path import basename
+from ansible import constants as C
+from ansible import context
+from ansible.module_utils._text import to_text
+from ansible.utils.color import colorize, hostcolor
+from ansible.plugins.callback.default import CallbackModule as CallbackModule_default
+
+
+class CallbackModule(CallbackModule_default):
+
+    '''
+    Design goals:
+    - Print consolidated output that looks like a *NIX startup log
+    - Defaults should avoid displaying unnecessary information wherever possible
+
+    TODOs:
+    - Only display task names if the task runs on at least one host
+    - Add option to display all hostnames on a single line in the appropriate result color (failures may have a separate line)
+    - Consolidate stats display
+    - Display whether run is in --check mode
+    - Don't show play name if no hosts found
+    '''
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.unixy'
+
+    def _run_is_verbose(self, result):
+        return ((self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and '_ansible_verbose_override' not in result._result)
+
+    def _get_task_display_name(self, task):
+        self.task_display_name = None
+        display_name = task.get_name().strip().split(" : ")
+
+        task_display_name = display_name[-1]
+        if task_display_name.startswith("include"):
+            return
+        else:
+            self.task_display_name = task_display_name
+
+    def _preprocess_result(self, result):
+        self.delegated_vars = result._result.get('_ansible_delegated_vars', None)
+        self._handle_exception(result._result, use_stderr=self.display_failed_stderr)
+        self._handle_warnings(result._result)
+
+    def _process_result_output(self, result, msg):
+        task_host = result._host.get_name()
+        task_result = "%s %s" % (task_host, msg)
+
+        if self._run_is_verbose(result):
+            task_result = "%s %s: %s" % (task_host, msg, self._dump_results(result._result, indent=4))
+            return task_result
+
+        if self.delegated_vars:
+            task_delegate_host = self.delegated_vars['ansible_host']
+            task_result = "%s -> %s %s" % (task_host, task_delegate_host, msg)
+
+        if result._result.get('msg') and result._result.get('msg') != "All items completed":
+            task_result += " | msg: " + to_text(result._result.get('msg'))
+
+        if result._result.get('stdout'):
+            task_result += " | stdout: " + result._result.get('stdout')
+
+        if result._result.get('stderr'):
+            task_result += " | stderr: " + result._result.get('stderr')
+
+        return task_result
+
+    def v2_playbook_on_task_start(self, task, is_conditional):
+        self._get_task_display_name(task)
+        if self.task_display_name is not None:
+            self._display.display("%s..." % self.task_display_name)
+
+    def v2_playbook_on_handler_task_start(self, task):
+        self._get_task_display_name(task)
+        if self.task_display_name is not None:
+            self._display.display("%s (via handler)... " % self.task_display_name)
+
+    def v2_playbook_on_play_start(self, play):
+        name = play.get_name().strip()
+        if name and play.hosts:
+            msg = u"\n- %s on hosts: %s -" % (name, ",".join(play.hosts))
+        else:
+            msg = u"---"
+
+        self._display.display(msg)
+
+    def v2_runner_on_skipped(self, result, ignore_errors=False):
+        if self.display_skipped_hosts:
+            self._preprocess_result(result)
+            display_color = C.COLOR_SKIP
+            msg = "skipped"
+
+            task_result = self._process_result_output(result, msg)
+            self._display.display("  " + task_result, display_color)
+        else:
+            return
+
+    def v2_runner_on_failed(self, result, ignore_errors=False):
+        self._preprocess_result(result)
+        display_color = C.COLOR_ERROR
+        msg = "failed"
+        item_value = self._get_item_label(result._result)
+        if item_value:
+            msg += " | item: %s" % (item_value,)
+
+        task_result = self._process_result_output(result, msg)
+        self._display.display("  " + task_result, display_color, stderr=self.display_failed_stderr)
+
+    def v2_runner_on_ok(self, result, msg="ok", display_color=C.COLOR_OK):
+        self._preprocess_result(result)
+
+        result_was_changed = ('changed' in result._result and result._result['changed'])
+        if result_was_changed:
+            msg = "done"
+            item_value = self._get_item_label(result._result)
+            if item_value:
+                msg += " | item: %s" % (item_value,)
+            display_color = C.COLOR_CHANGED
+            task_result = self._process_result_output(result, msg)
+            self._display.display("  " + task_result, display_color)
+        elif self.display_ok_hosts:
+            task_result = self._process_result_output(result, msg)
+            self._display.display("  " + task_result, display_color)
+
+    def v2_runner_item_on_skipped(self, result):
+        self.v2_runner_on_skipped(result)
+
+    def v2_runner_item_on_failed(self, result):
+        self.v2_runner_on_failed(result)
+
+    def v2_runner_item_on_ok(self, result):
+        self.v2_runner_on_ok(result)
+
+    def v2_runner_on_unreachable(self, result):
+        self._preprocess_result(result)
+
+        msg = "unreachable"
+        display_color = C.COLOR_UNREACHABLE
+        task_result = self._process_result_output(result, msg)
+
+        self._display.display("  " + task_result, display_color, stderr=self.display_failed_stderr)
+
+    def v2_on_file_diff(self, result):
+        if result._task.loop and 'results' in result._result:
+            for res in result._result['results']:
+                if 'diff' in res and res['diff'] and res.get('changed', False):
+                    diff = self._get_diff(res['diff'])
+                    if diff:
+                        self._display.display(diff)
+        elif 'diff' in result._result and result._result['diff'] and result._result.get('changed', False):
+            diff = self._get_diff(result._result['diff'])
+            if diff:
+                self._display.display(diff)
+
+    def v2_playbook_on_stats(self, stats):
+        self._display.display("\n- Play recap -", screen_only=True)
+
+        hosts = sorted(stats.processed.keys())
+        for h in hosts:
+            # TODO how else can we display these?
+            t = stats.summarize(h)
+
+            self._display.display(u"  %s : %s %s %s %s %s %s" % (
+                hostcolor(h, t),
+                colorize(u'ok', t['ok'], C.COLOR_OK),
+                colorize(u'changed', t['changed'], C.COLOR_CHANGED),
+                colorize(u'unreachable', t['unreachable'], C.COLOR_UNREACHABLE),
+                colorize(u'failed', t['failures'], C.COLOR_ERROR),
+                colorize(u'rescued', t['rescued'], C.COLOR_OK),
+                colorize(u'ignored', t['ignored'], C.COLOR_WARN)),
+                screen_only=True
+            )
+
+            self._display.display(u"  %s : %s %s %s %s %s %s" % (
+                hostcolor(h, t, False),
+                colorize(u'ok', t['ok'], None),
+                colorize(u'changed', t['changed'], None),
+                colorize(u'unreachable', t['unreachable'], None),
+                colorize(u'failed', t['failures'], None),
+                colorize(u'rescued', t['rescued'], None),
+                colorize(u'ignored', t['ignored'], None)),
+                log_only=True
+            )
+        if stats.custom and self.show_custom_stats:
+            self._display.banner("CUSTOM STATS: ")
+            # per host
+            # TODO: come up with 'pretty format'
+            for k in sorted(stats.custom.keys()):
+                if k == '_run':
+                    continue
+                self._display.display('\t%s: %s' % (k, self._dump_results(stats.custom[k], indent=1).replace('\n', '')))
+
+            # print per run custom stats
+            if '_run' in stats.custom:
+                self._display.display("", screen_only=True)
+                self._display.display('\tRUN: %s' % self._dump_results(stats.custom['_run'], indent=1).replace('\n', ''))
+            self._display.display("", screen_only=True)
+
+    def v2_playbook_on_no_hosts_matched(self):
+        self._display.display("  No hosts found!", color=C.COLOR_DEBUG)
+
+    def v2_playbook_on_no_hosts_remaining(self):
+        self._display.display("  Ran out of hosts!", color=C.COLOR_ERROR)
+
+    def v2_playbook_on_start(self, playbook):
+        # TODO display whether this run is happening in check mode
+        self._display.display("Executing playbook %s" % basename(playbook._file_name))
+
+        # show CLI arguments
+        if self._display.verbosity > 3:
+            if context.CLIARGS.get('args'):
+                self._display.display('Positional arguments: %s' % ' '.join(context.CLIARGS['args']),
+                                      color=C.COLOR_VERBOSE, screen_only=True)
+
+            for argument in (a for a in context.CLIARGS if a != 'args'):
+                val = context.CLIARGS[argument]
+                if val:
+                    self._display.vvvv('%s: %s' % (argument, val))
+
+    def v2_runner_retry(self, result):
+        msg = "  Retrying... (%d of %d)" % (result._result['attempts'], result._result['retries'])
+        if self._run_is_verbose(result):
+            msg += "Result was: %s" % self._dump_results(result._result)
+        self._display.display(msg, color=C.COLOR_DEBUG)

plugins/callback/yaml.py

@@ -0,0 +1,129 @@
+# (c) 2017 Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    callback: yaml
+    type: stdout
+    short_description: yaml-ized Ansible screen output
+    description:
+        - Ansible output that can be quite a bit easier to read than the
+          default JSON formatting.
+    extends_documentation_fragment:
+      - default_callback
+    requirements:
+      - set as stdout in configuration
+'''
+
+import yaml
+import json
+import re
+import string
+import sys
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible.module_utils.six import string_types
+from ansible.parsing.yaml.dumper import AnsibleDumper
+from ansible.plugins.callback import CallbackBase, strip_internal_keys, module_response_deepcopy
+from ansible.plugins.callback.default import CallbackModule as Default
+
+
+# from http://stackoverflow.com/a/15423007/115478
+def should_use_block(value):
+    """Returns true if string should be in block format"""
+    for c in u"\u000a\u000d\u001c\u001d\u001e\u0085\u2028\u2029":
+        if c in value:
+            return True
+    return False
+
+
+def my_represent_scalar(self, tag, value, style=None):
+    """Uses block style for multi-line strings"""
+    if style is None:
+        if should_use_block(value):
+            style = '|'
+            # we care more about readable than accuracy, so...
+            # ...no trailing space
+            value = value.rstrip()
+            # ...and non-printable characters
+            value = ''.join(x for x in value if x in string.printable)
+            # ...tabs prevent blocks from expanding
+            value = value.expandtabs()
+            # ...and odd bits of whitespace
+            value = re.sub(r'[\x0b\x0c\r]', '', value)
+            # ...as does trailing space
+            value = re.sub(r' +\n', '\n', value)
+        else:
+            style = self.default_style
+    node = yaml.representer.ScalarNode(tag, value, style=style)
+    if self.alias_key is not None:
+        self.represented_objects[self.alias_key] = node
+    return node
+
+
+class CallbackModule(Default):
+
+    """
+    Variation of the Default output which uses nicely readable YAML instead
+    of JSON for printing results.
+    """
+
+    CALLBACK_VERSION = 2.0
+    CALLBACK_TYPE = 'stdout'
+    CALLBACK_NAME = 'community.general.yaml'
+
+    def __init__(self):
+        super(CallbackModule, self).__init__()
+        yaml.representer.BaseRepresenter.represent_scalar = my_represent_scalar
+
+    def _dump_results(self, result, indent=None, sort_keys=True, keep_invocation=False):
+        if result.get('_ansible_no_log', False):
+            return json.dumps(dict(censored="The output has been hidden due to the fact that 'no_log: true' was specified for this result"))
+
+        # All result keys stating with _ansible_ are internal, so remove them from the result before we output anything.
+        abridged_result = strip_internal_keys(module_response_deepcopy(result))
+
+        # remove invocation unless specifically wanting it
+        if not keep_invocation and self._display.verbosity < 3 and 'invocation' in result:
+            del abridged_result['invocation']
+
+        # remove diff information from screen output
+        if self._display.verbosity < 3 and 'diff' in result:
+            del abridged_result['diff']
+
+        # remove exception from screen output
+        if 'exception' in abridged_result:
+            del abridged_result['exception']
+
+        dumped = ''
+
+        # put changed and skipped into a header line
+        if 'changed' in abridged_result:
+            dumped += 'changed=' + str(abridged_result['changed']).lower() + ' '
+            del abridged_result['changed']
+
+        if 'skipped' in abridged_result:
+            dumped += 'skipped=' + str(abridged_result['skipped']).lower() + ' '
+            del abridged_result['skipped']
+
+        # if we already have stdout, we don't need stdout_lines
+        if 'stdout' in abridged_result and 'stdout_lines' in abridged_result:
+            abridged_result['stdout_lines'] = '<omitted>'
+
+        # if we already have stderr, we don't need stderr_lines
+        if 'stderr' in abridged_result and 'stderr_lines' in abridged_result:
+            abridged_result['stderr_lines'] = '<omitted>'
+
+        if abridged_result:
+            dumped += '\n'
+            dumped += to_text(yaml.dump(abridged_result, allow_unicode=True, width=1000, Dumper=AnsibleDumper, default_flow_style=False))
+
+        # indent by a couple of spaces
+        dumped = '\n  '.join(dumped.split('\n')).rstrip()
+        return dumped
+
+    def _serialize_diff(self, diff):
+        return to_text(yaml.dump(diff, allow_unicode=True, width=1000, Dumper=AnsibleDumper, default_flow_style=False))

plugins/cliconf/aireos.py

@@ -0,0 +1,95 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: aireos
+short_description: Use aireos cliconf to run command on Cisco WLC platform
+description:
+  - This aireos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Cisco WLC network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'aireos'
+        reply = self.get('show sysinfo')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Product Version\.* (.*)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'System Name\.* (.*)', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        reply = self.get('show inventory')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'DESCR: \"(.*)\"', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running', 'startup'):
+            return self.invalid_params("fetching configuration from %s is not supported" % source)
+        if source == 'running':
+            cmd = 'show run-config commands'
+        else:
+            cmd = 'show run-config startup-commands'
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, command):
+        for cmd in chain(['config'], to_list(command), ['end']):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)
+
+    def set_cli_prompt_context(self):
+        """
+        Make sure we are in the operational cli mode
+        :return: None
+        """
+        if self._connection.connected:
+            self._update_cli_prompt_context(config_context=')#')

plugins/cliconf/apconos.py

@@ -0,0 +1,72 @@
+# (C) 2018 Red Hat Inc.
+# Copyright (C) 2019 APCON.
+#
+# GNU General Public License v3.0+
+#
+# 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.
+#
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Contains CLIConf Plugin methods for apconos Modules
+# APCON Networking
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+author: "David Li (@davidlee-ap)"
+cliconf: apconos
+short_description: Use apconos cliconf to run command on APCON network devices
+description:
+  - This apconos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from APCON network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'apconos'
+        reply = self.get(b'show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+        if data:
+            device_info['network_os_version'] = self.parse_version(data)
+            device_info['network_os_model'] = self.parse_model(data)
+
+        return device_info
+
+    def parse_version(self, data):
+        return ""
+
+    def parse_model(self, data):
+        return ""
+
+    @enable_mode
+    def get_config(self, source='running', format='text'):
+        pass
+
+    @enable_mode
+    def edit_config(self, command):
+        for cmd in chain([b'configure terminal'], to_list(command), [b'end']):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, check_all=check_all)
+
+    def get_capabilities(self):
+        return json.dumps(self.get_device_info())

plugins/cliconf/aruba.py

@@ -0,0 +1,95 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: aruba
+short_description: Use aruba cliconf to run command on Aruba platform
+description:
+  - This aruba plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Aruba network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'aruba'
+        reply = self.get('show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Version (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'^MODEL: (\S+)\),', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        reply = self.get('show hostname')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'^Hostname is (.+)', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running', 'startup'):
+            return self.invalid_params("fetching configuration from %s is not supported" % source)
+        if source == 'running':
+            cmd = 'show running-config all'
+        else:
+            cmd = 'show configuration'
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, command):
+        for cmd in chain(['configure terminal'], to_list(command), ['end']):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)
+
+    def set_cli_prompt_context(self):
+        """
+        Make sure we are in the operational cli mode
+        :return: None
+        """
+        if self._connection.connected:
+            self._update_cli_prompt_context(config_context=')#')

plugins/cliconf/ce.py

@@ -0,0 +1,121 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: ce
+short_description: Use ce cliconf to run command on HUAWEI CloudEngine platform
+description:
+  - This ce plugin provides low level abstraction apis for
+    sending and receiving CLI commands from HUAWEI CloudEngine network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'ce'
+        reply = self.get('display version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'^Huawei.+\n.+\Version\s+(\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1).strip(',')
+
+        match = re.search(r'^Huawei(.+)\n.+\(\S+\s+\S+\)', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'HUAWEI\s+(\S+)\s+uptime', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running'):
+            return self.invalid_params("fetching configuration from %s is not supported" % source)
+
+        if not flags:
+            flags = []
+
+        cmd = 'display current-configuration'
+
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, command):
+        results = []
+        for cmd in chain(['configure terminal'], to_list(command), ['end']):
+            if isinstance(cmd, dict):
+                command = cmd['command']
+                prompt = cmd['prompt']
+                answer = cmd['answer']
+                newline = cmd.get('newline', True)
+            else:
+                command = cmd
+                prompt = None
+                answer = None
+                newline = True
+
+            results.append(self.send_command(command, prompt, answer, False, newline))
+        return results[1:-1]
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)
+
+    def set_cli_prompt_context(self):
+        """
+        Make sure we are in the operational cli mode
+        :return: None
+        """
+        if self._connection.connected:
+            out = self._connection.get_prompt()
+
+            if out is None:
+                raise AnsibleConnectionFailure(message=u'cli prompt is not identified from the last received'
+                                                       u' response window: %s' % self._connection._last_recv_window)
+
+            prompt = to_text(out, errors='surrogate_then_replace').strip()
+            while prompt.endswith(']'):
+                self._connection.queue_message('vvvv', 'wrong context, sending return to device')
+                if prompt.startswith('[*'):
+                    self._connection.exec_command('clear configuration candidate')
+                self._connection.exec_command('return')
+                out = self._connection.get_prompt()
+                prompt = to_text(out, errors='surrogate_then_replace').strip()

plugins/cliconf/cnos.py

@@ -0,0 +1,135 @@
+# (C) 2017 Red Hat Inc.
+# Copyright (C) 2017 Lenovo.
+#
+# GNU General Public License v3.0+
+#
+# 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.
+#
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Contains CLIConf Plugin methods for CNOS Modules
+# Lenovo Networking
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: cnos
+short_description: Use cnos cliconf to run command on Lenovo CNOS platform
+description:
+  - This cnos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Lenovo CNOS network devices.
+'''
+
+import re
+import json
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils.common._collections_compat import Mapping
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'cnos'
+        reply = self.get('show sys-info')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+        host = self.get('show hostname')
+        hostname = to_text(host, errors='surrogate_or_strict').strip()
+        if data:
+            device_info['network_os_version'] = self.parse_version(data)
+            device_info['network_os_model'] = self.parse_model(data)
+            device_info['network_os_hostname'] = hostname
+
+        return device_info
+
+    def parse_version(self, data):
+        for line in data.split('\n'):
+            line = line.strip()
+            match = re.match(r'System Software Revision (.*?)',
+                             line, re.M | re.I)
+            if match:
+                vers = line.split(':')
+                ver = vers[1].strip()
+                return ver
+        return "NA"
+
+    def parse_model(self, data):
+        for line in data.split('\n'):
+            line = line.strip()
+            match = re.match(r'System Model (.*?)', line, re.M | re.I)
+            if match:
+                mdls = line.split(':')
+                mdl = mdls[1].strip()
+                return mdl
+        return "NA"
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running', 'startup'):
+            msg = "fetching configuration from %s is not supported"
+            return self.invalid_params(msg % source)
+        if source == 'running':
+            cmd = 'show running-config'
+        else:
+            cmd = 'show startup-config'
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, candidate=None, commit=True,
+                    replace=None, comment=None):
+        resp = {}
+        results = []
+        requests = []
+        if commit:
+            self.send_command('configure terminal')
+            for line in to_list(candidate):
+                if not isinstance(line, Mapping):
+                    line = {'command': line}
+
+                cmd = line['command']
+                if cmd != 'end' and cmd[0] != '!':
+                    results.append(self.send_command(**line))
+                    requests.append(cmd)
+
+            self.send_command('end')
+        else:
+            raise ValueError('check mode is not supported')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)
+
+    def set_cli_prompt_context(self):
+        """
+        Make sure we are in the operational cli mode
+        :return: None
+        """
+        if self._connection.connected:
+            out = self._connection.get_prompt()
+
+            if out is None:
+                raise AnsibleConnectionFailure(message=u'cli prompt is not identified from the last received'
+                                                       u' response window: %s' % self._connection._last_recv_window)
+
+            if to_text(out, errors='surrogate_then_replace').strip().endswith(')#'):
+                self._connection.queue_message('vvvv', 'In Config mode, sending exit to device')
+                self._connection.send_command('exit')
+            else:
+                self._connection.send_command('enable')

plugins/cliconf/edgeos.py

@@ -0,0 +1,114 @@
+# Copyright: (c) 2018, 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
+
+DOCUMENTATION = '''
+---
+cliconf: edgeos
+short_description: Use edgeos cliconf to run command on EdgeOS platform
+description:
+  - This edgeos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Ubiquiti EdgeOS network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible.module_utils.common._collections_compat import Mapping
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'edgeos'
+        reply = self.get('show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Version:\s*v?(\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'HW model:\s*(\S+)', data)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        reply = self.get('show host name')
+        device_info['network_os_hostname'] = to_text(reply, errors='surrogate_or_strict').strip()
+
+        return device_info
+
+    def get_config(self, source='running', format='text', flags=None):
+        return self.send_command('show configuration commands')
+
+    def edit_config(self, candidate=None, commit=True, replace=False, comment=None):
+        for cmd in chain(['configure'], to_list(candidate)):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def commit(self, comment=None):
+        if comment:
+            command = 'commit comment "{0}"'.format(comment)
+        else:
+            command = 'commit'
+        self.send_command(command)
+
+    def discard_changes(self, *args, **kwargs):
+        self.send_command('discard')
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                raise ValueError("'output' value %s is not supported for run_commands" % output)
+
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc:
+                    raise
+                out = getattr(e, 'err', e)
+
+            responses.append(out)
+
+        return responses
+
+    def get_device_operations(self):
+        return {
+            'supports_diff_replace': False,
+            'supports_commit': True,
+            'supports_rollback': False,
+            'supports_defaults': False,
+            'supports_onbox_diff': False,
+            'supports_commit_comment': True,
+            'supports_multiline_delimiter': False,
+            'supports_diff_match': False,
+            'supports_diff_ignore_lines': False,
+            'supports_generate_diff': False,
+            'supports_replace': False
+        }
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        result['rpc'] += ['commit', 'discard_changes', 'run_commands']
+        result['device_operations'] = self.get_device_operations()
+        return json.dumps(result)

plugins/cliconf/edgeswitch.py

@@ -0,0 +1,141 @@
+#
+# (c) 2018 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: edgeswitch
+short_description: Use edgeswitch cliconf to run command on EdgeSwitch platform
+description:
+  - This edgeswitch plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Ubiquiti EdgeSwitch network devices.
+'''
+
+import re
+import time
+import json
+
+from itertools import chain
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import dumps
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+from ansible.module_utils.common._collections_compat import Mapping
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'edgeswitch'
+        reply = self.get(command='show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Software Version\.+ (.*)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1).strip(',')
+
+        match = re.search(r'^Machine Model\.+ (.*)', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'System Name\.+ (.*)', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', flags=None):
+        if source not in ('running', 'startup'):
+            raise ValueError("fetching configuration from %s is not supported" % source)
+
+        if source == 'running':
+            cmd = 'show running-config '
+        else:
+            cmd = 'show startup-config '
+
+        if flags:
+            cmd += ' '.join(to_list(flags))
+            cmd = cmd.strip()
+
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, commands):
+        resp = {}
+
+        results = []
+        requests = []
+        self.send_command('configure')
+        for line in to_list(commands):
+            if not isinstance(line, Mapping):
+                line = {'command': line}
+
+            cmd = line['command']
+            if cmd != 'end' and cmd[0] != '!':
+                results.append(self.send_command(**line))
+                requests.append(cmd)
+
+        self.send_command('end')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command=None, prompt=None, answer=None, sendonly=False, output=None, newline=True, check_all=False):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        if output:
+            raise ValueError("'output' value %s is not supported for get" % output)
+
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        result['rpc'] += ['run_commands']
+        return json.dumps(result)
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                raise ValueError("'output' value %s is not supported for run_commands" % output)
+
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc:
+                    raise
+                out = getattr(e, 'err', e)
+
+            responses.append(out)
+
+        return responses

plugins/cliconf/enos.py

@@ -0,0 +1,103 @@
+# (C) 2017 Red Hat Inc.
+# Copyright (C) 2017 Lenovo.
+#
+# GNU General Public License v3.0+
+#
+# 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.
+#
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Contains CLIConf Plugin methods for ENOS Modules
+# Lenovo Networking
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: enos
+short_description: Use enos cliconf to run command on Lenovo ENOS platform
+description:
+  - This enos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Lenovo ENOS network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'enos'
+        reply = self.get('show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'^Software Version (.*?) ', data, re.M | re.I)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'^Lenovo RackSwitch (\S+)', data, re.M | re.I)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'^(.+) uptime', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+        else:
+            device_info['network_os_hostname'] = "NA"
+
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running', 'startup'):
+            msg = "fetching configuration from %s is not supported"
+            return self.invalid_params(msg % source)
+        if source == 'running':
+            cmd = 'show running-config'
+        else:
+            cmd = 'show startup-config'
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, command):
+        for cmd in chain(['configure terminal'], to_list(command), ['end']):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)
+
+    def set_cli_prompt_context(self):
+        """
+        Make sure we are in the operational cli mode
+        :return: None
+        """
+        if self._connection.connected:
+            out = self._connection.get_prompt()
+
+            if out is None:
+                raise AnsibleConnectionFailure(message=u'cli prompt is not identified from the last received'
+                                                       u' response window: %s' % self._connection._last_recv_window)
+
+            if to_text(out, errors='surrogate_then_replace').strip().endswith(')#'):
+                self._connection.queue_message('vvvv', 'In Config mode, sending exit to device')
+                self._connection.send_command('exit')
+            else:
+                self._connection.send_command('enable')

plugins/cliconf/eric_eccli.py

@@ -0,0 +1,97 @@
+#
+# Copyright (c) 2019 Ericsson AB.
+#
+# 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 <http://www.gnu.org/licenses/>.
+#
+
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+author: Ericsson IPOS OAM team
+cliconf: eccli
+short_description: Use eccli cliconf to run command on Ericsson ECCLI platform
+description:
+  - This eccli plugin provides low level abstraction APIs for
+    sending and receiving CLI commands from Ericsson ECCLI network devices.
+'''
+
+from ansible.module_utils.common._collections_compat import Mapping
+import collections
+import re
+import time
+import json
+
+from itertools import chain
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible.module_utils.six import iteritems
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import NetworkConfig, dumps
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_config(self, source='running', flags=None, format=None):
+        return
+
+    def edit_config(self, candidate=None, commit=True, replace=None, comment=None):
+        return
+
+    def get(self, command=None, prompt=None, answer=None, sendonly=False, output=None, newline=True, check_all=False):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        if output:
+            raise ValueError("'output' value %s is not supported for get" % output)
+
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_device_info(self):
+        device_info = {}
+        device_info['network_os'] = 'eric_eccli'
+        return device_info
+
+    def get_capabilities(self):
+        result = dict()
+        result['rpc'] = self.get_base_rpc() + ['run_commands']
+        result['network_api'] = 'cliconf'
+        result['device_info'] = self.get_device_info()
+        return json.dumps(result)
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                raise ValueError("'output' value %s is not supported for run_commands" % output)
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc:
+                    raise
+                out = getattr(e, 'err', e)
+
+            responses.append(out)
+
+        return responses

plugins/cliconf/exos.py

@@ -0,0 +1,229 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: exos
+short_description: Use exos cliconf to run command on Extreme EXOS platform
+description:
+  - This exos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Extreme EXOS network devices.
+'''
+
+import re
+import json
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.module_utils.connection import ConnectionError
+from ansible.module_utils.common._collections_compat import Mapping
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import NetworkConfig, dumps
+from ansible.plugins.cliconf import CliconfBase
+
+
+class Cliconf(CliconfBase):
+
+    def get_diff(self, candidate=None, running=None, diff_match='line', diff_ignore_lines=None, path=None, diff_replace='line'):
+        diff = {}
+        device_operations = self.get_device_operations()
+        option_values = self.get_option_values()
+
+        if candidate is None and device_operations['supports_generate_diff']:
+            raise ValueError("candidate configuration is required to generate diff")
+
+        if diff_match not in option_values['diff_match']:
+            raise ValueError("'match' value %s in invalid, valid values are %s" % (diff_match, ', '.join(option_values['diff_match'])))
+
+        if diff_replace not in option_values['diff_replace']:
+            raise ValueError("'replace' value %s in invalid, valid values are %s" % (diff_replace, ', '.join(option_values['diff_replace'])))
+
+        # prepare candidate configuration
+        candidate_obj = NetworkConfig(indent=1)
+        candidate_obj.load(candidate)
+
+        if running and diff_match != 'none' and diff_replace != 'config':
+            # running configuration
+            running_obj = NetworkConfig(indent=1, contents=running, ignore_lines=diff_ignore_lines)
+            configdiffobjs = candidate_obj.difference(running_obj, path=path, match=diff_match, replace=diff_replace)
+
+        else:
+            configdiffobjs = candidate_obj.items
+
+        diff['config_diff'] = dumps(configdiffobjs, 'commands') if configdiffobjs else ''
+        return diff
+
+    def get_device_info(self):
+        device_info = {}
+        device_info['network_os'] = 'exos'
+
+        reply = self.run_commands({'command': 'show switch detail', 'output': 'text'})
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'ExtremeXOS version  (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'System Type: +(\S+)', data)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'SysName: +(\S+)', data)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_default_flag(self):
+        # The flag to modify the command to collect configuration with defaults
+        return 'detail'
+
+    def get_config(self, source='running', format='text', flags=None):
+        options_values = self.get_option_values()
+        if format not in options_values['format']:
+            raise ValueError("'format' value %s is invalid. Valid values are %s" % (format, ','.join(options_values['format'])))
+
+        lookup = {'running': 'show configuration', 'startup': 'debug cfgmgr show configuration file'}
+        if source not in lookup:
+            raise ValueError("fetching configuration from %s is not supported" % source)
+
+        cmd = {'command': lookup[source], 'output': 'text'}
+
+        if source == 'startup':
+            reply = self.run_commands({'command': 'show switch', 'format': 'text'})
+            data = to_text(reply, errors='surrogate_or_strict').strip()
+            match = re.search(r'Config Selected: +(\S+)\.cfg', data, re.MULTILINE)
+            if match:
+                cmd['command'] += match.group(1)
+            else:
+                # No Startup(/Selected) Config
+                return {}
+
+        cmd['command'] += ' '.join(to_list(flags))
+        cmd['command'] = cmd['command'].strip()
+
+        return self.run_commands(cmd)[0]
+
+    def edit_config(self, candidate=None, commit=True, replace=None, diff=False, comment=None):
+        resp = {}
+        operations = self.get_device_operations()
+        self.check_edit_config_capability(operations, candidate, commit, replace, comment)
+        results = []
+        requests = []
+
+        if commit:
+            for line in to_list(candidate):
+                if not isinstance(line, Mapping):
+                    line = {'command': line}
+                results.append(self.send_command(**line))
+                requests.append(line['command'])
+        else:
+            raise ValueError('check mode is not supported')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, output=None, newline=True, check_all=False):
+        if output:
+            command = self._get_command_with_output(command, output)
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                cmd['command'] = self._get_command_with_output(cmd['command'], output)
+
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc is True:
+                    raise
+                out = getattr(e, 'err', e)
+
+            if out is not None:
+                try:
+                    out = to_text(out, errors='surrogate_or_strict').strip()
+                except UnicodeError:
+                    raise ConnectionError(message=u'Failed to decode output from %s: %s' % (cmd, to_text(out)))
+
+                if output and output == 'json':
+                    try:
+                        out = json.loads(out)
+                    except ValueError:
+                        raise ConnectionError('Response was not valid JSON, got {0}'.format(
+                            to_text(out)
+                        ))
+                responses.append(out)
+
+        return responses
+
+    def get_device_operations(self):
+        return {
+            'supports_diff_replace': False,         # identify if config should be merged or replaced is supported
+            'supports_commit': False,               # identify if commit is supported by device or not
+            'supports_rollback': False,             # identify if rollback is supported or not
+            'supports_defaults': True,              # identify if fetching running config with default is supported
+            'supports_commit_comment': False,       # identify if adding comment to commit is supported of not
+            'supports_onbox_diff': False,           # identify if on box diff capability is supported or not
+            'supports_generate_diff': True,         # identify if diff capability is supported within plugin
+            'supports_multiline_delimiter': False,  # identify if multiline delimiter is supported within config
+            'supports_diff_match': True,            # identify if match is supported
+            'supports_diff_ignore_lines': True,     # identify if ignore line in diff is supported
+            'supports_config_replace': False,       # identify if running config replace with candidate config is supported
+            'supports_admin': False,                # identify if admin configure mode is supported or not
+            'supports_commit_label': False,         # identify if commit label is supported or not
+            'supports_replace': False
+        }
+
+    def get_option_values(self):
+        return {
+            'format': ['text', 'json'],
+            'diff_match': ['line', 'strict', 'exact', 'none'],
+            'diff_replace': ['line', 'block'],
+            'output': ['text', 'json']
+        }
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        result['rpc'] += ['run_commmands', 'get_default_flag', 'get_diff']
+        result['device_operations'] = self.get_device_operations()
+        result['device_info'] = self.get_device_info()
+        result.update(self.get_option_values())
+        return json.dumps(result)
+
+    def _get_command_with_output(self, command, output):
+        if output not in self.get_option_values().get('output'):
+            raise ValueError("'output' value is %s is invalid. Valid values are %s" % (output, ','.join(self.get_option_values().get('output'))))
+
+        if output == 'json' and not command.startswith('run script cli2json.py'):
+            cmd = 'run script cli2json.py %s' % command
+        else:
+            cmd = command
+        return cmd

plugins/cliconf/icx.py

@@ -0,0 +1,314 @@
+# Copyright: (c) 2019, 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
+
+DOCUMENTATION = '''
+---
+author: Ruckus Wireless (@Commscope)
+cliconf: icx
+short_description: Use icx cliconf to run command on Ruckus ICX platform
+description:
+  - This icx plugin provides low level abstraction APIs for
+    sending and receiving CLI commands from Ruckus ICX network devices.
+'''
+
+
+import re
+import time
+import json
+import os
+
+from itertools import chain
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible.module_utils.six import iteritems
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import NetworkConfig, dumps
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+from ansible.module_utils.common._collections_compat import Mapping
+
+
+class Cliconf(CliconfBase):
+
+    @enable_mode
+    def get_config(self, source='running', flags=None, format=None, compare=None):
+        if source not in ('running', 'startup'):
+            raise ValueError("fetching configuration from %s is not supported" % source)
+
+        if format:
+            raise ValueError("'format' value %s is not supported for get_config" % format)
+
+        if not flags:
+            flags = []
+
+        if compare is False:
+            return ''
+        else:
+            if source == 'running':
+                cmd = 'show running-config '
+            else:
+                cmd = 'show configuration '
+
+            cmd += ' '.join(to_list(flags))
+            cmd = cmd.strip()
+
+            return self.send_command(cmd)
+
+    def get_diff(self, candidate=None, running=None, diff_match='line', diff_ignore_lines=None, path=None, diff_replace='line'):
+        """
+        Generate diff between candidate and running configuration. If the
+        remote host supports onbox diff capabilities ie. supports_onbox_diff in that case
+        candidate and running configurations are not required to be passed as argument.
+        In case if onbox diff capability is not supported candidate argument is mandatory
+        and running argument is optional.
+        :param candidate: The configuration which is expected to be present on remote host.
+        :param running: The base configuration which is used to generate diff.
+        :param diff_match: Instructs how to match the candidate configuration with current device configuration
+                      Valid values are 'line', 'strict', 'exact', 'none'.
+                      'line' - commands are matched line by line
+                      'strict' - command lines are matched with respect to position
+                      'exact' - command lines must be an equal match
+                      'none' - will not compare the candidate configuration with the running configuration
+        :param diff_ignore_lines: Use this argument to specify one or more lines that should be
+                                  ignored during the diff.  This is used for lines in the configuration
+                                  that are automatically updated by the system.  This argument takes
+                                  a list of regular expressions or exact line matches.
+        :param path: The ordered set of parents that uniquely identify the section or hierarchy
+                     the commands should be checked against.  If the parents argument
+                     is omitted, the commands are checked against the set of top
+                    level or global commands.
+        :param diff_replace: Instructs on the way to perform the configuration on the device.
+                        If the replace argument is set to I(line) then the modified lines are
+                        pushed to the device in configuration mode.  If the replace argument is
+                        set to I(block) then the entire command block is pushed to the device in
+                        configuration mode if any line is not correct.
+        :return: Configuration diff in  json format.
+               {
+                   'config_diff': '',
+                   'banner_diff': {}
+               }
+
+        """
+        diff = {}
+        device_operations = self.get_device_operations()
+        option_values = self.get_option_values()
+
+        if candidate is None and device_operations['supports_generate_diff']:
+            raise ValueError("candidate configuration is required to generate diff")
+
+        if diff_match not in option_values['diff_match']:
+            raise ValueError("'match' value %s in invalid, valid values are %s" % (diff_match, ', '.join(option_values['diff_match'])))
+
+        if diff_replace not in option_values['diff_replace']:
+            raise ValueError("'replace' value %s in invalid, valid values are %s" % (diff_replace, ', '.join(option_values['diff_replace'])))
+
+        # prepare candidate configuration
+        candidate_obj = NetworkConfig(indent=1)
+        want_src, want_banners = self._extract_banners(candidate)
+        candidate_obj.load(want_src)
+
+        if running and diff_match != 'none':
+            # running configuration
+            have_src, have_banners = self._extract_banners(running)
+
+            running_obj = NetworkConfig(indent=1, contents=have_src, ignore_lines=diff_ignore_lines)
+            configdiffobjs = candidate_obj.difference(running_obj, path=path, match=diff_match, replace=diff_replace)
+
+        else:
+            configdiffobjs = candidate_obj.items
+            have_banners = {}
+
+        diff['config_diff'] = dumps(configdiffobjs, 'commands') if configdiffobjs else ''
+
+        banners = self._diff_banners(want_banners, have_banners)
+        diff['banner_diff'] = banners if banners else {}
+        return diff
+
+    @enable_mode
+    def edit_config(self, candidate=None, commit=True, replace=None, comment=None):
+        resp = {}
+        operations = self.get_device_operations()
+        self.check_edit_config_capability(operations, candidate, commit, replace, comment)
+
+        results = []
+        requests = []
+        if commit:
+            prompt = self._connection.get_prompt()
+            if (b'(config-if' in prompt) or (b'(config' in prompt) or (b'(config-lag-if' in prompt):
+                self.send_command('end')
+
+            self.send_command('configure terminal')
+
+            for line in to_list(candidate):
+                if not isinstance(line, Mapping):
+                    line = {'command': line}
+
+                cmd = line['command']
+                if cmd != 'end' and cmd[0] != '!':
+                    results.append(self.send_command(**line))
+                    requests.append(cmd)
+
+            self.send_command('end')
+        else:
+            raise ValueError('check mode is not supported')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command=None, prompt=None, answer=None, sendonly=False, output=None, check_all=False):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        if output:
+            raise ValueError("'output' value %s is not supported for get" % output)
+
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, check_all=check_all)
+
+    def scp(self, command=None, scp_user=None, scp_pass=None):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        prompt = ["User name:", "Password:"]
+        if(scp_pass is None):
+            answer = [scp_user, self._connection._play_context.password]
+        else:
+            answer = [scp_user, scp_pass]
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=False, check_all=True)
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'icx'
+        reply = self.get(command='show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Version (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1).strip(',')
+
+        match = re.search(r'^Cisco (.+) \(revision', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'^(.+) uptime', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_device_operations(self):
+        return {
+            'supports_diff_replace': True,
+            'supports_commit': False,
+            'supports_rollback': False,
+            'supports_defaults': True,
+            'supports_onbox_diff': False,
+            'supports_commit_comment': False,
+            'supports_multiline_delimiter': True,
+            'supports_diff_match': True,
+            'supports_diff_ignore_lines': True,
+            'supports_generate_diff': True,
+            'supports_replace': False
+        }
+
+    def get_option_values(self):
+        return {
+            'format': ['text'],
+            'diff_match': ['line', 'strict', 'exact', 'none'],
+            'diff_replace': ['line', 'block'],
+            'output': []
+        }
+
+    def get_capabilities(self):
+        result = dict()
+        result['rpc'] = self.get_base_rpc() + ['edit_banner', 'get_diff', 'run_commands', 'get_defaults_flag']
+        result['network_api'] = 'cliconf'
+        result['device_operations'] = self.get_device_operations()
+        result.update(self.get_option_values())
+        return json.dumps(result)
+
+    def edit_banner(self, candidate=None, multiline_delimiter="@", commit=True):
+        """
+        Edit banner on remote device
+        :param banners: Banners to be loaded in json format
+        :param multiline_delimiter: Line delimiter for banner
+        :param commit: Boolean value that indicates if the device candidate
+               configuration should be  pushed in the running configuration or discarded.
+        :param diff: Boolean flag to indicate if configuration that is applied on remote host should
+                     generated and returned in response or not
+        :return: Returns response of executing the configuration command received
+             from remote host
+        """
+        resp = {}
+        banners_obj = json.loads(candidate)
+        results = []
+        requests = []
+        if commit:
+            for key, value in iteritems(banners_obj):
+                key += ' %s' % multiline_delimiter
+                self.send_command('config terminal', sendonly=True)
+                for cmd in [key, value, multiline_delimiter]:
+                    obj = {'command': cmd, 'sendonly': True}
+                    results.append(self.send_command(**obj))
+                    requests.append(cmd)
+
+                self.send_command('end', sendonly=True)
+                time.sleep(0.1)
+                results.append(self.send_command('\n'))
+                requests.append('\n')
+
+        resp['request'] = requests
+        resp['response'] = results
+
+        return resp
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                raise ValueError("'output' value %s is not supported for run_commands" % output)
+
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc:
+                    raise
+                out = getattr(e, 'err', to_text(e))
+
+            responses.append(out)
+
+        return responses
+
+    def _extract_banners(self, config):
+        banners = {}
+        banner_cmds = re.findall(r'^banner (\w+)', config, re.M)
+        for cmd in banner_cmds:
+            regex = r'banner %s \$(.+?)(?=\$)' % cmd
+            match = re.search(regex, config, re.S)
+            if match:
+                key = 'banner %s' % cmd
+                banners[key] = match.group(1).strip()
+
+        for cmd in banner_cmds:
+            regex = r'banner %s \$(.+?)(?=\$)' % cmd
+            match = re.search(regex, config, re.S)
+            if match:
+                config = config.replace(str(match.group(1)), '')
+
+        config = re.sub(r'banner \w+ \$\$', '!! banner removed', config)
+        return config, banners
+
+    def _diff_banners(self, want, have):
+        candidate = {}
+        for key, value in iteritems(want):
+            if value != have.get(key):
+                candidate[key] = value
+        return candidate

plugins/cliconf/ironware.py

@@ -0,0 +1,95 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: ironware
+short_description: Use ironware cliconf to run command on Extreme Ironware platform
+description:
+  - This ironware plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Extreme Ironware network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'ironware'
+        reply = self.send_command('show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'IronWare : Version (\S+),', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'^(?:System Mode\:|System\:) (CES|CER|MLX|XMR)', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running', 'startup'):
+            raise ValueError("fetching configuration from %s is not supported" % source)
+
+        if source == 'running':
+            cmd = 'show running-config'
+            if flags is not None:
+                cmd += ' ' + ' '.join(flags)
+
+        else:
+            cmd = 'show configuration'
+            if flags is not None:
+                raise ValueError("flags are only supported with running-config")
+
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, command):
+        for cmd in chain(['configure terminal'], to_list(command), ['end']):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)
+
+    def set_cli_prompt_context(self):
+        """
+        Make sure we are in the operational cli mode
+        :return: None
+        """
+        if self._connection.connected:
+            self._update_cli_prompt_context(config_context=')#')

plugins/cliconf/netvisor.py

@@ -0,0 +1,74 @@
+#
+# (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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: netvisor
+short_description: Use netvisor cliconf to run command on Pluribus netvisor platform
+description:
+  - This netvisor plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Pluribus netvisor devices.
+'''
+
+import json
+from ansible.plugins.cliconf import CliconfBase
+
+
+class Cliconf(CliconfBase):
+
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running'):
+            return self.invalid_params("fetching configuration from %s is not supported" % source)
+        cmd = 'show running-config'
+        return self.send_command(cmd)
+
+    def edit_config(self, command):
+        return
+
+    def get(self, command=None, prompt=None, answer=None, sendonly=False, output=None, newline=True, check_all=False):
+        if not command:
+            raise ValueError('must provide value of command to execute')
+        if output:
+            raise ValueError("'output' value %s is not supported for get" % output)
+
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_option_values(self):
+        return {
+            'format': ['text'],
+            'diff_match': ['line', 'strict', 'exact', 'none'],
+            'diff_replace': ['line', 'block'],
+            'output': []
+        }
+
+    def get_capabilities(self):
+        result = dict()
+        result['rpc'] = self.get_base_rpc()
+        result['network_api'] = 'cliconf'
+        result['device_info'] = self.get_device_info()
+        result.update(self.get_option_values())
+        return json.dumps(result)
+
+    def get_device_info(self):
+        device_info = {}
+        device_info['network_os'] = 'netvisor'
+
+        return device_info

plugins/cliconf/nos.py

@@ -0,0 +1,112 @@
+#
+# (c) 2018 Extreme Networks 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: nos
+short_description: Use nos cliconf to run command on Extreme NOS platform
+description:
+  - This nos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Extreme NOS network devices.
+'''
+
+import re
+import json
+
+from ansible.module_utils._text import to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'nos'
+        reply = self.get('show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'Network Operating System Version: (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        reply = self.get('show chassis')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'^Chassis Name:(\s+)(\S+)', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(2)
+
+        reply = self.get('show running-config | inc "switch-attributes host-name"')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'switch-attributes host-name (\S+)', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_config(self, source='running', flags=None):
+        if source not in 'running':
+            raise ValueError("fetching configuration from %s is not supported" % source)
+        if source == 'running':
+            cmd = 'show running-config'
+
+        flags = [] if flags is None else flags
+        cmd += ' '.join(flags)
+        cmd = cmd.strip()
+
+        return self.send_command(cmd)
+
+    def edit_config(self, command):
+        resp = {}
+        results = []
+        requests = []
+        self.send_command('configure terminal')
+        for cmd in to_list(command):
+            if isinstance(cmd, dict):
+                command = cmd['command']
+                prompt = cmd['prompt']
+                answer = cmd['answer']
+                newline = cmd.get('newline', True)
+            else:
+                command = cmd
+                prompt = None
+                answer = None
+                newline = True
+
+            if cmd != 'end' and cmd[0] != '!':
+                results.append(self.send_command(command, prompt, answer, False, newline))
+                requests.append(cmd)
+
+        self.send_command('end')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)

plugins/cliconf/onyx.py

@@ -0,0 +1,77 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: onyx
+short_description: Use onyx cliconf to run command on Mellanox ONYX platform
+description:
+  - This onyx plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Mellanox ONYX network devices.
+'''
+
+import json
+
+from itertools import chain
+
+from ansible.module_utils._text import to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        reply = self.get('show version | json-print')
+        data = json.loads(reply)
+        device_info['network_os'] = data['Product name']
+        device_info['network_os_version'] = data['Product release']
+        device_info['network_os_version_summary'] = data['Version summary']
+        device_info['network_os_model'] = data['Product model']
+
+        reply = self.get('show hosts | include Hostname')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+        hostname = data.split(':')[1]
+        hostname = hostname.strip()
+        device_info['network_os_hostname'] = hostname
+
+        return device_info
+
+    @enable_mode
+    def get_config(self, source='running', format='text', flags=None):
+        if source not in ('running',):
+            return self.invalid_params("fetching configuration from %s is not supported" % source)
+        cmd = 'show running-config'
+        return self.send_command(cmd)
+
+    @enable_mode
+    def edit_config(self, command):
+        for cmd in chain(['configure terminal'], to_list(command), ['exit']):
+            self.send_command(cmd)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)

plugins/cliconf/routeros.py

@@ -0,0 +1,78 @@
+#
+# (c) 2017 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: routeros
+short_description: Use routeros cliconf to run command on MikroTik RouterOS platform
+description:
+  - This routeros plugin provides low level abstraction apis for
+    sending and receiving CLI commands from MikroTik RouterOS network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+        device_info['network_os'] = 'RouterOS'
+
+        resource = self.get('/system resource print')
+        data = to_text(resource, errors='surrogate_or_strict').strip()
+        match = re.search(r'version: (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        routerboard = self.get('/system routerboard print')
+        data = to_text(routerboard, errors='surrogate_or_strict').strip()
+        match = re.search(r'model: (.+)$', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        identity = self.get('/system identity print')
+        data = to_text(identity, errors='surrogate_or_strict').strip()
+        match = re.search(r'name: (.+)$', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_config(self, source='running', format='text', flags=None):
+        return
+
+    def edit_config(self, command):
+        return
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)

plugins/cliconf/slxos.py

@@ -0,0 +1,104 @@
+#
+# (c) 2018 Extreme Networks 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: slxos
+short_description: Use slxos cliconf to run command on Extreme SLX-OS platform
+description:
+  - This slxos plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Extreme SLX-OS network devices.
+'''
+
+import re
+import json
+
+from itertools import chain
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible.plugins.cliconf import CliconfBase
+
+
+class Cliconf(CliconfBase):
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'slxos'
+        reply = self.get('show version')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'SLX\-OS Operating System Version: (\S+)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        reply = self.get('show chassis')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'^Chassis Name:(\s+)(\S+)', data, re.M)
+        if match:
+            device_info['network_os_model'] = match.group(2)
+
+        reply = self.get('show running-config | inc "switch-attributes host-name"')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'switch-attributes host-name (\S+)', data, re.M)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_config(self, source='running', flags=None):
+        if source not in ('running', 'startup'):
+            raise ValueError("fetching configuration from %s is not supported" % source)
+        if source == 'running':
+            cmd = 'show running-config'
+        else:
+            cmd = 'show startup-config'
+
+        flags = [] if flags is None else flags
+        cmd += ' '.join(flags)
+        cmd = cmd.strip()
+
+        return self.send_command(cmd)
+
+    def edit_config(self, command):
+        for cmd in chain(['configure terminal'], to_list(command), ['end']):
+            if isinstance(cmd, dict):
+                command = cmd['command']
+                prompt = cmd['prompt']
+                answer = cmd['answer']
+                newline = cmd.get('newline', True)
+            else:
+                command = cmd
+                prompt = None
+                answer = None
+                newline = True
+
+            self.send_command(command, prompt, answer, False, newline)
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        return json.dumps(result)

plugins/cliconf/voss.py

@@ -0,0 +1,235 @@
+#
+# (c) 2018 Extreme Networks 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+---
+cliconf: voss
+short_description: Use voss cliconf to run command on Extreme VOSS platform
+description:
+  - This voss plugin provides low level abstraction apis for
+    sending and receiving CLI commands from Extreme VOSS network devices.
+'''
+
+import re
+import json
+
+from ansible.errors import AnsibleConnectionFailure
+from ansible.module_utils._text import to_text
+from ansible.module_utils.common._collections_compat import Mapping
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import NetworkConfig, dumps
+from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import to_list
+from ansible_collections.community.general.plugins.module_utils.network.voss.voss import VossNetworkConfig
+from ansible.plugins.cliconf import CliconfBase, enable_mode
+
+
+class Cliconf(CliconfBase):
+
+    @enable_mode
+    def get_config(self, source='running', flags=None, format=None):
+        if source not in ('running', 'startup'):
+            raise ValueError("fetching configuration from %s is not supported" % source)
+
+        if format:
+            raise ValueError("'format' value %s is not supported for get_config" % format)
+
+        if not flags:
+            flags = []
+        if source == 'running':
+            cmd = 'show running-config '
+            cmd += ' '.join(to_list(flags))
+            cmd = cmd.strip()
+        else:
+            cmd = 'more /intflash/config.cfg'
+
+        return self.send_command(cmd)
+
+    def get_diff(self, candidate=None, running=None, diff_match='line', diff_ignore_lines=None, path=None, diff_replace='line'):
+        """
+        Generate diff between candidate and running configuration. If the
+        remote host supports onbox diff capabilities ie. supports_onbox_diff in that case
+        candidate and running configurations are not required to be passed as argument.
+        In case if onbox diff capability is not supported candidate argument is mandatory
+        and running argument is optional.
+        :param candidate: The configuration which is expected to be present on remote host.
+        :param running: The base configuration which is used to generate diff.
+        :param diff_match: Instructs how to match the candidate configuration with current device configuration
+                      Valid values are 'line', 'strict', 'exact', 'none'.
+                      'line' - commands are matched line by line
+                      'strict' - command lines are matched with respect to position
+                      'exact' - command lines must be an equal match
+                      'none' - will not compare the candidate configuration with the running configuration
+        :param diff_ignore_lines: Use this argument to specify one or more lines that should be
+                                  ignored during the diff.  This is used for lines in the configuration
+                                  that are automatically updated by the system.  This argument takes
+                                  a list of regular expressions or exact line matches.
+        :param path: The ordered set of parents that uniquely identify the section or hierarchy
+                     the commands should be checked against.  If the parents argument
+                     is omitted, the commands are checked against the set of top
+                    level or global commands.
+        :param diff_replace: Instructs on the way to perform the configuration on the device.
+                        If the replace argument is set to I(line) then the modified lines are
+                        pushed to the device in configuration mode.  If the replace argument is
+                        set to I(block) then the entire command block is pushed to the device in
+                        configuration mode if any line is not correct.
+        :return: Configuration diff in  json format.
+               {
+                   'config_diff': '',
+               }
+
+        """
+        diff = {}
+
+        device_operations = self.get_device_operations()
+        option_values = self.get_option_values()
+
+        if candidate is None and device_operations['supports_generate_diff']:
+            raise ValueError("candidate configuration is required to generate diff")
+
+        if diff_match not in option_values['diff_match']:
+            raise ValueError("'match' value %s in invalid, valid values are %s" % (diff_match, ', '.join(option_values['diff_match'])))
+
+        if diff_replace not in option_values['diff_replace']:
+            raise ValueError("'replace' value %s in invalid, valid values are %s" % (diff_replace, ', '.join(option_values['diff_replace'])))
+
+        # prepare candidate configuration
+        candidate_obj = VossNetworkConfig(indent=0, ignore_lines=diff_ignore_lines)
+        candidate_obj.load(candidate)
+
+        if running and diff_match != 'none':
+            # running configuration
+            running_obj = VossNetworkConfig(indent=0, contents=running, ignore_lines=diff_ignore_lines)
+            configdiffobjs = candidate_obj.difference(running_obj, path=path, match=diff_match, replace=diff_replace)
+
+        else:
+            configdiffobjs = candidate_obj.items
+
+        diff['config_diff'] = dumps(configdiffobjs, 'commands') if configdiffobjs else ''
+        diff['diff_path'] = path
+        diff['diff_replace'] = diff_replace
+        return diff
+
+    @enable_mode
+    def edit_config(self, candidate=None, commit=True, replace=None, comment=None):
+        resp = {}
+        operations = self.get_device_operations()
+        self.check_edit_config_capability(operations, candidate, commit, replace, comment)
+
+        results = []
+        requests = []
+        if commit:
+            self.send_command('configure terminal')
+            for line in to_list(candidate):
+                if not isinstance(line, Mapping):
+                    line = {'command': line}
+
+                cmd = line['command']
+                if cmd != 'end' and cmd[0] != '!':
+                    results.append(self.send_command(**line))
+                    requests.append(cmd)
+
+            self.send_command('end')
+        else:
+            raise ValueError('check mode is not supported')
+
+        resp['request'] = requests
+        resp['response'] = results
+        return resp
+
+    def get(self, command, prompt=None, answer=None, sendonly=False, newline=True, check_all=False):
+        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)
+
+    def get_device_info(self):
+        device_info = {}
+
+        device_info['network_os'] = 'voss'
+        reply = self.get(command='show sys-info')
+        data = to_text(reply, errors='surrogate_or_strict').strip()
+
+        match = re.search(r'SysDescr\s+: \S+ \((\S+)\)', data)
+        if match:
+            device_info['network_os_version'] = match.group(1)
+
+        match = re.search(r'Chassis\s+: (\S+)', data)
+        if match:
+            device_info['network_os_model'] = match.group(1)
+
+        match = re.search(r'SysName\s+: (\S+)', data)
+        if match:
+            device_info['network_os_hostname'] = match.group(1)
+
+        return device_info
+
+    def get_device_operations(self):
+        return {
+            'supports_diff_replace': True,
+            'supports_commit': False,
+            'supports_rollback': False,
+            'supports_defaults': True,
+            'supports_onbox_diff': False,
+            'supports_commit_comment': False,
+            'supports_multiline_delimiter': False,
+            'supports_diff_match': True,
+            'supports_diff_ignore_lines': True,
+            'supports_generate_diff': True,
+            'supports_replace': False
+        }
+
+    def get_option_values(self):
+        return {
+            'format': ['text'],
+            'diff_match': ['line', 'strict', 'exact', 'none'],
+            'diff_replace': ['line', 'block'],
+            'output': []
+        }
+
+    def get_capabilities(self):
+        result = super(Cliconf, self).get_capabilities()
+        result['rpc'] += ['get_diff', 'run_commands', 'get_defaults_flag']
+        result['device_operations'] = self.get_device_operations()
+        result.update(self.get_option_values())
+        return json.dumps(result)
+
+    def run_commands(self, commands=None, check_rc=True):
+        if commands is None:
+            raise ValueError("'commands' value is required")
+
+        responses = list()
+        for cmd in to_list(commands):
+            if not isinstance(cmd, Mapping):
+                cmd = {'command': cmd}
+
+            output = cmd.pop('output', None)
+            if output:
+                raise ValueError("'output' value %s is not supported for run_commands" % output)
+
+            try:
+                out = self.send_command(**cmd)
+            except AnsibleConnectionFailure as e:
+                if check_rc:
+                    raise
+                out = getattr(e, 'err', e)
+
+            responses.append(out)
+
+        return responses
+
+    def get_defaults_flag(self):
+        return 'verbose'

plugins/connection/chroot.py

@@ -0,0 +1,206 @@
+# Based on local.py (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# (c) 2013, Maykel Moya <mmoya@speedyrails.com>
+# (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
+# 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
+
+DOCUMENTATION = '''
+    author: Maykel Moya <mmoya@speedyrails.com>
+    connection: chroot
+    short_description: Interact with local chroot
+    description:
+        - Run commands or put/fetch files to an existing chroot on the Ansible controller.
+    options:
+      remote_addr:
+        description:
+            - The path of the chroot you want to access.
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+      executable:
+        description:
+            - User specified executable shell
+        ini:
+          - section: defaults
+            key: executable
+        env:
+          - name: ANSIBLE_EXECUTABLE
+        vars:
+          - name: ansible_executable
+        default: /bin/sh
+      chroot_exe:
+        description:
+            - User specified chroot binary
+        ini:
+          - section: chroot_connection
+            key: exe
+        env:
+          - name: ANSIBLE_CHROOT_EXE
+        vars:
+          - name: ansible_chroot_exe
+        default: chroot
+'''
+
+import os
+import os.path
+import subprocess
+import traceback
+
+from ansible.errors import AnsibleError
+from ansible.module_utils.basic import is_executable
+from ansible.module_utils.common.process import get_bin_path
+from ansible.module_utils.six.moves import shlex_quote
+from ansible.module_utils._text import to_bytes, to_native
+from ansible.plugins.connection import ConnectionBase, BUFSIZE
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(ConnectionBase):
+    ''' Local chroot based connections '''
+
+    transport = 'community.general.chroot'
+    has_pipelining = True
+    # su currently has an undiagnosed issue with calculating the file
+    # checksums (so copy, for instance, doesn't work right)
+    # Have to look into that before re-enabling this
+    has_tty = False
+
+    default_user = 'root'
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        self.chroot = self._play_context.remote_addr
+
+        if os.geteuid() != 0:
+            raise AnsibleError("chroot connection requires running as root")
+
+        # we're running as root on the local system so do some
+        # trivial checks for ensuring 'host' is actually a chroot'able dir
+        if not os.path.isdir(self.chroot):
+            raise AnsibleError("%s is not a directory" % self.chroot)
+
+        chrootsh = os.path.join(self.chroot, 'bin/sh')
+        # Want to check for a usable bourne shell inside the chroot.
+        # is_executable() == True is sufficient.  For symlinks it
+        # gets really complicated really fast.  So we punt on finding that
+        # out.  As long as it's a symlink we assume that it will work
+        if not (is_executable(chrootsh) or (os.path.lexists(chrootsh) and os.path.islink(chrootsh))):
+            raise AnsibleError("%s does not look like a chrootable dir (/bin/sh missing)" % self.chroot)
+
+    def _connect(self):
+        ''' connect to the chroot '''
+        if os.path.isabs(self.get_option('chroot_exe')):
+            self.chroot_cmd = self.get_option('chroot_exe')
+        else:
+            try:
+                self.chroot_cmd = get_bin_path(self.get_option('chroot_exe'))
+            except ValueError as e:
+                raise AnsibleError(to_native(e))
+
+        super(Connection, self)._connect()
+        if not self._connected:
+            display.vvv("THIS IS A LOCAL CHROOT DIR", host=self.chroot)
+            self._connected = True
+
+    def _buffered_exec_command(self, cmd, stdin=subprocess.PIPE):
+        ''' run a command on the chroot.  This is only needed for implementing
+        put_file() get_file() so that we don't have to read the whole file
+        into memory.
+
+        compared to exec_command() it looses some niceties like being able to
+        return the process's exit code immediately.
+        '''
+        executable = self.get_option('executable')
+        local_cmd = [self.chroot_cmd, self.chroot, executable, '-c', cmd]
+
+        display.vvv("EXEC %s" % (local_cmd), host=self.chroot)
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+        p = subprocess.Popen(local_cmd, shell=False, stdin=stdin,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        return p
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        ''' run a command on the chroot '''
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        p = self._buffered_exec_command(cmd)
+
+        stdout, stderr = p.communicate(in_data)
+        return (p.returncode, stdout, stderr)
+
+    def _prefix_login_path(self, remote_path):
+        ''' Make sure that we put files into a standard path
+
+            If a path is relative, then we need to choose where to put it.
+            ssh chooses $HOME but we aren't guaranteed that a home dir will
+            exist in any given chroot.  So for now we're choosing "/" instead.
+            This also happens to be the former default.
+
+            Can revisit using $HOME instead if it's a problem
+        '''
+        if not remote_path.startswith(os.path.sep):
+            remote_path = os.path.join(os.path.sep, remote_path)
+        return os.path.normpath(remote_path)
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to chroot '''
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.chroot)
+
+        out_path = shlex_quote(self._prefix_login_path(out_path))
+        try:
+            with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as in_file:
+                if not os.fstat(in_file.fileno()).st_size:
+                    count = ' count=0'
+                else:
+                    count = ''
+                try:
+                    p = self._buffered_exec_command('dd of=%s bs=%s%s' % (out_path, BUFSIZE, count), stdin=in_file)
+                except OSError:
+                    raise AnsibleError("chroot connection requires dd command in the chroot")
+                try:
+                    stdout, stderr = p.communicate()
+                except Exception:
+                    traceback.print_exc()
+                    raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+                if p.returncode != 0:
+                    raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+        except IOError:
+            raise AnsibleError("file or module does not exist at: %s" % in_path)
+
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from chroot to local '''
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.chroot)
+
+        in_path = shlex_quote(self._prefix_login_path(in_path))
+        try:
+            p = self._buffered_exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE))
+        except OSError:
+            raise AnsibleError("chroot connection requires dd command in the chroot")
+
+        with open(to_bytes(out_path, errors='surrogate_or_strict'), 'wb+') as out_file:
+            try:
+                chunk = p.stdout.read(BUFSIZE)
+                while chunk:
+                    out_file.write(chunk)
+                    chunk = p.stdout.read(BUFSIZE)
+            except Exception:
+                traceback.print_exc()
+                raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+            stdout, stderr = p.communicate()
+            if p.returncode != 0:
+                raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/docker.py

@@ -0,0 +1,356 @@
+# Based on the chroot connection plugin by Maykel Moya
+#
+# (c) 2014, Lorin Hochstein
+# (c) 2015, Leendert Brouwer (https://github.com/objectified)
+# (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
+# 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
+
+DOCUMENTATION = '''
+    author:
+        - Lorin Hochestein
+        - Leendert Brouwer
+    connection: docker
+    short_description: Run tasks in docker containers
+    description:
+        - Run commands or put/fetch files to an existing docker container.
+    options:
+      remote_user:
+        description:
+            - The user to execute as inside the container
+        vars:
+            - name: ansible_user
+            - name: ansible_docker_user
+      docker_extra_args:
+        description:
+            - Extra arguments to pass to the docker command line
+        default: ''
+      remote_addr:
+        description:
+            - The name of the container you want to access.
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+            - name: ansible_docker_host
+'''
+
+import distutils.spawn
+import fcntl
+import os
+import os.path
+import subprocess
+import re
+
+from distutils.version import LooseVersion
+
+import ansible.constants as C
+from ansible.compat import selectors
+from ansible.errors import AnsibleError, AnsibleFileNotFound
+from ansible.module_utils.six.moves import shlex_quote
+from ansible.module_utils._text import to_bytes, to_native, to_text
+from ansible.plugins.connection import ConnectionBase, BUFSIZE
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(ConnectionBase):
+    ''' Local docker based connections '''
+
+    transport = 'community.general.docker'
+    has_pipelining = True
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        # Note: docker supports running as non-root in some configurations.
+        # (For instance, setting the UNIX socket file to be readable and
+        # writable by a specific UNIX group and then putting users into that
+        # group).  Therefore we don't check that the user is root when using
+        # this connection.  But if the user is getting a permission denied
+        # error it probably means that docker on their system is only
+        # configured to be connected to by root and they are not running as
+        # root.
+
+        # Windows uses Powershell modules
+        if getattr(self._shell, "_IS_WINDOWS", False):
+            self.module_implementation_preferences = ('.ps1', '.exe', '')
+
+        if 'docker_command' in kwargs:
+            self.docker_cmd = kwargs['docker_command']
+        else:
+            self.docker_cmd = distutils.spawn.find_executable('docker')
+            if not self.docker_cmd:
+                raise AnsibleError("docker command not found in PATH")
+
+        docker_version = self._get_docker_version()
+        if docker_version == u'dev':
+            display.warning(u'Docker version number is "dev". Will assume latest version.')
+        if docker_version != u'dev' and LooseVersion(docker_version) < LooseVersion(u'1.3'):
+            raise AnsibleError('docker connection type requires docker 1.3 or higher')
+
+        # The remote user we will request from docker (if supported)
+        self.remote_user = None
+        # The actual user which will execute commands in docker (if known)
+        self.actual_user = None
+
+        if self._play_context.remote_user is not None:
+            if docker_version == u'dev' or LooseVersion(docker_version) >= LooseVersion(u'1.7'):
+                # Support for specifying the exec user was added in docker 1.7
+                self.remote_user = self._play_context.remote_user
+                self.actual_user = self.remote_user
+            else:
+                self.actual_user = self._get_docker_remote_user()
+
+                if self.actual_user != self._play_context.remote_user:
+                    display.warning(u'docker {0} does not support remote_user, using container default: {1}'
+                                    .format(docker_version, self.actual_user or u'?'))
+        elif self._display.verbosity > 2:
+            # Since we're not setting the actual_user, look it up so we have it for logging later
+            # Only do this if display verbosity is high enough that we'll need the value
+            # This saves overhead from calling into docker when we don't need to
+            self.actual_user = self._get_docker_remote_user()
+
+    @staticmethod
+    def _sanitize_version(version):
+        return re.sub(u'[^0-9a-zA-Z.]', u'', version)
+
+    def _old_docker_version(self):
+        cmd_args = []
+        if self._play_context.docker_extra_args:
+            cmd_args += self._play_context.docker_extra_args.split(' ')
+
+        old_version_subcommand = ['version']
+
+        old_docker_cmd = [self.docker_cmd] + cmd_args + old_version_subcommand
+        p = subprocess.Popen(old_docker_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        cmd_output, err = p.communicate()
+
+        return old_docker_cmd, to_native(cmd_output), err, p.returncode
+
+    def _new_docker_version(self):
+        # no result yet, must be newer Docker version
+        cmd_args = []
+        if self._play_context.docker_extra_args:
+            cmd_args += self._play_context.docker_extra_args.split(' ')
+
+        new_version_subcommand = ['version', '--format', "'{{.Server.Version}}'"]
+
+        new_docker_cmd = [self.docker_cmd] + cmd_args + new_version_subcommand
+        p = subprocess.Popen(new_docker_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        cmd_output, err = p.communicate()
+        return new_docker_cmd, to_native(cmd_output), err, p.returncode
+
+    def _get_docker_version(self):
+
+        cmd, cmd_output, err, returncode = self._old_docker_version()
+        if returncode == 0:
+            for line in to_text(cmd_output, errors='surrogate_or_strict').split(u'\n'):
+                if line.startswith(u'Server version:'):  # old docker versions
+                    return self._sanitize_version(line.split()[2])
+
+        cmd, cmd_output, err, returncode = self._new_docker_version()
+        if returncode:
+            raise AnsibleError('Docker version check (%s) failed: %s' % (to_native(cmd), to_native(err)))
+
+        return self._sanitize_version(to_text(cmd_output, errors='surrogate_or_strict'))
+
+    def _get_docker_remote_user(self):
+        """ Get the default user configured in the docker container """
+        p = subprocess.Popen([self.docker_cmd, 'inspect', '--format', '{{.Config.User}}', self._play_context.remote_addr],
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        out, err = p.communicate()
+        out = to_text(out, errors='surrogate_or_strict')
+
+        if p.returncode != 0:
+            display.warning(u'unable to retrieve default user from docker container: %s %s' % (out, to_text(err)))
+            return None
+
+        # The default exec user is root, unless it was changed in the Dockerfile with USER
+        return out.strip() or u'root'
+
+    def _build_exec_cmd(self, cmd):
+        """ Build the local docker exec command to run cmd on remote_host
+
+            If remote_user is available and is supported by the docker
+            version we are using, it will be provided to docker exec.
+        """
+
+        local_cmd = [self.docker_cmd]
+
+        if self._play_context.docker_extra_args:
+            local_cmd += self._play_context.docker_extra_args.split(' ')
+
+        local_cmd += [b'exec']
+
+        if self.remote_user is not None:
+            local_cmd += [b'-u', self.remote_user]
+
+        # -i is needed to keep stdin open which allows pipelining to work
+        local_cmd += [b'-i', self._play_context.remote_addr] + cmd
+
+        return local_cmd
+
+    def _connect(self, port=None):
+        """ Connect to the container. Nothing to do """
+        super(Connection, self)._connect()
+        if not self._connected:
+            display.vvv(u"ESTABLISH DOCKER CONNECTION FOR USER: {0}".format(
+                self.actual_user or u'?'), host=self._play_context.remote_addr
+            )
+            self._connected = True
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        """ Run a command on the docker host """
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        local_cmd = self._build_exec_cmd([self._play_context.executable, '-c', cmd])
+
+        display.vvv(u"EXEC {0}".format(to_text(local_cmd)), host=self._play_context.remote_addr)
+        display.debug("opening command with Popen()")
+
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+
+        p = subprocess.Popen(
+            local_cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        display.debug("done running command with Popen()")
+
+        if self.become and self.become.expect_prompt() and sudoable:
+            fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) | os.O_NONBLOCK)
+            fcntl.fcntl(p.stderr, fcntl.F_SETFL, fcntl.fcntl(p.stderr, fcntl.F_GETFL) | os.O_NONBLOCK)
+            selector = selectors.DefaultSelector()
+            selector.register(p.stdout, selectors.EVENT_READ)
+            selector.register(p.stderr, selectors.EVENT_READ)
+
+            become_output = b''
+            try:
+                while not self.become.check_success(become_output) and not self.become.check_password_prompt(become_output):
+                    events = selector.select(self._play_context.timeout)
+                    if not events:
+                        stdout, stderr = p.communicate()
+                        raise AnsibleError('timeout waiting for privilege escalation password prompt:\n' + to_native(become_output))
+
+                    for key, event in events:
+                        if key.fileobj == p.stdout:
+                            chunk = p.stdout.read()
+                        elif key.fileobj == p.stderr:
+                            chunk = p.stderr.read()
+
+                    if not chunk:
+                        stdout, stderr = p.communicate()
+                        raise AnsibleError('privilege output closed while waiting for password prompt:\n' + to_native(become_output))
+                    become_output += chunk
+            finally:
+                selector.close()
+
+            if not self.become.check_success(become_output):
+                become_pass = self.become.get_option('become_pass', playcontext=self._play_context)
+                p.stdin.write(to_bytes(become_pass, errors='surrogate_or_strict') + b'\n')
+            fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) & ~os.O_NONBLOCK)
+            fcntl.fcntl(p.stderr, fcntl.F_SETFL, fcntl.fcntl(p.stderr, fcntl.F_GETFL) & ~os.O_NONBLOCK)
+
+        display.debug("getting output with communicate()")
+        stdout, stderr = p.communicate(in_data)
+        display.debug("done communicating")
+
+        display.debug("done with docker.exec_command()")
+        return (p.returncode, stdout, stderr)
+
+    def _prefix_login_path(self, remote_path):
+        ''' Make sure that we put files into a standard path
+
+            If a path is relative, then we need to choose where to put it.
+            ssh chooses $HOME but we aren't guaranteed that a home dir will
+            exist in any given chroot.  So for now we're choosing "/" instead.
+            This also happens to be the former default.
+
+            Can revisit using $HOME instead if it's a problem
+        '''
+        if not remote_path.startswith(os.path.sep):
+            remote_path = os.path.join(os.path.sep, remote_path)
+        return os.path.normpath(remote_path)
+
+    def put_file(self, in_path, out_path):
+        """ Transfer a file from local to docker container """
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self._play_context.remote_addr)
+
+        out_path = self._prefix_login_path(out_path)
+        if not os.path.exists(to_bytes(in_path, errors='surrogate_or_strict')):
+            raise AnsibleFileNotFound(
+                "file or module does not exist: %s" % to_native(in_path))
+
+        out_path = shlex_quote(out_path)
+        # Older docker doesn't have native support for copying files into
+        # running containers, so we use docker exec to implement this
+        # Although docker version 1.8 and later provide support, the
+        # owner and group of the files are always set to root
+        with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as in_file:
+            if not os.fstat(in_file.fileno()).st_size:
+                count = ' count=0'
+            else:
+                count = ''
+            args = self._build_exec_cmd([self._play_context.executable, "-c", "dd of=%s bs=%s%s" % (out_path, BUFSIZE, count)])
+            args = [to_bytes(i, errors='surrogate_or_strict') for i in args]
+            try:
+                p = subprocess.Popen(args, stdin=in_file,
+                                     stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            except OSError:
+                raise AnsibleError("docker connection requires dd command in the container to put files")
+            stdout, stderr = p.communicate()
+
+            if p.returncode != 0:
+                raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" %
+                                   (to_native(in_path), to_native(out_path), to_native(stdout), to_native(stderr)))
+
+    def fetch_file(self, in_path, out_path):
+        """ Fetch a file from container to local. """
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self._play_context.remote_addr)
+
+        in_path = self._prefix_login_path(in_path)
+        # out_path is the final file path, but docker takes a directory, not a
+        # file path
+        out_dir = os.path.dirname(out_path)
+
+        args = [self.docker_cmd, "cp", "%s:%s" % (self._play_context.remote_addr, in_path), out_dir]
+        args = [to_bytes(i, errors='surrogate_or_strict') for i in args]
+
+        p = subprocess.Popen(args, stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p.communicate()
+
+        actual_out_path = os.path.join(out_dir, os.path.basename(in_path))
+
+        if p.returncode != 0:
+            # Older docker doesn't have native support for fetching files command `cp`
+            # If `cp` fails, try to use `dd` instead
+            args = self._build_exec_cmd([self._play_context.executable, "-c", "dd if=%s bs=%s" % (in_path, BUFSIZE)])
+            args = [to_bytes(i, errors='surrogate_or_strict') for i in args]
+            with open(to_bytes(actual_out_path, errors='surrogate_or_strict'), 'wb') as out_file:
+                try:
+                    p = subprocess.Popen(args, stdin=subprocess.PIPE,
+                                         stdout=out_file, stderr=subprocess.PIPE)
+                except OSError:
+                    raise AnsibleError("docker connection requires dd command in the container to put files")
+                stdout, stderr = p.communicate()
+
+                if p.returncode != 0:
+                    raise AnsibleError("failed to fetch file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+
+        # Rename if needed
+        if actual_out_path != out_path:
+            os.rename(to_bytes(actual_out_path, errors='strict'), to_bytes(out_path, errors='strict'))
+
+    def close(self):
+        """ Terminate the connection. Nothing to do for Docker"""
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/funcd.py

@@ -0,0 +1,102 @@
+# Based on local.py (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
+# Based on chroot.py (c) 2013, Maykel Moya <mmoya@speedyrails.com>
+# Copyright (c) 2013, Michael Scherer <misc@zarb.org>
+# 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
+
+DOCUMENTATION = '''
+    author: Michael Scherer (@msherer) <misc@zarb.org>
+    connection: funcd
+    short_description: Use funcd to connect to target
+    description:
+        - This transport permits you to use Ansible over Func.
+        - For people who have already setup func and that wish to play with ansible,
+          this permit to move gradually to ansible without having to redo completely the setup of the network.
+    options:
+      remote_addr:
+        description:
+            - The path of the chroot you want to access.
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+            - name: ansible_func_host
+'''
+
+HAVE_FUNC = False
+try:
+    import func.overlord.client as fc
+    HAVE_FUNC = True
+except ImportError:
+    pass
+
+import os
+import tempfile
+import shutil
+
+from ansible.errors import AnsibleError
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(object):
+    ''' Func-based connections '''
+
+    has_pipelining = False
+
+    def __init__(self, runner, host, port, *args, **kwargs):
+        self.runner = runner
+        self.host = host
+        # port is unused, this go on func
+        self.port = port
+
+    def connect(self, port=None):
+        if not HAVE_FUNC:
+            raise AnsibleError("func is not installed")
+
+        self.client = fc.Client(self.host)
+        return self
+
+    def exec_command(self, cmd, become_user=None, sudoable=False, executable='/bin/sh', in_data=None):
+        ''' run a command on the remote minion '''
+
+        if in_data:
+            raise AnsibleError("Internal Error: this module does not support optimized module pipelining")
+
+        # totally ignores privlege escalation
+        display.vvv("EXEC %s" % (cmd), host=self.host)
+        p = self.client.command.run(cmd)[self.host]
+        return (p[0], p[1], p[2])
+
+    def _normalize_path(self, path, prefix):
+        if not path.startswith(os.path.sep):
+            path = os.path.join(os.path.sep, path)
+        normpath = os.path.normpath(path)
+        return os.path.join(prefix, normpath[1:])
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to remote '''
+
+        out_path = self._normalize_path(out_path, '/')
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.host)
+        self.client.local.copyfile.send(in_path, out_path)
+
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from remote to local '''
+
+        in_path = self._normalize_path(in_path, '/')
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.host)
+        # need to use a tmp dir due to difference of semantic for getfile
+        # ( who take a # directory as destination) and fetch_file, who
+        # take a file directly
+        tmpdir = tempfile.mkdtemp(prefix="func_ansible")
+        self.client.local.getfile.get(in_path, tmpdir)
+        shutil.move(os.path.join(tmpdir, self.host, os.path.basename(in_path)), out_path)
+        shutil.rmtree(tmpdir)
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        pass

plugins/connection/iocage.py

@@ -0,0 +1,82 @@
+# Based on jail.py
+# (c) 2013, Michael Scherer <misc@zarb.org>
+# (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
+# (c) 2016, Stephan Lohse <dev-github@ploek.org>
+# 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
+
+DOCUMENTATION = '''
+    author: Stephan Lohse <dev-github@ploek.org>
+    connection: iocage
+    short_description: Run tasks in iocage jails
+    description:
+        - Run commands or put/fetch files to an existing iocage jail
+    options:
+      remote_addr:
+        description:
+            - Path to the jail
+        vars:
+            - name: ansible_host
+            - name: ansible_iocage_host
+      remote_user:
+        description:
+            - User to execute as inside the jail
+        vars:
+            - name: ansible_user
+            - name: ansible_iocage_user
+'''
+
+import subprocess
+
+from ansible_collections.community.general.plugins.connection.jail import Connection as Jail
+from ansible.module_utils._text import to_native
+from ansible.errors import AnsibleError
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(Jail):
+    ''' Local iocage based connections '''
+
+    transport = 'community.general.iocage'
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        self.ioc_jail = play_context.remote_addr
+
+        self.iocage_cmd = Jail._search_executable('iocage')
+
+        jail_uuid = self.get_jail_uuid()
+
+        kwargs[Jail.modified_jailname_key] = 'ioc-{0}'.format(jail_uuid)
+
+        display.vvv(u"Jail {iocjail} has been translated to {rawjail}".format(
+            iocjail=self.ioc_jail, rawjail=kwargs[Jail.modified_jailname_key]),
+            host=kwargs[Jail.modified_jailname_key])
+
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+    def get_jail_uuid(self):
+        p = subprocess.Popen([self.iocage_cmd, 'get', 'host_hostuuid', self.ioc_jail],
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.STDOUT)
+
+        stdout, stderr = p.communicate()
+
+        if stdout is not None:
+            stdout = to_native(stdout)
+
+        if stderr is not None:
+            stderr = to_native(stderr)
+
+        # otherwise p.returncode would not be set
+        p.wait()
+
+        if p.returncode != 0:
+            raise AnsibleError(u"iocage returned an error: {0}".format(stdout))
+
+        return stdout.strip('\n')

plugins/connection/jail.py

@@ -0,0 +1,201 @@
+# Based on local.py by Michael DeHaan <michael.dehaan@gmail.com>
+# and chroot.py by  Maykel Moya <mmoya@speedyrails.com>
+# Copyright (c) 2013, Michael Scherer <misc@zarb.org>
+# Copyright (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
+# 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
+
+DOCUMENTATION = '''
+    author: Ansible Core Team
+    connection: jail
+    short_description: Run tasks in jails
+    description:
+        - Run commands or put/fetch files to an existing jail
+    options:
+      remote_addr:
+        description:
+            - Path to the jail
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+            - name: ansible_jail_host
+      remote_user:
+        description:
+            - User to execute as inside the jail
+        vars:
+            - name: ansible_user
+            - name: ansible_jail_user
+'''
+
+import distutils.spawn
+import os
+import os.path
+import subprocess
+import traceback
+import ansible.constants as C
+
+from ansible.errors import AnsibleError
+from ansible.module_utils.six.moves import shlex_quote
+from ansible.module_utils._text import to_bytes, to_native, to_text
+from ansible.plugins.connection import ConnectionBase, BUFSIZE
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(ConnectionBase):
+    ''' Local BSD Jail based connections '''
+
+    modified_jailname_key = 'conn_jail_name'
+
+    transport = 'community.general.jail'
+    # Pipelining may work.  Someone needs to test by setting this to True and
+    # having pipelining=True in their ansible.cfg
+    has_pipelining = True
+    has_tty = False
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        self.jail = self._play_context.remote_addr
+        if self.modified_jailname_key in kwargs:
+            self.jail = kwargs[self.modified_jailname_key]
+
+        if os.geteuid() != 0:
+            raise AnsibleError("jail connection requires running as root")
+
+        self.jls_cmd = self._search_executable('jls')
+        self.jexec_cmd = self._search_executable('jexec')
+
+        if self.jail not in self.list_jails():
+            raise AnsibleError("incorrect jail name %s" % self.jail)
+
+    @staticmethod
+    def _search_executable(executable):
+        cmd = distutils.spawn.find_executable(executable)
+        if not cmd:
+            raise AnsibleError("%s command not found in PATH" % executable)
+        return cmd
+
+    def list_jails(self):
+        p = subprocess.Popen([self.jls_cmd, '-q', 'name'],
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        stdout, stderr = p.communicate()
+
+        return to_text(stdout, errors='surrogate_or_strict').split()
+
+    def _connect(self):
+        ''' connect to the jail; nothing to do here '''
+        super(Connection, self)._connect()
+        if not self._connected:
+            display.vvv(u"ESTABLISH JAIL CONNECTION FOR USER: {0}".format(self._play_context.remote_user), host=self.jail)
+            self._connected = True
+
+    def _buffered_exec_command(self, cmd, stdin=subprocess.PIPE):
+        ''' run a command on the jail.  This is only needed for implementing
+        put_file() get_file() so that we don't have to read the whole file
+        into memory.
+
+        compared to exec_command() it looses some niceties like being able to
+        return the process's exit code immediately.
+        '''
+
+        local_cmd = [self.jexec_cmd]
+        set_env = ''
+
+        if self._play_context.remote_user is not None:
+            local_cmd += ['-U', self._play_context.remote_user]
+            # update HOME since -U does not update the jail environment
+            set_env = 'HOME=~' + self._play_context.remote_user + ' '
+
+        local_cmd += [self.jail, self._play_context.executable, '-c', set_env + cmd]
+
+        display.vvv("EXEC %s" % (local_cmd,), host=self.jail)
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+        p = subprocess.Popen(local_cmd, shell=False, stdin=stdin,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        return p
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        ''' run a command on the jail '''
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        p = self._buffered_exec_command(cmd)
+
+        stdout, stderr = p.communicate(in_data)
+        return (p.returncode, stdout, stderr)
+
+    def _prefix_login_path(self, remote_path):
+        ''' Make sure that we put files into a standard path
+
+            If a path is relative, then we need to choose where to put it.
+            ssh chooses $HOME but we aren't guaranteed that a home dir will
+            exist in any given chroot.  So for now we're choosing "/" instead.
+            This also happens to be the former default.
+
+            Can revisit using $HOME instead if it's a problem
+        '''
+        if not remote_path.startswith(os.path.sep):
+            remote_path = os.path.join(os.path.sep, remote_path)
+        return os.path.normpath(remote_path)
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to jail '''
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.jail)
+
+        out_path = shlex_quote(self._prefix_login_path(out_path))
+        try:
+            with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as in_file:
+                if not os.fstat(in_file.fileno()).st_size:
+                    count = ' count=0'
+                else:
+                    count = ''
+                try:
+                    p = self._buffered_exec_command('dd of=%s bs=%s%s' % (out_path, BUFSIZE, count), stdin=in_file)
+                except OSError:
+                    raise AnsibleError("jail connection requires dd command in the jail")
+                try:
+                    stdout, stderr = p.communicate()
+                except Exception:
+                    traceback.print_exc()
+                    raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+                if p.returncode != 0:
+                    raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, to_native(stdout), to_native(stderr)))
+        except IOError:
+            raise AnsibleError("file or module does not exist at: %s" % in_path)
+
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from jail to local '''
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.jail)
+
+        in_path = shlex_quote(self._prefix_login_path(in_path))
+        try:
+            p = self._buffered_exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE))
+        except OSError:
+            raise AnsibleError("jail connection requires dd command in the jail")
+
+        with open(to_bytes(out_path, errors='surrogate_or_strict'), 'wb+') as out_file:
+            try:
+                chunk = p.stdout.read(BUFSIZE)
+                while chunk:
+                    out_file.write(chunk)
+                    chunk = p.stdout.read(BUFSIZE)
+            except Exception:
+                traceback.print_exc()
+                raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+            stdout, stderr = p.communicate()
+            if p.returncode != 0:
+                raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, to_native(stdout), to_native(stderr)))
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/kubectl.py

@@ -0,0 +1,355 @@
+# Based on the docker connection plugin
+#
+# Connection plugin for configuring kubernetes containers with kubectl
+# (c) 2017, XuXinkun <xuxinkun@gmail.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    author:
+        - xuxinkun
+
+    connection: kubectl
+
+    short_description: Execute tasks in pods running on Kubernetes.
+
+    description:
+        - Use the kubectl exec command to run tasks in, or put/fetch files to, pods running on the Kubernetes
+          container platform.
+
+
+    requirements:
+      - kubectl (go binary)
+
+    options:
+      kubectl_pod:
+        description:
+          - Pod name. Required when the host name does not match pod name.
+        default: ''
+        vars:
+          - name: ansible_kubectl_pod
+        env:
+          - name: K8S_AUTH_POD
+      kubectl_container:
+        description:
+          - Container name. Required when a pod contains more than one container.
+        default: ''
+        vars:
+          - name: ansible_kubectl_container
+        env:
+          - name: K8S_AUTH_CONTAINER
+      kubectl_namespace:
+        description:
+          - The namespace of the pod
+        default: ''
+        vars:
+          - name: ansible_kubectl_namespace
+        env:
+          - name: K8S_AUTH_NAMESPACE
+      kubectl_extra_args:
+        description:
+          - Extra arguments to pass to the kubectl command line.
+        default: ''
+        vars:
+          - name: ansible_kubectl_extra_args
+        env:
+          - name: K8S_AUTH_EXTRA_ARGS
+      kubectl_kubeconfig:
+        description:
+          - Path to a kubectl config file. Defaults to I(~/.kube/config)
+        default: ''
+        vars:
+          - name: ansible_kubectl_kubeconfig
+          - name: ansible_kubectl_config
+        env:
+          - name: K8S_AUTH_KUBECONFIG
+      kubectl_context:
+        description:
+          - The name of a context found in the K8s config file.
+        default: ''
+        vars:
+          - name: ansible_kubectl_context
+        env:
+          - name: k8S_AUTH_CONTEXT
+      kubectl_host:
+        description:
+          - URL for accessing the API.
+        default: ''
+        vars:
+          - name: ansible_kubectl_host
+          - name: ansible_kubectl_server
+        env:
+          - name: K8S_AUTH_HOST
+          - name: K8S_AUTH_SERVER
+      kubectl_username:
+        description:
+          - Provide a username for authenticating with the API.
+        default: ''
+        vars:
+          - name: ansible_kubectl_username
+          - name: ansible_kubectl_user
+        env:
+          - name: K8S_AUTH_USERNAME
+      kubectl_password:
+        description:
+          - Provide a password for authenticating with the API.
+        default: ''
+        vars:
+          - name: ansible_kubectl_password
+        env:
+          - name: K8S_AUTH_PASSWORD
+      kubectl_token:
+        description:
+          - API authentication bearer token.
+        vars:
+          - name: ansible_kubectl_token
+          - name: ansible_kubectl_api_key
+        env:
+          - name: K8S_AUTH_TOKEN
+          - name: K8S_AUTH_API_KEY
+      client_cert:
+        description:
+          - Path to a certificate used to authenticate with the API.
+        default: ''
+        vars:
+          - name: ansible_kubectl_cert_file
+          - name: ansible_kubectl_client_cert
+        env:
+          - name: K8S_AUTH_CERT_FILE
+        aliases: [ kubectl_cert_file ]
+      client_key:
+        description:
+          - Path to a key file used to authenticate with the API.
+        default: ''
+        vars:
+          - name: ansible_kubectl_key_file
+          - name: ansible_kubectl_client_key
+        env:
+          - name: K8S_AUTH_KEY_FILE
+        aliases: [ kubectl_key_file ]
+      ca_cert:
+        description:
+          - Path to a CA certificate used to authenticate with the API.
+        default: ''
+        vars:
+          - name: ansible_kubectl_ssl_ca_cert
+          - name: ansible_kubectl_ca_cert
+        env:
+          - name: K8S_AUTH_SSL_CA_CERT
+        aliases: [ kubectl_ssl_ca_cert ]
+      validate_certs:
+        description:
+          - Whether or not to verify the API server's SSL certificate. Defaults to I(true).
+        default: ''
+        vars:
+          - name: ansible_kubectl_verify_ssl
+          - name: ansible_kubectl_validate_certs
+        env:
+          - name: K8S_AUTH_VERIFY_SSL
+        aliases: [ kubectl_verify_ssl ]
+'''
+
+import distutils.spawn
+import os
+import os.path
+import subprocess
+
+import ansible.constants as C
+from ansible.parsing.yaml.loader import AnsibleLoader
+from ansible.errors import AnsibleError, AnsibleFileNotFound
+from ansible.module_utils.six.moves import shlex_quote
+from ansible.module_utils._text import to_bytes
+from ansible.plugins.connection import ConnectionBase, BUFSIZE
+from ansible.utils.display import Display
+
+display = Display()
+
+
+CONNECTION_TRANSPORT = 'kubectl'
+
+CONNECTION_OPTIONS = {
+    'kubectl_container': '-c',
+    'kubectl_namespace': '-n',
+    'kubectl_kubeconfig': '--kubeconfig',
+    'kubectl_context': '--context',
+    'kubectl_host': '--server',
+    'kubectl_username': '--username',
+    'kubectl_password': '--password',
+    'client_cert': '--client-certificate',
+    'client_key': '--client-key',
+    'ca_cert': '--certificate-authority',
+    'validate_certs': '--insecure-skip-tls-verify',
+    'kubectl_token': '--token'
+}
+
+
+class Connection(ConnectionBase):
+    ''' Local kubectl based connections '''
+
+    transport = CONNECTION_TRANSPORT
+    connection_options = CONNECTION_OPTIONS
+    documentation = DOCUMENTATION
+    has_pipelining = True
+    transport_cmd = None
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        # Note: kubectl runs commands as the user that started the container.
+        # It is impossible to set the remote user for a kubectl connection.
+        cmd_arg = '{0}_command'.format(self.transport)
+        if cmd_arg in kwargs:
+            self.transport_cmd = kwargs[cmd_arg]
+        else:
+            self.transport_cmd = distutils.spawn.find_executable(self.transport)
+            if not self.transport_cmd:
+                raise AnsibleError("{0} command not found in PATH".format(self.transport))
+
+    def _build_exec_cmd(self, cmd):
+        """ Build the local kubectl exec command to run cmd on remote_host
+        """
+        local_cmd = [self.transport_cmd]
+
+        # Build command options based on doc string
+        doc_yaml = AnsibleLoader(self.documentation).get_single_data()
+        for key in doc_yaml.get('options'):
+            if key.endswith('verify_ssl') and self.get_option(key) != '':
+                # Translate verify_ssl to skip_verify_ssl, and output as string
+                skip_verify_ssl = not self.get_option(key)
+                local_cmd.append(u'{0}={1}'.format(self.connection_options[key], str(skip_verify_ssl).lower()))
+            elif not key.endswith('container') and self.get_option(key) and self.connection_options.get(key):
+                cmd_arg = self.connection_options[key]
+                local_cmd += [cmd_arg, self.get_option(key)]
+
+        extra_args_name = u'{0}_extra_args'.format(self.transport)
+        if self.get_option(extra_args_name):
+            local_cmd += self.get_option(extra_args_name).split(' ')
+
+        pod = self.get_option(u'{0}_pod'.format(self.transport))
+        if not pod:
+            pod = self._play_context.remote_addr
+        # -i is needed to keep stdin open which allows pipelining to work
+        local_cmd += ['exec', '-i', pod]
+
+        # if the pod has more than one container, then container is required
+        container_arg_name = u'{0}_container'.format(self.transport)
+        if self.get_option(container_arg_name):
+            local_cmd += ['-c', self.get_option(container_arg_name)]
+
+        local_cmd += ['--'] + cmd
+
+        return local_cmd
+
+    def _connect(self, port=None):
+        """ Connect to the container. Nothing to do """
+        super(Connection, self)._connect()
+        if not self._connected:
+            display.vvv(u"ESTABLISH {0} CONNECTION".format(self.transport), host=self._play_context.remote_addr)
+            self._connected = True
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        """ Run a command in the container """
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        local_cmd = self._build_exec_cmd([self._play_context.executable, '-c', cmd])
+
+        display.vvv("EXEC %s" % (local_cmd,), host=self._play_context.remote_addr)
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+        p = subprocess.Popen(local_cmd, shell=False, stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        stdout, stderr = p.communicate(in_data)
+        return (p.returncode, stdout, stderr)
+
+    def _prefix_login_path(self, remote_path):
+        ''' Make sure that we put files into a standard path
+
+            If a path is relative, then we need to choose where to put it.
+            ssh chooses $HOME but we aren't guaranteed that a home dir will
+            exist in any given chroot.  So for now we're choosing "/" instead.
+            This also happens to be the former default.
+
+            Can revisit using $HOME instead if it's a problem
+        '''
+        if not remote_path.startswith(os.path.sep):
+            remote_path = os.path.join(os.path.sep, remote_path)
+        return os.path.normpath(remote_path)
+
+    def put_file(self, in_path, out_path):
+        """ Transfer a file from local to the container """
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self._play_context.remote_addr)
+
+        out_path = self._prefix_login_path(out_path)
+        if not os.path.exists(to_bytes(in_path, errors='surrogate_or_strict')):
+            raise AnsibleFileNotFound(
+                "file or module does not exist: %s" % in_path)
+
+        out_path = shlex_quote(out_path)
+        # kubectl doesn't have native support for copying files into
+        # running containers, so we use kubectl exec to implement this
+        with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as in_file:
+            if not os.fstat(in_file.fileno()).st_size:
+                count = ' count=0'
+            else:
+                count = ''
+            args = self._build_exec_cmd([self._play_context.executable, "-c", "dd of=%s bs=%s%s" % (out_path, BUFSIZE, count)])
+            args = [to_bytes(i, errors='surrogate_or_strict') for i in args]
+            try:
+                p = subprocess.Popen(args, stdin=in_file,
+                                     stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            except OSError:
+                raise AnsibleError("kubectl connection requires dd command in the container to put files")
+            stdout, stderr = p.communicate()
+
+            if p.returncode != 0:
+                raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+
+    def fetch_file(self, in_path, out_path):
+        """ Fetch a file from container to local. """
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self._play_context.remote_addr)
+
+        in_path = self._prefix_login_path(in_path)
+        out_dir = os.path.dirname(out_path)
+
+        # kubectl doesn't have native support for fetching files from
+        # running containers, so we use kubectl exec to implement this
+        args = self._build_exec_cmd([self._play_context.executable, "-c", "dd if=%s bs=%s" % (in_path, BUFSIZE)])
+        args = [to_bytes(i, errors='surrogate_or_strict') for i in args]
+        actual_out_path = os.path.join(out_dir, os.path.basename(in_path))
+        with open(to_bytes(actual_out_path, errors='surrogate_or_strict'), 'wb') as out_file:
+            try:
+                p = subprocess.Popen(args, stdin=subprocess.PIPE,
+                                     stdout=out_file, stderr=subprocess.PIPE)
+            except OSError:
+                raise AnsibleError(
+                    "{0} connection requires dd command in the container to fetch files".format(self.transport)
+                )
+            stdout, stderr = p.communicate()
+
+            if p.returncode != 0:
+                raise AnsibleError("failed to fetch file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+
+        if actual_out_path != out_path:
+            os.rename(to_bytes(actual_out_path, errors='strict'), to_bytes(out_path, errors='strict'))
+
+    def close(self):
+        """ Terminate the connection. Nothing to do for kubectl"""
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/libvirt_lxc.py

@@ -0,0 +1,181 @@
+# Based on local.py (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
+# Based on chroot.py (c) 2013, Maykel Moya <mmoya@speedyrails.com>
+# (c) 2013, Michael Scherer <misc@zarb.org>
+# (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
+# (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
+
+DOCUMENTATION = '''
+    author: Michael Scherer <misc@zarb.org>
+    connection: libvirt_lxc
+    short_description: Run tasks in lxc containers via libvirt
+    description:
+        - Run commands or put/fetch files to an existing lxc container using libvirt
+    options:
+      remote_addr:
+        description:
+            - Container identifier
+        default: The set user as per docker's configuration
+        vars:
+            - name: ansible_host
+            - name: ansible_libvirt_lxc_host
+'''
+
+import distutils.spawn
+import os
+import os.path
+import subprocess
+import traceback
+
+from ansible import constants as C
+from ansible.errors import AnsibleError
+from ansible.module_utils.six.moves import shlex_quote
+from ansible.module_utils._text import to_bytes
+from ansible.plugins.connection import ConnectionBase, BUFSIZE
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(ConnectionBase):
+    ''' Local lxc based connections '''
+
+    transport = 'community.general.libvirt_lxc'
+    has_pipelining = True
+    # su currently has an undiagnosed issue with calculating the file
+    # checksums (so copy, for instance, doesn't work right)
+    # Have to look into that before re-enabling this
+    default_user = 'root'
+    has_tty = False
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+        self.lxc = self._play_context.remote_addr
+
+        self.virsh = self._search_executable('virsh')
+
+        self._check_domain(self.lxc)
+
+    def _search_executable(self, executable):
+        cmd = distutils.spawn.find_executable(executable)
+        if not cmd:
+            raise AnsibleError("%s command not found in PATH") % executable
+        return cmd
+
+    def _check_domain(self, domain):
+        p = subprocess.Popen([self.virsh, '-q', '-c', 'lxc:///', 'dominfo', to_bytes(domain)],
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p.communicate()
+        if p.returncode:
+            raise AnsibleError("%s is not a lxc defined in libvirt" % domain)
+
+    def _connect(self):
+        ''' connect to the lxc; nothing to do here '''
+        super(Connection, self)._connect()
+        if not self._connected:
+            display.vvv("THIS IS A LOCAL LXC DIR", host=self.lxc)
+            self._connected = True
+
+    def _buffered_exec_command(self, cmd, stdin=subprocess.PIPE):
+        ''' run a command on the chroot.  This is only needed for implementing
+        put_file() get_file() so that we don't have to read the whole file
+        into memory.
+
+        compared to exec_command() it looses some niceties like being able to
+        return the process's exit code immediately.
+        '''
+        executable = C.DEFAULT_EXECUTABLE.split()[0] if C.DEFAULT_EXECUTABLE else '/bin/sh'
+        local_cmd = [self.virsh, '-q', '-c', 'lxc:///', 'lxc-enter-namespace']
+
+        if C.DEFAULT_LIBVIRT_LXC_NOSECLABEL:
+            local_cmd += ['--noseclabel']
+
+        local_cmd += [self.lxc, '--', executable, '-c', cmd]
+
+        display.vvv("EXEC %s" % (local_cmd,), host=self.lxc)
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+        p = subprocess.Popen(local_cmd, shell=False, stdin=stdin,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        return p
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        ''' run a command on the chroot '''
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        p = self._buffered_exec_command(cmd)
+
+        stdout, stderr = p.communicate(in_data)
+        return (p.returncode, stdout, stderr)
+
+    def _prefix_login_path(self, remote_path):
+        ''' Make sure that we put files into a standard path
+
+            If a path is relative, then we need to choose where to put it.
+            ssh chooses $HOME but we aren't guaranteed that a home dir will
+            exist in any given chroot.  So for now we're choosing "/" instead.
+            This also happens to be the former default.
+
+            Can revisit using $HOME instead if it's a problem
+        '''
+        if not remote_path.startswith(os.path.sep):
+            remote_path = os.path.join(os.path.sep, remote_path)
+        return os.path.normpath(remote_path)
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to lxc '''
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.lxc)
+
+        out_path = shlex_quote(self._prefix_login_path(out_path))
+        try:
+            with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as in_file:
+                if not os.fstat(in_file.fileno()).st_size:
+                    count = ' count=0'
+                else:
+                    count = ''
+                try:
+                    p = self._buffered_exec_command('dd of=%s bs=%s%s' % (out_path, BUFSIZE, count), stdin=in_file)
+                except OSError:
+                    raise AnsibleError("chroot connection requires dd command in the chroot")
+                try:
+                    stdout, stderr = p.communicate()
+                except Exception:
+                    traceback.print_exc()
+                    raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+                if p.returncode != 0:
+                    raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+        except IOError:
+            raise AnsibleError("file or module does not exist at: %s" % in_path)
+
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from lxc to local '''
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.lxc)
+
+        in_path = shlex_quote(self._prefix_login_path(in_path))
+        try:
+            p = self._buffered_exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE))
+        except OSError:
+            raise AnsibleError("chroot connection requires dd command in the chroot")
+
+        with open(to_bytes(out_path, errors='surrogate_or_strict'), 'wb+') as out_file:
+            try:
+                chunk = p.stdout.read(BUFSIZE)
+                while chunk:
+                    out_file.write(chunk)
+                    chunk = p.stdout.read(BUFSIZE)
+            except Exception:
+                traceback.print_exc()
+                raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+            stdout, stderr = p.communicate()
+            if p.returncode != 0:
+                raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/lxc.py

@@ -0,0 +1,228 @@
+# (c) 2015, Joerg Thalheim <joerg@higgsboson.tk>
+# 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
+
+DOCUMENTATION = '''
+    author: Joerg Thalheim <joerg@higgsboson.tk>
+    connection: lxc
+    short_description: Run tasks in lxc containers via lxc python library
+    description:
+        - Run commands or put/fetch files to an existing lxc container using lxc python library
+    options:
+      remote_addr:
+        description:
+            - Container identifier
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+            - name: ansible_lxc_host
+      executable:
+        default: /bin/sh
+        description:
+            - Shell executable
+        vars:
+            - name: ansible_executable
+            - name: ansible_lxc_executable
+'''
+
+import os
+import shutil
+import traceback
+import select
+import fcntl
+import errno
+
+HAS_LIBLXC = False
+try:
+    import lxc as _lxc
+    HAS_LIBLXC = True
+except ImportError:
+    pass
+
+from ansible import constants as C
+from ansible import errors
+from ansible.module_utils._text import to_bytes, to_native
+from ansible.plugins.connection import ConnectionBase
+
+
+class Connection(ConnectionBase):
+    ''' Local lxc based connections '''
+
+    transport = 'community.general.lxc'
+    has_pipelining = True
+    default_user = 'root'
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        self.container_name = self._play_context.remote_addr
+        self.container = None
+
+    def _connect(self):
+        ''' connect to the lxc; nothing to do here '''
+        super(Connection, self)._connect()
+
+        if not HAS_LIBLXC:
+            msg = "lxc bindings for python2 are not installed"
+            raise errors.AnsibleError(msg)
+
+        if self.container:
+            return
+
+        self._display.vvv("THIS IS A LOCAL LXC DIR", host=self.container_name)
+        self.container = _lxc.Container(self.container_name)
+        if self.container.state == "STOPPED":
+            raise errors.AnsibleError("%s is not running" % self.container_name)
+
+    def _communicate(self, pid, in_data, stdin, stdout, stderr):
+        buf = {stdout: [], stderr: []}
+        read_fds = [stdout, stderr]
+        if in_data:
+            write_fds = [stdin]
+        else:
+            write_fds = []
+        while len(read_fds) > 0 or len(write_fds) > 0:
+            try:
+                ready_reads, ready_writes, _ = select.select(read_fds, write_fds, [])
+            except select.error as e:
+                if e.args[0] == errno.EINTR:
+                    continue
+                raise
+            for fd in ready_writes:
+                in_data = in_data[os.write(fd, in_data):]
+                if len(in_data) == 0:
+                    write_fds.remove(fd)
+            for fd in ready_reads:
+                data = os.read(fd, 32768)
+                if not data:
+                    read_fds.remove(fd)
+                buf[fd].append(data)
+
+        (pid, returncode) = os.waitpid(pid, 0)
+
+        return returncode, b"".join(buf[stdout]), b"".join(buf[stderr])
+
+    def _set_nonblocking(self, fd):
+        flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK
+        fcntl.fcntl(fd, fcntl.F_SETFL, flags)
+        return fd
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        ''' run a command on the chroot '''
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        # python2-lxc needs bytes. python3-lxc needs text.
+        executable = to_native(self._play_context.executable, errors='surrogate_or_strict')
+        local_cmd = [executable, '-c', to_native(cmd, errors='surrogate_or_strict')]
+
+        read_stdout, write_stdout = None, None
+        read_stderr, write_stderr = None, None
+        read_stdin, write_stdin = None, None
+
+        try:
+            read_stdout, write_stdout = os.pipe()
+            read_stderr, write_stderr = os.pipe()
+
+            kwargs = {
+                'stdout': self._set_nonblocking(write_stdout),
+                'stderr': self._set_nonblocking(write_stderr),
+                'env_policy': _lxc.LXC_ATTACH_CLEAR_ENV
+            }
+
+            if in_data:
+                read_stdin, write_stdin = os.pipe()
+                kwargs['stdin'] = self._set_nonblocking(read_stdin)
+
+            self._display.vvv("EXEC %s" % (local_cmd), host=self.container_name)
+            pid = self.container.attach(_lxc.attach_run_command, local_cmd, **kwargs)
+            if pid == -1:
+                msg = "failed to attach to container %s" % self.container_name
+                raise errors.AnsibleError(msg)
+
+            write_stdout = os.close(write_stdout)
+            write_stderr = os.close(write_stderr)
+            if read_stdin:
+                read_stdin = os.close(read_stdin)
+
+            return self._communicate(pid,
+                                     in_data,
+                                     write_stdin,
+                                     read_stdout,
+                                     read_stderr)
+        finally:
+            fds = [read_stdout,
+                   write_stdout,
+                   read_stderr,
+                   write_stderr,
+                   read_stdin,
+                   write_stdin]
+            for fd in fds:
+                if fd:
+                    os.close(fd)
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to lxc '''
+        super(Connection, self).put_file(in_path, out_path)
+        self._display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.container_name)
+        in_path = to_bytes(in_path, errors='surrogate_or_strict')
+        out_path = to_bytes(out_path, errors='surrogate_or_strict')
+
+        if not os.path.exists(in_path):
+            msg = "file or module does not exist: %s" % in_path
+            raise errors.AnsibleFileNotFound(msg)
+        try:
+            src_file = open(in_path, "rb")
+        except IOError:
+            traceback.print_exc()
+            raise errors.AnsibleError("failed to open input file to %s" % in_path)
+        try:
+            def write_file(args):
+                with open(out_path, 'wb+') as dst_file:
+                    shutil.copyfileobj(src_file, dst_file)
+            try:
+                self.container.attach_wait(write_file, None)
+            except IOError:
+                traceback.print_exc()
+                msg = "failed to transfer file to %s" % out_path
+                raise errors.AnsibleError(msg)
+        finally:
+            src_file.close()
+
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from lxc to local '''
+        super(Connection, self).fetch_file(in_path, out_path)
+        self._display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.container_name)
+        in_path = to_bytes(in_path, errors='surrogate_or_strict')
+        out_path = to_bytes(out_path, errors='surrogate_or_strict')
+
+        try:
+            dst_file = open(out_path, "wb")
+        except IOError:
+            traceback.print_exc()
+            msg = "failed to open output file %s" % out_path
+            raise errors.AnsibleError(msg)
+        try:
+            def write_file(args):
+                try:
+                    with open(in_path, 'rb') as src_file:
+                        shutil.copyfileobj(src_file, dst_file)
+                finally:
+                    # this is needed in the lxc child process
+                    # to flush internal python buffers
+                    dst_file.close()
+            try:
+                self.container.attach_wait(write_file, None)
+            except IOError:
+                traceback.print_exc()
+                msg = "failed to transfer file from %s to %s" % (in_path, out_path)
+                raise errors.AnsibleError(msg)
+        finally:
+            dst_file.close()
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/lxd.py

@@ -0,0 +1,125 @@
+# (c) 2016 Matt Clay <matt@mystile.com>
+# (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
+
+DOCUMENTATION = '''
+    author: Matt Clay <matt@mystile.com>
+    connection: lxd
+    short_description: Run tasks in lxc containers via lxc CLI
+    description:
+        - Run commands or put/fetch files to an existing lxc container using lxc CLI
+    options:
+      remote_addr:
+        description:
+            - Container identifier
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+            - name: ansible_lxd_host
+      executable:
+        description:
+            - shell to use for execution inside container
+        default: /bin/sh
+        vars:
+            - name: ansible_executable
+            - name: ansible_lxd_executable
+'''
+
+import os
+from distutils.spawn import find_executable
+from subprocess import Popen, PIPE
+
+from ansible.errors import AnsibleError, AnsibleConnectionFailure, AnsibleFileNotFound
+from ansible.module_utils._text import to_bytes, to_text
+from ansible.plugins.connection import ConnectionBase
+
+
+class Connection(ConnectionBase):
+    """ lxd based connections """
+
+    transport = 'community.general.lxd'
+    has_pipelining = True
+    default_user = 'root'
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        self._host = self._play_context.remote_addr
+        self._lxc_cmd = find_executable("lxc")
+
+        if not self._lxc_cmd:
+            raise AnsibleError("lxc command not found in PATH")
+
+        if self._play_context.remote_user is not None and self._play_context.remote_user != 'root':
+            self._display.warning('lxd does not support remote_user, using container default: root')
+
+    def _connect(self):
+        """connect to lxd (nothing to do here) """
+        super(Connection, self)._connect()
+
+        if not self._connected:
+            self._display.vvv(u"ESTABLISH LXD CONNECTION FOR USER: root", host=self._host)
+            self._connected = True
+
+    def exec_command(self, cmd, in_data=None, sudoable=True):
+        """ execute a command on the lxd host """
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        self._display.vvv(u"EXEC {0}".format(cmd), host=self._host)
+
+        local_cmd = [self._lxc_cmd, "exec", self._host, "--", self._play_context.executable, "-c", cmd]
+
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+        in_data = to_bytes(in_data, errors='surrogate_or_strict', nonstring='passthru')
+
+        process = Popen(local_cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        stdout, stderr = process.communicate(in_data)
+
+        stdout = to_text(stdout)
+        stderr = to_text(stderr)
+
+        if stderr == "error: Container is not running.\n":
+            raise AnsibleConnectionFailure("container not running: %s" % self._host)
+
+        if stderr == "error: not found\n":
+            raise AnsibleConnectionFailure("container not found: %s" % self._host)
+
+        return process.returncode, stdout, stderr
+
+    def put_file(self, in_path, out_path):
+        """ put a file from local to lxd """
+        super(Connection, self).put_file(in_path, out_path)
+
+        self._display.vvv(u"PUT {0} TO {1}".format(in_path, out_path), host=self._host)
+
+        if not os.path.isfile(to_bytes(in_path, errors='surrogate_or_strict')):
+            raise AnsibleFileNotFound("input path is not a file: %s" % in_path)
+
+        local_cmd = [self._lxc_cmd, "file", "push", in_path, self._host + "/" + out_path]
+
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+
+        process = Popen(local_cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        process.communicate()
+
+    def fetch_file(self, in_path, out_path):
+        """ fetch a file from lxd to local """
+        super(Connection, self).fetch_file(in_path, out_path)
+
+        self._display.vvv(u"FETCH {0} TO {1}".format(in_path, out_path), host=self._host)
+
+        local_cmd = [self._lxc_cmd, "file", "pull", self._host + "/" + in_path, out_path]
+
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+
+        process = Popen(local_cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        process.communicate()
+
+    def close(self):
+        """ close the connection (nothing to do here) """
+        super(Connection, self).close()
+
+        self._connected = False

plugins/connection/oc.py

@@ -0,0 +1,173 @@
+# Based on the docker connection plugin
+#
+# Connection plugin for configuring kubernetes containers with kubectl
+# (c) 2017, XuXinkun <xuxinkun@gmail.com>
+#
+# 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 <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+DOCUMENTATION = '''
+    author:
+        - xuxinkun
+
+    connection: oc
+
+    short_description: Execute tasks in pods running on OpenShift.
+
+    description:
+        - Use the oc exec command to run tasks in, or put/fetch files to, pods running on the OpenShift
+          container platform.
+
+
+    requirements:
+      - oc (go binary)
+
+    options:
+      oc_pod:
+        description:
+          - Pod name. Required when the host name does not match pod name.
+        default: ''
+        vars:
+          - name: ansible_oc_pod
+        env:
+          - name: K8S_AUTH_POD
+      oc_container:
+        description:
+          - Container name. Required when a pod contains more than one container.
+        default: ''
+        vars:
+          - name: ansible_oc_container
+        env:
+          - name: K8S_AUTH_CONTAINER
+      oc_namespace:
+        description:
+          - The namespace of the pod
+        default: ''
+        vars:
+          - name: ansible_oc_namespace
+        env:
+          - name: K8S_AUTH_NAMESPACE
+      oc_extra_args:
+        description:
+          - Extra arguments to pass to the oc command line.
+        default: ''
+        vars:
+          - name: ansible_oc_extra_args
+        env:
+          - name: K8S_AUTH_EXTRA_ARGS
+      oc_kubeconfig:
+        description:
+          - Path to a oc config file. Defaults to I(~/.kube/conig)
+        default: ''
+        vars:
+          - name: ansible_oc_kubeconfig
+          - name: ansible_oc_config
+        env:
+          - name: K8S_AUTH_KUBECONFIG
+      oc_context:
+        description:
+          - The name of a context found in the K8s config file.
+        default: ''
+        vars:
+          - name: ansible_oc_context
+        env:
+          - name: k8S_AUTH_CONTEXT
+      oc_host:
+        description:
+          - URL for accessing the API.
+        default: ''
+        vars:
+          - name: ansible_oc_host
+          - name: ansible_oc_server
+        env:
+          - name: K8S_AUTH_HOST
+          - name: K8S_AUTH_SERVER
+      oc_token:
+        description:
+          - API authentication bearer token.
+        vars:
+          - name: ansible_oc_token
+          - name: ansible_oc_api_key
+        env:
+          - name: K8S_AUTH_TOKEN
+          - name: K8S_AUTH_API_KEY
+      client_cert:
+        description:
+          - Path to a certificate used to authenticate with the API.
+        default: ''
+        vars:
+          - name: ansible_oc_cert_file
+          - name: ansible_oc_client_cert
+        env:
+          - name: K8S_AUTH_CERT_FILE
+        aliases: [ oc_cert_file ]
+      client_key:
+        description:
+          - Path to a key file used to authenticate with the API.
+        default: ''
+        vars:
+          - name: ansible_oc_key_file
+          - name: ansible_oc_client_key
+        env:
+          - name: K8S_AUTH_KEY_FILE
+        aliases: [ oc_key_file ]
+      ca_cert:
+        description:
+          - Path to a CA certificate used to authenticate with the API.
+        default: ''
+        vars:
+          - name: ansible_oc_ssl_ca_cert
+          - name: ansible_oc_ca_cert
+        env:
+          - name: K8S_AUTH_SSL_CA_CERT
+        aliases: [ oc_ssl_ca_cert ]
+      validate_certs:
+        description:
+          - Whether or not to verify the API server's SSL certificate. Defaults to I(true).
+        default: ''
+        vars:
+          - name: ansible_oc_verify_ssl
+          - name: ansible_oc_validate_certs
+        env:
+          - name: K8S_AUTH_VERIFY_SSL
+        aliases: [ oc_verify_ssl ]
+'''
+
+from ansible_collections.community.general.plugins.connection.kubectl import Connection as KubectlConnection
+
+
+CONNECTION_TRANSPORT = 'oc'
+
+CONNECTION_OPTIONS = {
+    'oc_container': '-c',
+    'oc_namespace': '-n',
+    'oc_kubeconfig': '--config',
+    'oc_context': '--context',
+    'oc_host': '--server',
+    'client_cert': '--client-certificate',
+    'client_key': '--client-key',
+    'ca_cert': '--certificate-authority',
+    'validate_certs': '--insecure-skip-tls-verify',
+    'oc_token': '--token'
+}
+
+
+class Connection(KubectlConnection):
+    ''' Local oc based connections '''
+    transport = CONNECTION_TRANSPORT
+    connection_options = CONNECTION_OPTIONS
+    documentation = DOCUMENTATION

plugins/connection/qubes.py

@@ -0,0 +1,159 @@
+# Based on the buildah connection plugin
+# Copyright (c) 2017 Ansible Project
+#               2018 Kushal Das
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+#
+# Written by: Kushal Das (https://github.com/kushaldas)
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+
+DOCUMENTATION = '''
+    connection: qubes
+    short_description: Interact with an existing QubesOS AppVM
+
+    description:
+        - Run commands or put/fetch files to an existing Qubes AppVM using qubes tools.
+
+    author: Kushal Das (@kushaldas)
+
+
+    options:
+      remote_addr:
+        description:
+            - vm name
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+      remote_user:
+        description:
+            - The user to execute as inside the vm.
+        default: The *user* account as default in Qubes OS.
+        vars:
+            - name: ansible_user
+#        keyword:
+#            - name: hosts
+'''
+
+import shlex
+import shutil
+
+import os
+import base64
+import subprocess
+
+import ansible.constants as C
+from ansible.module_utils._text import to_bytes, to_native
+from ansible.plugins.connection import ConnectionBase, ensure_connect
+from ansible.errors import AnsibleConnectionFailure
+from ansible.utils.display import Display
+
+display = Display()
+
+
+# this _has to be_ named Connection
+class Connection(ConnectionBase):
+    """This is a connection plugin for qubes: it uses qubes-run-vm binary to interact with the containers."""
+
+    # String used to identify this Connection class from other classes
+    transport = 'community.general.qubes'
+    has_pipelining = True
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        self._remote_vmname = self._play_context.remote_addr
+        self._connected = False
+        # Default username in Qubes
+        self.user = "user"
+        if self._play_context.remote_user:
+            self.user = self._play_context.remote_user
+
+    def _qubes(self, cmd=None, in_data=None, shell="qubes.VMShell"):
+        """run qvm-run executable
+
+        :param cmd: cmd string for remote system
+        :param in_data: data passed to qvm-run-vm's stdin
+        :return: return code, stdout, stderr
+        """
+        display.vvvv("CMD: ", cmd)
+        if not cmd.endswith("\n"):
+            cmd = cmd + "\n"
+        local_cmd = []
+
+        # For dom0
+        local_cmd.extend(["qvm-run", "--pass-io", "--service"])
+        if self.user != "user":
+            # Means we have a remote_user value
+            local_cmd.extend(["-u", self.user])
+
+        local_cmd.append(self._remote_vmname)
+
+        local_cmd.append(shell)
+
+        local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd]
+
+        display.vvvv("Local cmd: ", local_cmd)
+
+        display.vvv("RUN %s" % (local_cmd,), host=self._remote_vmname)
+        p = subprocess.Popen(local_cmd, shell=False, stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        # Here we are writing the actual command to the remote bash
+        p.stdin.write(to_bytes(cmd, errors='surrogate_or_strict'))
+        stdout, stderr = p.communicate(input=in_data)
+        return p.returncode, stdout, stderr
+
+    def _connect(self):
+        """No persistent connection is being maintained."""
+        super(Connection, self)._connect()
+        self._connected = True
+
+    @ensure_connect
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        """Run specified command in a running QubesVM """
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        display.vvvv("CMD IS: %s" % cmd)
+
+        rc, stdout, stderr = self._qubes(cmd)
+
+        display.vvvvv("STDOUT %r STDERR %r" % (stderr, stderr))
+        return rc, stdout, stderr
+
+    def put_file(self, in_path, out_path):
+        """ Place a local file located in 'in_path' inside VM at 'out_path' """
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self._remote_vmname)
+
+        with open(in_path, "rb") as fobj:
+            source_data = fobj.read()
+
+        retcode, dummy, dummy = self._qubes('cat > "{0}"\n'.format(out_path), source_data, "qubes.VMRootShell")
+        # if qubes.VMRootShell service not supported, fallback to qubes.VMShell and
+        # hope it will have appropriate permissions
+        if retcode == 127:
+            retcode, dummy, dummy = self._qubes('cat > "{0}"\n'.format(out_path), source_data)
+
+        if retcode != 0:
+            raise AnsibleConnectionFailure('Failed to put_file to {0}'.format(out_path))
+
+    def fetch_file(self, in_path, out_path):
+        """Obtain file specified via 'in_path' from the container and place it at 'out_path' """
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self._remote_vmname)
+
+        # We are running in dom0
+        cmd_args_list = ["qvm-run", "--pass-io", self._remote_vmname, "cat {0}".format(in_path)]
+        with open(out_path, "wb") as fobj:
+            p = subprocess.Popen(cmd_args_list, shell=False, stdout=fobj)
+            p.communicate()
+            if p.returncode != 0:
+                raise AnsibleConnectionFailure('Failed to fetch file to {0}'.format(out_path))
+
+    def close(self):
+        """ Closing the connection """
+        super(Connection, self).close()
+        self._connected = False

plugins/connection/saltstack.py

@@ -0,0 +1,105 @@
+# Based on local.py (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
+# Based on chroot.py (c) 2013, Maykel Moya <mmoya@speedyrails.com>
+# Based on func.py
+# (c) 2014, Michael Scherer <misc@zarb.org>
+# (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
+
+DOCUMENTATION = '''
+    author: Michael Scherer (@mscherer) <misc@zarb.org>
+    connection: saltstack
+    short_description: Allow ansible to piggyback on salt minions
+    description:
+        - This allows you to use existing Saltstack infrastructure to connect to targets.
+'''
+
+import re
+import os
+import pty
+import subprocess
+
+from ansible.module_utils._text import to_bytes, to_text
+from ansible.module_utils.six.moves import cPickle
+
+HAVE_SALTSTACK = False
+try:
+    import salt.client as sc
+    HAVE_SALTSTACK = True
+except ImportError:
+    pass
+
+import os
+from ansible import errors
+from ansible.plugins.connection import ConnectionBase
+
+
+class Connection(ConnectionBase):
+    ''' Salt-based connections '''
+
+    has_pipelining = False
+    # while the name of the product is salt, naming that module salt cause
+    # trouble with module import
+    transport = 'community.general.saltstack'
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+        self.host = self._play_context.remote_addr
+
+    def _connect(self):
+        if not HAVE_SALTSTACK:
+            raise errors.AnsibleError("saltstack is not installed")
+
+        self.client = sc.LocalClient()
+        self._connected = True
+        return self
+
+    def exec_command(self, cmd, sudoable=False, in_data=None):
+        ''' run a command on the remote minion '''
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        if in_data:
+            raise errors.AnsibleError("Internal Error: this module does not support optimized module pipelining")
+
+        self._display.vvv("EXEC %s" % (cmd), host=self.host)
+        # need to add 'true;' to work around https://github.com/saltstack/salt/issues/28077
+        res = self.client.cmd(self.host, 'cmd.exec_code_all', ['bash', 'true;' + cmd])
+        if self.host not in res:
+            raise errors.AnsibleError("Minion %s didn't answer, check if salt-minion is running and the name is correct" % self.host)
+
+        p = res[self.host]
+        return (p['retcode'], p['stdout'], p['stderr'])
+
+    def _normalize_path(self, path, prefix):
+        if not path.startswith(os.path.sep):
+            path = os.path.join(os.path.sep, path)
+        normpath = os.path.normpath(path)
+        return os.path.join(prefix, normpath[1:])
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to remote '''
+
+        super(Connection, self).put_file(in_path, out_path)
+
+        out_path = self._normalize_path(out_path, '/')
+        self._display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.host)
+        with open(in_path) as in_fh:
+            content = in_fh.read()
+        self.client.cmd(self.host, 'file.write', [out_path, content])
+
+    # TODO test it
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from remote to local '''
+
+        super(Connection, self).fetch_file(in_path, out_path)
+
+        in_path = self._normalize_path(in_path, '/')
+        self._display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.host)
+        content = self.client.cmd(self.host, 'cp.get_file_str', [in_path])[self.host]
+        open(out_path, 'wb').write(content)
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        pass

plugins/connection/zone.py

@@ -0,0 +1,200 @@
+# Based on local.py (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
+# and chroot.py     (c) 2013, Maykel Moya <mmoya@speedyrails.com>
+# and jail.py       (c) 2013, Michael Scherer <misc@zarb.org>
+# (c) 2015, Dagobert Michelsen <dam@baltic-online.de>
+# (c) 2015, Toshio Kuratomi <tkuratomi@ansible.com>
+# 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
+
+DOCUMENTATION = '''
+    author: Ansible Core Team
+    connection: zone
+    short_description: Run tasks in a zone instance
+    description:
+        - Run commands or put/fetch files to an existing zone
+    options:
+      remote_addr:
+        description:
+            - Zone identifier
+        default: inventory_hostname
+        vars:
+            - name: ansible_host
+            - name: ansible_zone_host
+'''
+
+import distutils.spawn
+import os
+import os.path
+import subprocess
+import traceback
+
+from ansible import constants as C
+from ansible.errors import AnsibleError
+from ansible.module_utils.six.moves import shlex_quote
+from ansible.module_utils._text import to_bytes
+from ansible.plugins.connection import ConnectionBase, BUFSIZE
+from ansible.utils.display import Display
+
+display = Display()
+
+
+class Connection(ConnectionBase):
+    ''' Local zone based connections '''
+
+    transport = 'community.general.zone'
+    has_pipelining = True
+    has_tty = False
+
+    def __init__(self, play_context, new_stdin, *args, **kwargs):
+        super(Connection, self).__init__(play_context, new_stdin, *args, **kwargs)
+
+        self.zone = self._play_context.remote_addr
+
+        if os.geteuid() != 0:
+            raise AnsibleError("zone connection requires running as root")
+
+        self.zoneadm_cmd = to_bytes(self._search_executable('zoneadm'))
+        self.zlogin_cmd = to_bytes(self._search_executable('zlogin'))
+
+        if self.zone not in self.list_zones():
+            raise AnsibleError("incorrect zone name %s" % self.zone)
+
+    @staticmethod
+    def _search_executable(executable):
+        cmd = distutils.spawn.find_executable(executable)
+        if not cmd:
+            raise AnsibleError("%s command not found in PATH" % executable)
+        return cmd
+
+    def list_zones(self):
+        process = subprocess.Popen([self.zoneadm_cmd, 'list', '-ip'],
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        zones = []
+        for l in process.stdout.readlines():
+            # 1:work:running:/zones/work:3126dc59-9a07-4829-cde9-a816e4c5040e:native:shared
+            s = l.split(':')
+            if s[1] != 'global':
+                zones.append(s[1])
+
+        return zones
+
+    def get_zone_path(self):
+        # solaris10vm# zoneadm -z cswbuild list -p
+        # -:cswbuild:installed:/zones/cswbuild:479f3c4b-d0c6-e97b-cd04-fd58f2c0238e:native:shared
+        process = subprocess.Popen([self.zoneadm_cmd, '-z', to_bytes(self.zone), 'list', '-p'],
+                                   stdin=subprocess.PIPE,
+                                   stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        # stdout, stderr = p.communicate()
+        path = process.stdout.readlines()[0].split(':')[3]
+        return path + '/root'
+
+    def _connect(self):
+        ''' connect to the zone; nothing to do here '''
+        super(Connection, self)._connect()
+        if not self._connected:
+            display.vvv("THIS IS A LOCAL ZONE DIR", host=self.zone)
+            self._connected = True
+
+    def _buffered_exec_command(self, cmd, stdin=subprocess.PIPE):
+        ''' run a command on the zone.  This is only needed for implementing
+        put_file() get_file() so that we don't have to read the whole file
+        into memory.
+
+        compared to exec_command() it looses some niceties like being able to
+        return the process's exit code immediately.
+        '''
+        # NOTE: zlogin invokes a shell (just like ssh does) so we do not pass
+        # this through /bin/sh -c here.  Instead it goes through the shell
+        # that zlogin selects.
+        local_cmd = [self.zlogin_cmd, self.zone, cmd]
+        local_cmd = map(to_bytes, local_cmd)
+
+        display.vvv("EXEC %s" % (local_cmd), host=self.zone)
+        p = subprocess.Popen(local_cmd, shell=False, stdin=stdin,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        return p
+
+    def exec_command(self, cmd, in_data=None, sudoable=False):
+        ''' run a command on the zone '''
+        super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable)
+
+        p = self._buffered_exec_command(cmd)
+
+        stdout, stderr = p.communicate(in_data)
+        return (p.returncode, stdout, stderr)
+
+    def _prefix_login_path(self, remote_path):
+        ''' Make sure that we put files into a standard path
+
+            If a path is relative, then we need to choose where to put it.
+            ssh chooses $HOME but we aren't guaranteed that a home dir will
+            exist in any given chroot.  So for now we're choosing "/" instead.
+            This also happens to be the former default.
+
+            Can revisit using $HOME instead if it's a problem
+        '''
+        if not remote_path.startswith(os.path.sep):
+            remote_path = os.path.join(os.path.sep, remote_path)
+        return os.path.normpath(remote_path)
+
+    def put_file(self, in_path, out_path):
+        ''' transfer a file from local to zone '''
+        super(Connection, self).put_file(in_path, out_path)
+        display.vvv("PUT %s TO %s" % (in_path, out_path), host=self.zone)
+
+        out_path = shlex_quote(self._prefix_login_path(out_path))
+        try:
+            with open(in_path, 'rb') as in_file:
+                if not os.fstat(in_file.fileno()).st_size:
+                    count = ' count=0'
+                else:
+                    count = ''
+                try:
+                    p = self._buffered_exec_command('dd of=%s bs=%s%s' % (out_path, BUFSIZE, count), stdin=in_file)
+                except OSError:
+                    raise AnsibleError("jail connection requires dd command in the jail")
+                try:
+                    stdout, stderr = p.communicate()
+                except Exception:
+                    traceback.print_exc()
+                    raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+                if p.returncode != 0:
+                    raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+        except IOError:
+            raise AnsibleError("file or module does not exist at: %s" % in_path)
+
+    def fetch_file(self, in_path, out_path):
+        ''' fetch a file from zone to local '''
+        super(Connection, self).fetch_file(in_path, out_path)
+        display.vvv("FETCH %s TO %s" % (in_path, out_path), host=self.zone)
+
+        in_path = shlex_quote(self._prefix_login_path(in_path))
+        try:
+            p = self._buffered_exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE))
+        except OSError:
+            raise AnsibleError("zone connection requires dd command in the zone")
+
+        with open(out_path, 'wb+') as out_file:
+            try:
+                chunk = p.stdout.read(BUFSIZE)
+                while chunk:
+                    out_file.write(chunk)
+                    chunk = p.stdout.read(BUFSIZE)
+            except Exception:
+                traceback.print_exc()
+                raise AnsibleError("failed to transfer file %s to %s" % (in_path, out_path))
+            stdout, stderr = p.communicate()
+            if p.returncode != 0:
+                raise AnsibleError("failed to transfer file %s to %s:\n%s\n%s" % (in_path, out_path, stdout, stderr))
+
+    def close(self):
+        ''' terminate the connection; nothing to do here '''
+        super(Connection, self).close()
+        self._connected = False

plugins/doc_fragments/a10.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+# Copyright: (c) 2016, John Barker <jobarker@redhat.com>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+
+class ModuleDocFragment(object):
+
+    # Standard files documentation fragment
+    DOCUMENTATION = r'''
+options:
+  host:
+    description:
+      - Hostname or IP of the A10 Networks device.
+    type: str
+    required: true
+  username:
+    description:
+      - An account with administrator privileges.
+    type: str
+    required: true
+    aliases: [ admin, user ]
+  password:
+    description:
+      - Password for the C(username) account.
+    type: str
+    required: true
+    aliases: [ pass, pwd ]
+  write_config:
+    description:
+      - If C(yes), any changes will cause a write of the running configuration
+        to non-volatile memory. This will save I(all) configuration changes,
+        including those that may have been made manually or through other modules,
+        so care should be taken when specifying C(yes).
+    type: bool
+    default: no
+  validate_certs:
+    description:
+      - If C(no), SSL certificates will not be validated.
+      - This should only be used on personally controlled devices using self-signed certificates.
+    type: bool
+    default: yes
+notes:
+    - Requires A10 Networks aXAPI 2.1.
+'''

plugins/doc_fragments/aireos.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+# Copyright: (c) 2017, James Mighion <@jmighion>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+
+class ModuleDocFragment(object):
+
+    # Standard files documentation fragment
+    DOCUMENTATION = r'''
+options:
+  provider:
+    description:
+      - A dict object containing connection details.
+    suboptions:
+      host:
+        description:
+          - Specifies the DNS host name or address for connecting to the remote device over the specified transport.
+          - The value of host is used as the destination address for the transport.
+        type: str
+        required: true
+      port:
+        description:
+          - Specifies the port to use when building the connection to the remote device.
+        type: int
+        default: 22
+      username:
+        description:
+          - Configures the username to use to authenticate the connection to the remote device.
+          - This value is used to authenticate the SSH session.
+          - If the value is not specified in the task, the value of environment variable
+            C(ANSIBLE_NET_USERNAME) will be used instead.
+        type: str
+      password:
+        description:
+          - Specifies the password to use to authenticate the connection to the remote device.
+          - This value is used to authenticate the SSH session.
+          - If the value is not specified in the task, the value of environment variable
+            C(ANSIBLE_NET_PASSWORD) will be used instead.
+        type: str
+      timeout:
+        description:
+          - Specifies the timeout in seconds for communicating with the network device
+            for either connecting or sending commands.
+          - If the timeout is exceeded before the operation is completed, the module will error.
+        type: int
+        default: 10
+      ssh_keyfile:
+        description:
+          - Specifies the SSH key to use to authenticate the connection to the remote device.
+          - This value is the path to the key used to authenticate the SSH session.
+          - If the value is not specified in the task, the value of environment variable
+            C(ANSIBLE_NET_SSH_KEYFILE) will be used instead.
+        type: path
+'''

plugins/doc_fragments/alicloud.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+# Copyright: (c) 2017 Alibaba Group Holding Limited. He Guimin <heguimin36@163.com>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+
+class ModuleDocFragment(object):
+
+    # Alicloud only documentation fragment
+    DOCUMENTATION = r'''
+options:
+  alicloud_access_key:
+    description:
+    - Aliyun Cloud access key.
+    - If not set then the value of environment variable C(ALICLOUD_ACCESS_KEY),
+      C(ALICLOUD_ACCESS_KEY_ID) will be used instead.
+    type: str
+    aliases: [ access_key_id, access_key ]
+  alicloud_secret_key:
+    description:
+    - Aliyun Cloud secret key.
+    - If not set then the value of environment variable C(ALICLOUD_SECRET_KEY),
+      C(ALICLOUD_SECRET_ACCESS_KEY) will be used instead.
+    type: str
+    aliases: [ secret_access_key, secret_key ]
+  alicloud_region:
+    description:
+    - The Aliyun Cloud region to use.
+    - If not specified then the value of environment variable
+      C(ALICLOUD_REGION), C(ALICLOUD_REGION_ID) will be used instead.
+    type: str
+    aliases: [ region, region_id ]
+  alicloud_security_token:
+    description:
+    - The Aliyun Cloud security token.
+    - If not specified then the value of environment variable
+      C(ALICLOUD_SECURITY_TOKEN) will be used instead.
+    type: str
+    aliases: [ security_token ]
+author:
+- He Guimin (@xiaozhu36)
+requirements:
+- python >= 2.6
+extends_documentation_fragment:
+- community.general.alicloud
+
+notes:
+  - If parameters are not set within the module, the following
+    environment variables can be used in decreasing order of precedence
+    C(ALICLOUD_ACCESS_KEY) or C(ALICLOUD_ACCESS_KEY_ID),
+    C(ALICLOUD_SECRET_KEY) or C(ALICLOUD_SECRET_ACCESS_KEY),
+    C(ALICLOUD_REGION) or C(ALICLOUD_REGION_ID),
+    C(ALICLOUD_SECURITY_TOKEN)
+  - C(ALICLOUD_REGION) or C(ALICLOUD_REGION_ID) can be typically be used to specify the
+    ALICLOUD region, when required, but this can also be configured in the footmark config file
+'''