# https://learn.microsoft.com/en-us/azure/devops/pipelines/tasks/reference/?view=azure-pipelines&viewFallbackFrom=azure-devops#tool

# `{script: ...}` is shorthand for `{task: CmdLine@<mumble>, inputs: {script: ...}}`.

# https://learn.microsoft.com/en-us/azure/devops/pipelines/yaml-schema/steps-script?view=azure-pipelines

# https://learn.microsoft.com/en-us/azure/devops/pipelines/tasks/reference/cmd-line-v2?view=azure-pipelines

- task: UsePythonVersion@0

displayName: Install python

inputs:

versionSpec: '$(python.version)'

condition: ne(variables['python.version'], '')

- script: |

sudo apt-get update

sudo apt-get install -y python2-dev python3-pip virtualenv

displayName: Install build deps

condition: and(eq(variables['python.version'], ''), eq(variables['Agent.OS'], 'Linux'))

displayName: Install tooling

displayName: "Run tests"

env:

AWS_ACCESS_KEY_ID: $(AWS_ACCESS_KEY_ID)

matrix:

Mito_27:

tox.env: py27-mode_mitogen

Loc_27_210:

tox.env: py27-mode_localhost-ansible2.10

Van_27_210:

- job: Linux

pool:

python.version: '3.6'

tox.env: py36-mode_mitogen-distro_ubuntu2004

Ans_27_210:

tox.env: py27-mode_ansible-ansible2.10

python.version: '3.6'

tox.env: py36-mode_ansible-ansible4

import sys

import tempfile

try:

import urlparse

#!/usr/bin/env python

# Run tests/ansible/all.yml under Ansible and Ansible-Mitogen

import os

import subprocess

import sys

os.chdir(IMAGE_PREP_DIR)

ci_lib.run("ansible-playbook -c local -i localhost, _user_accounts.yml")

with ci_lib.Fold('ansible'):

os.chdir(TESTS_DIR)

*.pyc

*.pyd

*.pyo

MANIFEST

build/

dist/

__metaclass__ = type

import collections

import os

import mitogen.master

PREFIX = 'ansible.module_utils.'

Module = collections.namedtuple('Module', 'name path kind parent')

def scan_fromlist(code):

for level, modname_s, fromlist in mitogen.master.scan_code_imports(code):

for name in fromlist:

if not fromlist:

yield level, modname_s

def scan(module_name, module_path, search_path):

module = Module(module_name, module_path, imp.PY_SOURCE, None)

stack = [module]

seen = set()

__metaclass__ = type

import atexit

import json

import os

import re

ctypes = None

try:

# Cannot use cStringIO as it does not support Unicode.

from StringIO import StringIO

except ImportError:

sys.modules.pop(fullname, None)

def find_module(self, fullname, path=None):

if fullname in self._by_fullname:

return self

def load_module(self, fullname):

path, is_pkg = self._by_fullname[fullname]

source = ansible_mitogen.target.get_small_file(self._context, path)

code = compile(source, path, 'exec', 0, 1)

synchronization mechanism by importing everything the module will need

prior to detaching.

"""

for fullname, _, _ in self.module_map['custom']:

mitogen.core.import_module(fullname)

for fullname in self.module_map['builtin']:

try:

mitogen.core.import_module(fullname)

# #590: Ansible 2.8 module_utils.distro is a package that

# replaces itself in sys.modules with a non-package during

# import. Prior to replacement, it is a real package containing

# loop progresses to the next entry and attempts to preload

# 'distro._distro', the import mechanism will fail. So here we

# silently ignore any failure for it.

def _setup_excepthook(self):

"""

from __future__ import absolute_import, division, print_function

__metaclass__ = type

import ansible

'ansible_version',

]

del ansible

python-mitogen (0.3.4-3) unstable; urgency=medium

* Patch: Support setting interpreter_python in config, again.

NEW_VERSION_MSG = (

"Your Ansible version (%s) is too recent. The most recent version\n"

diff --git a/mitogen/core.py b/mitogen/core.py

--- a/mitogen/core.py

+++ b/mitogen/core.py

s, n = LATIN1_CODEC.encode(s)

return s

def _find_global(self, module, func):

"""

Return the class implementing `module_name.class_name` or raise

return Secret

elif func == 'Kwargs':

return Kwargs

.ci/ansible_tests.py | 11 ++++++++++-

ansible_mitogen/transport_config.py | 16 ++++++++++++----

tests/ansible/hosts/default.hosts | 2 ++

.../integration/transport_config/become_pass.yml | 5 +++--

tests/ansible/regression/all.yml | 1 +

tests/ansible/regression/become_test.yml | 9 +++++++++

.../regression/issue_952__ask_become_pass.yml | 21 +++++++++++++++++++++

tests/requirements.txt | 1 +

create mode 100644 tests/ansible/regression/become_test.yml

create mode 100644 tests/ansible/regression/issue_952__ask_become_pass.yml

def password(self):

diff --git a/tests/ansible/hosts/default.hosts b/tests/ansible/hosts/default.hosts

--- a/tests/ansible/hosts/default.hosts

+++ b/tests/ansible/hosts/default.hosts

[test-targets]

target

+

+[linux_containers]

diff --git a/tests/ansible/integration/transport_config/become_pass.yml b/tests/ansible/integration/transport_config/become_pass.yml

index 317e052..670faf5 100644

--- a/tests/ansible/integration/transport_config/become_pass.yml

+ changed_when: false

+ check_mode: false

diff --git a/tests/requirements.txt b/tests/requirements.txt

--- a/tests/requirements.txt

+++ b/tests/requirements.txt

+pexpect==4.8

argv = eval(context.call(os.getenv, 'ORIGINAL_ARGV'))

diff --git a/tests/ssh_test.py b/tests/ssh_test.py

--- a/tests/ssh_test.py

+++ b/tests/ssh_test.py

@@ -18,6 +18,7 @@ class StubSshMixin(testlib.RouterMixin):

skip-django-tests

skip-python2.7-test

poll-poller

ansible-2.14

ask-become-pass

interpreter_python

ansible-2.16

They require Django, and tend to fail for us.

---

diff --git a/tests/module_finder_test.py b/tests/module_finder_test.py

--- a/tests/module_finder_test.py

+++ b/tests/module_finder_test.py

self.assertEqual(set(related), self.SIMPLE_EXPECT)

+if False: # sys.version_info > (2, 6):

<p>

<br>

</p>

.. _Ansible: https://www.ansible.com/

Overview

* Mitogen 0.2.x supports Ansible 2.3-2.9; with Python 2.6, 2.7, or 3.6.

Mitogen 0.3.1+ supports

Verify your installation is running one of these versions by checking

``ansible --version`` output.

---------------

The summaries below may be reproduced using data and scripts maintained in the

recorded using Ansible 2.5.14.

This demonstrates Mitogen vs. SSH pipelining to the local machine running

`bench/loop-100-items.yml

executing a simple command 100 times. Most Ansible controller overhead is

isolated, characterizing just module executor and connection layer performance.

Mitogen requires **63x less bandwidth and 5.9x less time**.

~~~~~~~~~~~~~~~~~~~~~~~~~~~

`This playbook

was used to compare file transfer performance over a ~26 ms link. It uses the

``with_filetree`` loop syntax to copy a directory of 1,000 0-byte files to the

target.

</style>

To avail of fixes in an unreleased version, please download a ZIP file

v0.3.4 (2023-07-02)

-------------------

-------------------

This release separates itself from the v0.2.X releases. Ansible's API changed too much to support backwards compatibility so from now on, v0.2.X releases will be for Ansible < 2.10 and v0.3.X will be for Ansible 2.10+.

* :gh:issue:`827` NewStylePlanner: detect `ansible_collections` imports

* :gh:issue:`770` better check for supported Ansible version

* :gh:issue:`756` ssh connections with `check_host_keys='accept'` would

timeout, when using recent OpenSSH client versions.

* :gh:issue:`758` fix initilialisation of callback plugins in test suite, to address a `KeyError` in

* :gh:issue:`775` Test with Python 3.9

* :gh:issue:`775` Add msvcrt to the default module deny list

* :gh:issue:`847` Removed historic Continuous Integration reverse shell

:linux:man7:`unix` sockets across privilege domains.

* :gh:issue:`467`: an incompatibility running Mitogen under `Molecule

* :gh:issue:`547`, :gh:issue:`598`: fix a deadlock during initialization of

connections, ``async`` tasks, tasks using custom :mod:`module_utils`,

parameter may specify an argument vector prefix rather than a string program

path.

descriptors that were closed before the IO loop resumes. As a temporary

workaround, kqueue's bulk change feature is not used.

import sys

sys.path.append('.')

author = u'Network Genomics'

copyright = u'2021, the Mitogen authors'

domainrefs = {

'gh:commit': {

'text': '%s',

},

'gh:issue': {

'text': '#%s',

},

'gh:pull': {

'text': '#%s',

},

'ans:mod': {

'text': '%s module',

},

'freebsd:man2': {

'text': '%s(2)',

},

'linux:man1': {

'text': '%s(1)',

},

'linux:man2': {

'text': '%s(2)',

},

'linux:man3': {

'text': '%s(3)',

},

'linux:man7': {

'text': '%s(7)',

},

}

rst_epilog = """

.. |mitogen_version| replace:: %(VERSION)s

""" % locals()

<li>randy &mdash; <em>desperate for automation</em></li>

<li>Michael & Vicky Twomey-Lee</li>

<li><a href="http://www.wezm.net/">Wesley Moore</a></li>

</ul>

`Fabric`_ can be built, and while the API is quite friendly and comparable to

`Fabric`_, ultimately it is not intended for direct use by consumer software.

.. _Ansible: https://docs.ansible.com/

.. _Fabric: https://www.fabfile.org/

Sphinx==2.1.2; python_version > '3.0'

sphinxcontrib-programoutput==0.14; python_version > '3.0'

alabaster==0.7.10; python_version > '3.0'

#: Library version as a tuple.

#: This is :data:`False` in slave contexts. Previously it was used to prevent

bootstrap implementation sent to every new slave context.

"""

import binascii

import collections

import encodings.latin_1

import signal

import socket

import struct

import syslog

import threading

import time

import traceback

import warnings

import weakref

import zlib

# Absolute imports for <2.5.

select = __import__('select')

def __repr__(self):

return 'Importer'

def builtin_find_module(self, fullname):

# imp.find_module() will always succeed for __main__, because it is a

# built-in module. That means it exists on a special linked list deep

if fullname == '__main__':

raise ModuleNotFoundError()

parent, _, modname = str_rpartition(fullname, '.')

if parent:

path = sys.modules[parent].__path__

else:

path = None

fp, pathname, description = imp.find_module(modname, path)

if fp:

fp.close()

Implements importlib.abc.MetaPathFinder.find_module().

Deprecrated in Python 3.4+, replaced by find_spec().

Raises ImportWarning in Python 3.10+.

path __path__ of parent packge. None for a top level module.

"""

if hasattr(_tls, 'running'):

try:

#_v and self._log.debug('Python requested %r', fullname)

fullname = to_text(fullname)

pkg = sys.modules.get(pkgname)

if pkgname and getattr(pkg, '__loader__', None) is not self:

self._log.debug('%s is submodule of a locally loaded package',

fullname)

return None

if pkgname and suffix not in self._present.get(pkgname, ()):

self._log.debug('%s has no submodule %s', pkgname, suffix)

return None

finally:

del _tls.running

blacklisted_msg = (

'%r is present in the Mitogen importer blacklist, therefore this '

'context will not attempt to request it from the master, as the '

if present:

callback()

def load_module(self, fullname):

"""

Return the loaded module specified by fullname.

self._request_module(fullname, event.set)

event.wait()

raise ModuleNotFoundError(self.absent_msg % (fullname,))

mod = sys.modules.setdefault(fullname, imp.new_module(fullname))

mod.__file__ = self.get_filename(fullname)

mod.__loader__ = self

def _setup_package(self):

global mitogen

mitogen.__package__ = 'mitogen'

mitogen.__path__ = []

mitogen.__loader__ = self.importer

import dis

import errno

import inspect

import itertools

import logging

import zlib

try:

import sysconfig

except ImportError:

sysconfig = None

"""

Return :data:`True` if `modname` appears to come from the standard library.

"""

#

# """

# Main is a little special - imp.is_builtin("__main__") will return False,

# but BuiltinImporter is still the most appropriate initial setting for

# its __loader__ attribute.

# """ -- comment in CPython pylifecycle.c:add_main_module()

return True

module = sys.modules.get(modname)

name according to the running Python interpreter. You'd think this was a

simple task, right? Naive young fellow, welcome to the real world.

"""

def __repr__(self):

return '%s()' % (type(self).__name__,)

return path, source, is_pkg

"""

Attempt to fetch source code by examining the module's (hopefully less

insane) parent package, and if no insane parents exist, simply use

def _find_one_component(self, modname, search_path):

try:

#fp, path, (suffix, _, kind) = imp.find_module(modname, search_path)

return imp.find_module(modname, search_path)

except ImportError:

e = sys.exc_info()[1]

"""

See implementation for a description of how this works.

"""

#if fullname not in sys.modules:

# Don't attempt this unless a module really exists in sys.modules,

# else we could return junk.

return self._found_module(fullname, path, fp)

class ModuleFinder(object):

"""

Given the name of a loaded module, make a best-effort attempt at finding

DefectivePython3xMainMethod(),

PkgutilMethod(),

SysModulesMethod(),

]

def get_module_source(self, fullname):

connection.

"""

import errno

import fcntl

import getpass

class EpollPoller(mitogen.core.Poller):

"""

"""

SUPPORTED = hasattr(select, 'epoll')

_repr = 'EpollPoller()'

# file descriptor 0 as 100, creates a pipe, then execs a new interpreter

# with a custom argv.

# * Optimized for minimum byte count after minification & compression.

# * 'CONTEXT_NAME' and 'PREAMBLE_COMPRESSED_LEN' are substituted with

# their respective values.

# * CONTEXT_NAME must be prefixed with the name of the Python binary in

# order to allow virtualenvs to detect their install prefix.

# * macOS <= 10.14 (Darwin <= 18) install an unreliable Python version

# switcher as /usr/bin/python, which introspects argv0. To workaround

# it we redirect attempts to call /usr/bin/python with an explicit

# do something slightly different. The Python executable is patched to

# perform an extra execvp(). I don't fully understand the details, but

# setting PYTHON_LAUNCHED_FROM_WRAPPER=1 avoids it.

#

# Locals:

# R: read side of interpreter stdin.

os.environ['ARGV0']=sys.executable

os.execl(sys.executable,sys.executable+'(mitogen:CONTEXT_NAME)')

os.write(1,'MITO000\n'.encode())

fp=os.fdopen(W,'wb',0)

fp.write(C)

fp.close()

source = source.replace('PREAMBLE_COMPRESSED_LEN',

str(len(preamble_compressed)))

compressed = zlib.compress(source.encode(), 9)

return self.get_python_argv() + [

'-c',

]

def get_econtext_config(self):

One size fits all method to ensure a target context has been preloaded

with a set of small files and Python modules.

"""

for path in paths:

overridden_source = None

'Programming Language :: Python :: 3.8',

'Programming Language :: Python :: 3.9',

'Programming Language :: Python :: 3.10',

'Programming Language :: Python :: Implementation :: CPython',

'Topic :: System :: Distributed Computing',

'Topic :: System :: Systems Administration',

task_output_limit = 10

[ssh_connection]

pipelining = True

# become_same_user.yml

bsu-joe ansible_user=joe

# vim: syntax=dosini

# Connection delegation scenarios. It's impossible to connect to them, but their would-be

# vim: syntax=dosini

# When running the tests outside CI, make a single 'target' host which is the

# local machine. The ansible_user override is necessary since some tests want a

# fixed ansible.cfg remote_user setting to test against.

[test-targets]

target

# vim: syntax=dosini

# Used for manual testing.

# vim: syntax=dosini

# issue #511, #536: we must not define an explicit localhost, as some

# integration/transport_config

# Hosts with twiddled configs that need to be checked somehow.

tc_transport

[transport_config_undiscover:vars]

# This optimisation should not be relied in any test.

# Note: tc-python-path-* are intentionally not included.

[tc_transport]

tc-transport-unset

# Verify passwordful su behaviour

- name: integration/become/su_password.yml

hosts: test-targets

fail_msg: out={{out}}

when: is_mitogen

shell: whoami

become: true

become_user: mitogen__user1

register: out

vars:

ansible_become_pass: user1_password

- assert:

that:

- out.stdout == 'mitogen__user1'

fail_msg: out={{out}}

tags:

- su

- su_password

'keepalive_count': 10,

'password': null,

'port': null,

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

'keepalive_count': 10,

'password': null,

'port': null,

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

"python_path": ["/usr/bin/python"],

'remote_name': null,

'ssh_args': [

],

'ssh_debug_level': null,

'ssh_path': 'ssh',

vars:

ansible_python_interpreter: auto

test_echo_module:

register: echoout

# can't test this assertion:

# because Mitogen's ansible_python_interpreter is a connection-layer configurable that

# "must be extracted during each task execution to form the complete connection-layer configuration".

# Discovery won't be reran though; the ansible_python_interpreter is read from the cache if already discovered

that:

- auto_out.ansible_facts.discovered_interpreter_python is defined

- name: test that auto_legacy gives a dep warning when /usr/bin/python present but != auto result

- name: ensure modules can't set discovered_interpreter_X or ansible_X_interpreter

block:

- test_echo_module:

ansible_discovered_interpreter_bogus: from module

discovered_interpreter_bogus: from_module

ansible_bogus_interpreter: from_module

- distro == 'ubuntu'

- distro_version is version('16.04', '>=', strict=True)

always:

- meta: clear_facts

when:

- name: integration/interpreter_discovery/complex_args.yml

hosts: test-targets

gather_facts: true

tasks:

- name: create temp file to source

file:

# special_python: source /tmp/fake && python

- name: set python using sourced file

set_fact:

- name: run get_url with specially-sourced python

get_url:

dest: "/tmp/"

mode: 0644

vars:

ansible_python_interpreter: "{{ special_python }}"

- name: run get_url with specially-sourced python including jinja

get_url:

dest: "/tmp/"

mode: 0644

vars:

ansible_python_interpreter: >

{% if "1" == "1" %}

{% else %}

python

{% endif %}

tags:

- complex_args

- shell: >

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -c local -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

- name: integration/runner/custom_python_new_style_module.yml

hosts: test-targets

tasks:

- custom_python_new_style_missing_interpreter:

foo: true

with_sequence: start=0 end={{end|default(1)}}

- name: integration/runner/custom_python_new_style_module.yml

hosts: test-targets

tasks:

- meta: end_play

when: not is_mitogen

# issue #555

- name: integration/runner/custom_python_prehistoric_module.yml

tasks:

- custom_python_prehistoric_module:

register: out

- assert:

that: out.ok

fail_msg: out={{out}}

tags:

- custom_python_prehistoric_module

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

shell: >

ANSIBLE_ANY_ERRORS_FATAL=false

ANSIBLE_STRATEGY=mitogen_linear

ansible -m shell -a whoami

{% for inv in ansible_inventory_sources %}

-i "{{ inv }}"

TEMPLATE_KWARGS = {}

if 'bare_deprecated' in _argspec.args:

TEMPLATE_KWARGS['bare_deprecated'] = False

# I am an Ansible new-style Python module. I return details about the Python

# interpreter I run within.

def main():

module = AnsibleModule(argument_spec={})

module.exit_json(

python={

'version': {

'full': '%i.%i.%i' % sys.version_info[:3],

# I expect the quote from modules2/module_utils/joker.py.

from ansible.module_utils.basic import AnsibleModule

from ansible.module_utils.basic import AnsibleModule

from ansible.module_utils.externalpkg import extmod

# I am an Ansible Python JSONARGS module. I should receive an encoding string.

json_arguments = """<<INCLUDE_ANSIBLE_MODULE_JSON_ARGS>>"""

# I am an Ansible new-style Python module. I leak state from each invocation

# into a class variable and a global variable.

# I am an Ansible new-style Python module. I modify the process environment and

# don't clean up after myself.

# I am an Ansible new-style Python module, but I lack an interpreter.

import sys

# As of Ansible 2.10, Ansible changed new-style detection: # https://github.com/ansible/ansible/pull/61196/files#diff-5675e463b6ce1fbe274e5e7453f83cd71e61091ea211513c93e7c0b4d527d637L828-R980

# NOTE: this import works for Mitogen, and the import below matches new-style Ansible 2.10

# from ansible.module_utils.

# import ansible.module_utils.

def usage():

sys.stderr.write('Usage: %s <input.json>\n' % (sys.argv[0],))

sys.exit(1)

input_json = sys.stdin.read()

print("{")

# I am an Ansible new-style Python module. I should receive an encoding string.

import sys

# This is the magic marker Ansible looks for:

# from ansible.module_utils.

def usage():

sys.stderr.write('Usage: %s <input.json>\n' % (sys.argv[0],))

sys.exit(1)

input_json = sys.stdin.read()

print("{")

# #591: call os.getcwd() before AnsibleModule ever gets a chance to fix up the

# process environment.

# issue #555: I'm a module that cutpastes an old hack.

from ansible.module_utils.basic import AnsibleModule

# I am an Ansible new-style Python module. I run the script provided in the

# parameter.

# issue #590: I am an Ansible new-style Python module that tries to use

# ansible.module_utils.distro.

# I am an Ansible Python WANT_JSON module. I should receive a JSON-encoded file.

import json

# I am a module that indirectly depends on glibc cached /etc/resolv.conf state.

# -*- coding: utf-8 -*-

# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>

from __future__ import absolute_import, division, print_function

__metaclass__ = type

import platform

import sys

from ansible.module_utils.basic import AnsibleModule

def main():

module = AnsibleModule(argument_spec=dict(

))

# revert the Mitogen OSX tweak since discover_interpreter() doesn't return this info

# only for tests to check version of running interpreter -- Mac 10.15+ changed python2

# so it looks like it's /usr/bin/python but actually it's /System/Library/Frameworks/Python.framework/Versions/2.7/Resources/Python.app/Contents/MacOS/Python

sys.executable = "/usr/bin/python"

module.exit_json(**result)

when:

- lout.python.version.full is version('2.7', '>=', strict=True)

that:

fail_msg: out={{out}}

when:

- lout.python.version.full is version('2.7', '>=', strict=True)

hosts: localhost:test-targets

gather_facts: true

tasks:

- debug: {var: ansible_facts.osversion}

- debug: {var: ansible_facts.python}

- debug: {var: ansible_facts.system}

# WARNING: this creates non-privilged accounts with pre-set passwords!

#

- hosts: all

gather_facts: true

strategy: mitogen_free

normal_users: "{{

lookup('sequence', 'start=1 end=5 format=user%d', wantlist=True)

all_users: "{{

special_users +

normal_users

tasks:

- name: Disable non-localhost SSH for Mitogen users

when: false

with_items: "{{all_users}}"

copy:

dest: /var/lib/AccountsService/users/mitogen__{{item}}

content: |

[User]

SystemAccount=true

when: ansible_system == 'Linux' and out.stat.exists

service:

name: accounts-daemon

- name: Readonly homedir for one account

shell: "chown -R root: ~mitogen__readonly_homedir"

copy:

dest: ~mitogen__slow_user/.{{item}}

src: ../data/docker/mitogen__slow_user.profile

with_items:

- bashrc

- profile

copy:

dest: ~mitogen__permdenied/.{{item}}

src: ../data/docker/mitogen__permdenied.profile

with_items:

- bashrc

- profile

state: directory

mode: go=

owner: mitogen__has_sudo_pubkey

- copy:

dest: ~mitogen__has_sudo_pubkey/.ssh/authorized_keys

src: ../data/docker/mitogen__has_sudo_pubkey.key.pub

mode: go=

owner: mitogen__has_sudo_pubkey

- name: Require a TTY for two accounts

lineinfile:

import threading

import types

import zlib

import mock

super(ImporterMixin, self).tearDown()

class LoadModuleTest(ImporterMixin, testlib.TestCase):

data = zlib.compress(b("data = 1\n\n"))

path = 'fake_module.py'

# 0:fullname 1:pkg_present 2:path 3:compressed 4:related

response = (modname, None, path, data, [])

def test_module_added_to_sys_modules(self):

self.set_get_module_response(self.response)

mod = self.importer.load_module(self.modname)

self.assertIsNone(mod.__package__)

class LoadSubmoduleTest(ImporterMixin, testlib.TestCase):

data = zlib.compress(b("data = 1\n\n"))

path = 'fake_module.py'

self.assertEqual(mod.__package__, 'mypkg')

class LoadModulePackageTest(ImporterMixin, testlib.TestCase):

data = zlib.compress(b("func = lambda: 1\n\n"))

path = 'fake_pkg/__init__.py'

self.assertEqual(mod.func.__module__, self.modname)

class EmailParseAddrSysTest(testlib.RouterMixin, testlib.TestCase):

def initdir(self, caplog):

self.caplog = caplog

import inspect

import os

import sys

import unittest

self.assertIsNone(tup)

def call(self, fullname):

return self.klass().find(fullname)

self.assertEqual(is_pkg, False)

class ResolveRelPathTest(testlib.TestCase):

klass = mitogen.master.ModuleFinder

self.assertEqual(set(related), self.SIMPLE_EXPECT)