wip

Trying to get somewhere with traefik module
Magic command line
2020-02-20 13:18:53 +01:00 · 2020-02-17 01:00:59 +01:00 · 2020-02-16 21:34:41 +01:00 · 2020-02-16 20:54:12 +01:00 · 2020-02-16 20:53:49 +01:00 · 2020-02-16 20:14:20 +01:00
43 changed files with 1276 additions and 1206 deletions
@@ -2,22 +2,14 @@ build:
  cache:
    key: cache
    paths: [.cache]
-  image: quay.io/buildah/stable
+  image: yourlabs/shlax
-  script:
+  script: pip install -U --user -e . && CACHE_DIR=$(pwd)/.cache ./shlaxfile.py -d
-  - dnf install -y python3-pip
+    shlax build push
  - pip3 install -U --user -e .[cli]
  - CACHE_DIR=$(pwd)/.cache python3 ./shlaxfile.py build
  stage: build
 test:
  image: yourlabs/python
  stage: build
  script:
  - pip install -U --user -e .[test]
  - py.test -sv tests
 pypi:
  image: yourlabs/python
  only: [tags]
  script: pypi-release
  stage: deploy
 test: {image: yourlabs/python, script: 'pip install -U --user -e .[test] && py.test
    -svv tests', stage: build}
@@ -1,258 +0,0 @@
 # Shlax: Pythonic automation tool
 Shlax is a Python framework for system automation, initially with the purpose
 of replacing docker, docker-compose and ansible with a single tool with the
 purpose of code-reuse made possible by target abstraction.
 The pattern resolves around two moving parts: Actions and Targets.
 ## Action
 An action is a function that takes a target argument, it may execute nested
 actions by passing over the target argument which collects the results.
 Example:
 ```python
 async def hello_world(target):
    """Bunch of silly commands to demonstrate action programming."""
    await target.mkdir('foo')
    python = await target.which('python3', 'python')
    await target.exec(f'{python} --version > foo/test')
    version = target.exec('cat foo/test').output
    print('version')
 ```
 ### Recursion
 An action may call other actions recursively. There are two ways:
 ```python
 async def something(target):
    # just run the other action code
    hello_world(target)
    # or delegate the call to target
    target(hello_world)
 ```
 In the first case, the resulting count of ran actions will remain 1:
 "something" action.
 In the second case, the resulting count of ran actions will be 2: "something"
 and "hello_world".
 ### Callable classes
 Actually in practice, Actions are basic callable Python classes, here's a basic
 example to run a command:
 ```python
 class Run:
    def __init__(self, cmd):
        self.cmd = cmd
    async def __call__(self, target):
        return await target.exec(self.cmd)
 ```
 This allows to create callable objects which may be called just like functions
 and as such be appropriate actions, instead of:
 ```python
 async def one(target):
    target.exec('one')
 async def two(target):
    target.exec('two')
 ```
 You can do:
 ```python
 one = Run('one')
 two = Run('two')
 ```
 ### Parallel execution
 Actions may be executed in parallel with an action named ... Parallel. This
 defines an action that will execute three actions in parallel:
 ```python
 action = Parallel(
    hello_world,
    something,
    Run('echo hi'),
 )
 ```
 In this case, all actions must succeed for the parallel action to be considered
 a success.
 ### Methods
 An action may also be a method, as long as it just takes a target argument, for
 example:
 ```python
 class Thing:
    def start(self, target):
        """Starts thing"""
    def stop(self, target):
        """Stops thing"""
 action = Thing().start
 ```
 ### Cleaning
 If an action defines a `clean` method, it will always be called wether or not
 the action succeeded. Example:
 ```python
 class Thing:
    def __call__(self, target):
        """Do some thing"""
    def clean(self, target):
        """Clean-up target after __call__"""
 ```
 ### Colorful actions
 If an action defines a `colorize` method, it will be called with the colorset
 as argument for every output, this allows to code custom output rendering.
 ## Target
 A Target is mainly an object providing an abstraction layer over the system we
 want to automate with actions. It defines functions to execute a command, mount
 a directory, copy a file, manage environment variables and so on.
 ### Pre-configuration
 A Target can be pre-configured with a list of Actions in which case calling the
 target without argument will execute its Actions until one fails by raising an
 Exception:
 ```python
 say_hello = Localhost(
    hello_world,
    Run('echo hi'),
 )
 await say_hello()
 ```
 ### Results
 Every time a target execute an action, it will set the "status" attribute on it
 to "success" or "failure", and add it to the "results" attribute:
 ```python
 say_hello = Localhost(Run('echo hi'))
 await say_hello()
 say_hello.results  # contains the action with status="success"
 ```
 ## Targets as Actions: the nesting story
 We've seen that any callable taking a target argument is good to be considered
 an action, and that targets are callables.
 To make a Target runnable like any action, all we had to do is add the target
 keyword argument to `Target.__call__`.
 But `target()` fills `self.results`, so nested action results would not
 propagate to the parent target.
 That's why if Target receives a non-None target argument, it will has to set
 `self.parent` with it.
 This allows nested targets to traverse parents and get to the root Target
 with `target.caller`, where it can then attach results to.
 This opens the nice side effect that a target implementation may call the
 parent target if any, you could write a Docker target as such:
 ```python
 class Docker(Target):
    def __init__(self, *actions, name):
        self.name = name
        super().__init__(*actions)
    async def exec(self, *args):
        return await self.parent.exec(*['docker', 'exec', self.name] + args)
 ```
 This also means that you always need a parent with an exec implementation,
 there are two:
 - Localhost, executes on localhost
 - Stub, for testing
 The result of that design is that the following use cases are available:
 ```python
 # This action installs my favorite package on any distro
 action = Packages('python3')
 # Run it right here: apt install python3
 Localhost()(action)
 # Or remotely: ssh yourhost apt install python3
 Ssh(host='yourhost')(action)
 # Let's make a container build receipe with that action
 build = Buildah(package)
 # Run it locally: buildah exec apt install python3
 Localhost()(build)
 # Or on a server: ssh yourhost build exec apt install python3
 Ssh(host='yourhost')(build)
 # Or on a server behingh a bastion:
 # ssh yourbastion ssh yourhost build exec apt install python3
 Localhost()(Ssh(host='bastion')(Ssh(host='yourhost')(build))
 # That's going to do the same
 Localhost(Ssh(
    Ssh(
        build,
        host='yourhost'
    ),
    host='bastion'
 ))()
 ```
 ## CLI
 You can execute Shlax actions directly on the command line with the `shlax` CLI
 command.
 For your own Shlaxfiles, you can build your CLI with your favorite CLI
 framework. If you decide to use `cli2`, then Shlax provides a thin layer on top
 of it: Group and Command objects made for Shlax objects.
 For example:
 ```python
 yourcontainer = Container(
    build=Buildah(
        User('app', '/app', 1000),
        Packages('python', 'unzip', 'findutils'),
        Copy('setup.py', 'yourdir', '/app'),
        base='archlinux',
        commit='yourimage',
    ),
 )
 if __name__ == '__main__':
    print(Group(doc=__doc__).load(yourcontainer).entry_point())
 ```
 The above will execute a cli2 command with each method of yourcontainer as a
 sub-command.
@@ -5,9 +5,10 @@ setup(
    name='shlax',
    versioning='dev',
    setup_requires='setupmeta',
    install_requires=['cli2'],
    extras_require=dict(
-        cli=[
+        full=[
-            'cli2>=2.2.2',
+            'pyyaml',
        ],
        test=[
            'pytest',
@@ -24,7 +25,7 @@ setup(
    python_requires='>=3',
    entry_points={
        'console_scripts': [
-            'shlax = shlax.cli:cli.entry_point',
+            'shlax = shlax.cli:cli',
        ],
    },
 )
@@ -1,2 +1,235 @@
 from copy import deepcopy
 import functools
 import inspect
 import importlib
 import sys
 from ..output import Output
 from ..exceptions import WrongResult
 from ..result import Result
 class class_or_instance_method:
    def __init__(self, f):
        self.f = f
    def __get__(self, instance, owner):
        def newfunc(*args, **kwargs):
            return self.f(
                instance if instance is not None else owner,
                *args,
                **kwargs
            )
        return newfunc
 class Action:
-    pass
+    display_variables = []
    hide_variables = ['output']
    default_steps = ['apply']
    parent = None
    contextualize = []
    regexps = {
        r'([\w]+):': '{cyan}\\1{gray}:{reset}',
        r'(^|\n)( *)\- ': '\\1\\2{red}-{reset} ',
    }
    options = dict(
        debug=dict(
            alias='d',
            default='visit',
            help='''
            Display debug output. Supports values (combinable): cmd,out,visit
            '''.strip(),
            immediate=True,
        ),
    )
    def __init__(self, *args, **kwargs):
        self.args = args
        for key, value in kwargs.items():
            setattr(self, key, value)
            if isinstance(value, Action):
                getattr(self, key).shlaxstep = True
    def actions_filter(self, results, f=None, **filters):
        if f:
            def ff(a):
                try:
                    return f(a)
                except:
                    return False
            results = [*filter(ff, results)]
        for k, v in filters.items():
            if k == 'type':
                results = [*filter(
                    lambda s: type(s).__name__.lower() == str(v).lower(),
                    results
                )]
            else:
                results = [*filter(
                    lambda s: getattr(s, k, None) == v,
                    results
                )]
        return results
    def sibblings(self, f=None, **filters):
        if not self.parent:
            return []
        return self.actions_filter(
            [a for a in self.parent.actions if a is not self],
            f, **filters
        )
    def parents(self, f=None, **filters):
        if self.parent:
            return self.actions_filter(
                [self.parent] + self.parent.parents(),
                f, **filters
            )
        return []
    def children(self, f=None, **filters):
        children = []
        def add(parent):
            if parent != self:
                children.append(parent)
            if 'actions' not in parent.__dict__:
                return
            for action in parent.actions:
                add(action)
        add(self)
        return self.actions_filter(children, f, **filters)
    async def __call__(self, *targets, **options):
        if not targets:
            from ..targets.localhost import Localhost
            targets = [Localhost()]
        output = Output(regexp=self.regexps, debug=True)
        results = []
        for target in targets:
            target.output = output
            if len(targets) > 1:
                output.prefix = target
            from copy import deepcopy
            action = deepcopy(self)
            action.target = target
            result = Result(action, target)
            results.append(result)
            action.result = result
            action.output = output
            for step in options.get('steps', None) or self.default_steps:
                if step not in action.steps():
                    print(f'Failed to find {type(action).__name__}.{step}')
                    continue
                action.step = step
                output.start(action)
                try:
                    await getattr(action, step)()
                except Exception as e:
                    output.fail(action, e)
                    action.result.status = 'fail'
                    proc = getattr(e, 'proc', None)
                    if proc:
                        result = proc.rc
                    else:
                        raise
                else:
                    output.success(action)
                    result.status = 'success'
                finally:
                    clean = getattr(action, 'clean', None)
                    if clean:
                        output.clean(action)
                        await clean(target)
        return results
    def __repr__(self):
        return ' '.join([type(self).__name__] + [
            f'{k}={v}'
            for k, v in self.__dict__.items()
            if (k in self.display_variables or not self.display_variables)
            and (k not in self.hide_variables)
        ])
    def colorized(self, colors):
        return ' '.join([
            colors['pink1']
            + type(self).__name__
            + '.'
            + self.step
            + colors['yellow']
        ] + [
            f'{colors["blue"]}{k}{colors["gray"]}={colors["green2"]}{v}'
            for k, v in self.__dict__.items()
            if (k in self.display_variables or not self.display_variables)
            and (k not in self.hide_variables)
        ] + [colors['reset']])
    def callable(self):
        from ..targets import Localhost
        async def cb(*a, **k):
            from shlax.cli import cli
            script = Localhost(self, quiet=True)
            result = await script(*a, **k)
            success = functools.reduce(
                lambda a, b: a + b,
                [1 for c in script.children() if c.status == 'success'] or [0])
            if success:
                script.output.success(f'{success} PASS')
            failures = functools.reduce(
                lambda a, b: a + b,
                [1 for c in script.children() if c.status == 'fail'] or [0])
            if failures:
                script.output.fail(f'{failures} FAIL')
            cli.exit_code = failures
            return result
        return cb
    def kwargs_output(self):
        return self.kwargs
    def action(self, action, *args, **kwargs):
        if isinstance(action, str):
            # import dotted module path string to action
            import cli2
            a = cli2.Callable.factory(action).target
            if not a:
                a = cli2.Callable.factory(
                    '.'.join(['shlax', action])
                ).target
            if a:
                action = a
        p = action(*args, **kwargs)
        p.parent = self
        for parent in self.parents():
            if hasattr(parent, 'actions'):
                p.parent = parent
                break
        if 'actions' not in self.__dict__:
            # "mutate" to Strategy
            from ..strategies.script import Actions
            self.actions = Actions(self, [p])
        return p
    @class_or_instance_method
    def steps(self):
        return {
            key: getattr(self, key)
            for key in dir(self)
            if key != 'steps'  # avoid recursion
            and (
                key in self.default_steps
                or getattr(getattr(self, key), 'shlaxstep', False)
            )
        }
@@ -1,56 +1,7 @@
-import asyncio
+from .base import Action
 import binascii
 import os
-class Copy:
+class Copy(Action):
-    def __init__(self, *args):
+    """Copy files or directories to target."""
-        self.src = args[:-1]
+    async def call(self, *args, **kwargs):
-        self.dst = args[-1]
+        await self.copy(*self.args)
    def listfiles(self):
        if getattr(self, '_listfiles', None):
            return self._listfiles
        result = []
        for src in self.src:
            if os.path.isfile(src):
                result.append(src)
                continue
            for root, dirs, files in os.walk(src):
                if '__pycache__' in root:
                    continue
                result += [
                    os.path.join(root, f)
                    for f in files
                    if not f.endswith('.pyc')
                ]
        self._listfiles = result
        return result
    async def __call__(self, target):
        await target.mkdir(self.dst)
        for path in self.listfiles():
            if os.path.isdir(path):
                await target.mkdir(os.path.join(self.dst, path))
            elif '/' in path:
                dirname = os.path.join(
                    self.dst,
                    '/'.join(path.split('/')[:-1])
                )
                await target.mkdir(dirname)
                await target.copy(path, dirname)
            else:
                await target.copy(path, self.dst)
    def __str__(self):
        return f'Copy({", ".join(self.src)}, {self.dst})'
    async def cachekey(self):
        async def chksum(path):
            with open(path, 'rb') as f:
                return (path, str(binascii.crc32(f.read())))
        results = await asyncio.gather(*[chksum(f) for f in self.listfiles()])
        return {path: chks for path, chks in results}
@@ -0,0 +1,37 @@
 import hashlib
 import secrets
 import string
 from .base import Action
 class Htpasswd(Action):
    """Ensure a user is present in an htpasswd file."""
    display_variables = ('user', 'path')
    regexps = {
        r'(.*)': '{red}\\1{gray}:${blue}\\2${blue}',
        r'([^:]*):\\$([^$]*)\\$(.*)$': '{red}\\1{gray}:${blue}\\2${blue}\\3',
    }
    def __init__(self, user, path, **kwargs):
        self.user = user
        self.path = path
        super().__init__(**kwargs)
    async def apply(self):
        found = False
        htpasswd = await self.target.exec(
            'cat', self.path, raises=False)
        if htpasswd.rc == 0:
            for line in htpasswd.out.split('\n'):
                if line.startswith(self.user + ':'):
                    found = True
                    break
        if not found:
            self.password = ''.join(secrets.choice(
                string.ascii_letters + string.digits
            ) for i in range(20))
            hashed = hashlib.sha1(self.password.encode('utf8'))
            line = f'{self.user}:\\$sha1\\${hashed.hexdigest()}'
            await self.target.exec(f'echo {line} >> {self.path}')
@@ -7,8 +7,10 @@ import os
 import subprocess
 from textwrap import dedent
 from .base import Action
-class Packages:
+
 class Packages(Action):
    """
    Package manager abstract layer with caching.
@@ -52,12 +54,12 @@ class Packages:
    installed = []
-    def __init__(self, *packages, upgrade=True):
+    def __init__(self, *packages, **kwargs):
        self.packages = []
        self.upgrade = upgrade
        for package in packages:
            line = dedent(package).strip().replace('\n', ' ')
            self.packages += line.split(' ')
        super().__init__(*packages, **kwargs)
    @property
    def cache_root(self):
@@ -66,9 +68,9 @@ class Packages:
        else:
            return os.path.join(os.getenv('HOME'), '.cache')
-    async def update(self, target):
+    async def update(self):
        # run pkgmgr_setup functions ie. apk_setup
-        cachedir = await getattr(self, self.mgr + '_setup')(target)
+        cachedir = await getattr(self, self.mgr + '_setup')()
        lastupdate = None
        if os.path.exists(cachedir + '/lastupdate'):
@@ -92,7 +94,7 @@ class Packages:
                    f.write(str(os.getpid()))
                try:
-                    await target.rexec(self.cmds['update'])
+                    await self.rexec(self.cmds['update'])
                finally:
                    os.unlink(lockfile)
@@ -100,15 +102,15 @@ class Packages:
                    f.write(str(now))
            else:
                while os.path.exists(lockfile):
-                    print(f'{self.target} | Waiting for {lockfile} ...')
+                    print(f'{self.container.name} | Waiting for update ...')
                    await asyncio.sleep(1)
-    async def __call__(self, target):
+    async def apply(self):
-        cached = getattr(target, 'pkgmgr', None)
+        cached = getattr(self.target, 'pkgmgr', None)
        if cached:
            self.mgr = cached
        else:
-            mgr = await target.which(*self.mgrs.keys())
+            mgr = await self.target.which(*self.mgrs.keys())
            if mgr:
                self.mgr = mgr[0].split('/')[-1]
@@ -116,9 +118,11 @@ class Packages:
            raise Exception('Packages does not yet support this distro')
        self.cmds = self.mgrs[self.mgr]
-        await self.update(target)
+        if not getattr(self, '_packages_upgraded', None):
-        if self.upgrade:
+            await self.update()
-            await target.rexec(self.cmds['upgrade'])
+            if self.kwargs.get('upgrade', True):
                await self.target.exec(self.cmds['upgrade'], user='root')
            self._packages_upgraded = True
        packages = []
        for package in self.packages:
@@ -131,22 +135,22 @@ class Packages:
            else:
                packages.append(package)
-        await target.rexec(*self.cmds['install'].split(' ') + packages)
+        await self.target.exec(*self.cmds['install'].split(' ') + packages, user='root')
-    async def apk_setup(self, target):
+    async def apk_setup(self):
        cachedir = os.path.join(self.cache_root, self.mgr)
-        await target.mount(cachedir, '/var/cache/apk')
+        await self.mount(cachedir, '/var/cache/apk')
        # special step to enable apk cache
-        await target.rexec('ln -sf /var/cache/apk /etc/apk/cache')
+        await self.rexec('ln -sf /var/cache/apk /etc/apk/cache')
        return cachedir
-    async def dnf_setup(self, target):
+    async def dnf_setup(self):
        cachedir = os.path.join(self.cache_root, self.mgr)
-        await target.mount(cachedir, f'/var/cache/{self.mgr}')
+        await self.mount(cachedir, f'/var/cache/{self.mgr}')
-        await target.rexec('echo keepcache=True >> /etc/dnf/dnf.conf')
+        await self.rexec('echo keepcache=True >> /etc/dnf/dnf.conf')
        return cachedir
-    async def apt_setup(self, target):
+    async def apt_setup(self):
        codename = (await self.rexec(
            f'source {self.mnt}/etc/os-release; echo $VERSION_CODENAME'
        )).out
@@ -158,8 +162,8 @@ class Packages:
        await self.mount(cache_lists, f'/var/lib/apt/lists')
        return cachedir
-    async def pacman_setup(self, target):
+    async def pacman_setup(self):
        return self.cache_root + '/pacman'
-    def __str__(self):
+    def __repr__(self):
-        return f'Packages({self.packages}, upgrade={self.upgrade})'
+        return f'Packages({self.packages})'
@@ -1,11 +0,0 @@
 import asyncio
 class Parallel:
    def __init__(self, *actions):
        self.actions = actions
    async def __call__(self, target):
        return await asyncio.gather(*[
            target(action) for action in self.actions
        ])
@@ -1,69 +1,59 @@
 from glob import glob
 import os
 from urllib import request
 from .base import Action
 class Pip(Action):
    """Pip abstraction layer."""
    def __init__(self, *pip_packages):
        self.pip_packages = pip_packages
-    async def __call__(self, target):
+    def __init__(self, *pip_packages, pip=None, requirements=None):
-        # ensure python presence
+        self.requirements = requirements
-        results = await target.which('python3', 'python')
+        super().__init__(*pip_packages, pip=pip, requirements=requirements)
        if results:
            python = results[0]
        else:
            raise Exception('Could not find pip nor python')
-        # ensure pip module presence
+    async def call(self, *args, **kwargs):
-        result = await target.exec(python, '-m', 'pip', raises=False)
+        pip = self.kwargs.get('pip', None)
-        if result.rc != 0:
+        if not pip:
-            if not os.path.exists('get-pip.py'):
+            pip = await self.which('pip3', 'pip', 'pip2')
-                req = request.urlopen(
+            if pip:
-                    'https://bootstrap.pypa.io/get-pip.py'
+                pip = pip[0]
            else:
                from .packages import Packages
                action = self.action(
                    Packages,
                    'python3,apk', 'python3-pip,apt',
                    args=args, kwargs=kwargs
                )
-                content = req.read()
+                await action(*args, **kwargs)
-                with open('get-pip.py', 'wb+') as f:
+                pip = await self.which('pip3', 'pip', 'pip2')
-                    f.write(content)
+                if not pip:
                    raise Exception('Could not install a pip command')
                else:
                    pip = pip[0]
            await target.copy('get-pip.py', '.')
            await target.exec(python, 'get-pip.py')
        # choose a cache directory
        if 'CACHE_DIR' in os.environ:
            cache = os.path.join(os.getenv('CACHE_DIR'), 'pip')
        else:
            cache = os.path.join(os.getenv('HOME'), '.cache', 'pip')
-        # and mount it
+        if getattr(self, 'mount', None):
        if getattr(target, 'mount', None):
            # we are in a target which shares a mount command
-            await target.mount(cache, '/root/.cache/pip')
+            await self.mount(cache, '/root/.cache/pip')
        await self.exec(f'{pip} install --upgrade pip')
-        source = []
+        # https://github.com/pypa/pip/issues/5599
-        nonsource = []
+        if 'pip' not in self.kwargs:
-        for package in self.pip_packages:
+            pip = 'python3 -m pip'
            if os.path.exists(package):
                source.append(package)
            else:
                nonsource.append(package)
        if nonsource:
            await target.exec(
                python, '-m', 'pip',
                'install', '--upgrade',
                *nonsource
            )
        source = [p for p in self.args if p.startswith('/') or p.startswith('.')]
        if source:
-            await target.exec(
+            await self.exec(
-                python, '-m', 'pip',
+                f'{pip} install --upgrade --editable {" ".join(source)}'
                'install', '--upgrade', '--editable',
                *source
            )
-    def __str__(self):
+        nonsource = [p for p in self.args if not p.startswith('/')]
-        return f'Pip({", ".join(self.pip_packages)})'
+        if nonsource:
            await self.exec(f'{pip} install --upgrade {" ".join(nonsource)}')
        if self.requirements:
            await self.exec(f'{pip} install --upgrade -r {self.requirements}')
@@ -1,11 +1,18 @@
 from .base import Action
-class Run:
+class Run(Action):
-    def __init__(self, cmd):
+    """Run a script or command on a target."""
-        self.cmd = cmd
+    async def call(self, *args, **kwargs):
        image = self.kwargs.get('image', None)
        if not image:
            return await self.exec(*self.args, **self.kwargs)
        from ..targets.buildah import Buildah
        from ..targets.docker import Docker
        if isinstance(image, Buildah):
            breakpoint()
            result = await self.action(image, *args, **kwargs)
-    async def __call__(self, target):
+        return await Docker(
-        self.proc = await target.exec(self.cmd)
+            image=image,
-
+        ).exec(*args, **kwargs)
    def __str__(self):
        return f'Run({self.cmd})'
@@ -0,0 +1,19 @@
 import asyncio
 from .base import Action
 class Service(Action):
    """
    Manage a systemd service.
    """
    def __init__(self, *names, state=None):
        self.state = state or 'started'
        self.names = names
        super().__init__()
    async def call(self, *args, **kwargs):
        return asyncio.gather(*[
            self.exec('systemctl', 'start', name, user='root')
            for name in self.names
        ])
@@ -1,42 +0,0 @@
 import os
 import re
 from .packages import Packages
 class User:
    """
    Create a user.
    Example:
        User('app', '/app', getenv('_CONTAINERS_ROOTLESS_UID', 1000)),
    _CONTAINERS_ROOTLESS_UID allows to get your UID during build, which happens
    in buildah unshare.
    """
    def __init__(self, username, home, uid):
        self.username = username
        self.home = home
        self.uid = uid
    def __str__(self):
        return f'User({self.username}, {self.home}, {self.uid})'
    async def __call__(self, target):
        result = await target.rexec('id', self.uid)
        if result.rc == 0:
            old = re.match('.*\(([^)]*)\).*', result.out).group(1)
            await target.rexec(
                'usermod',
                '-d', self.home,
                '-l', self.username,
                old
            )
        else:
            await target.rexec(
                'useradd',
                '-d', self.home,
                '-u', self.uid,
                self.username
            )
@@ -1,80 +1,170 @@
 """
 Shlax automation tool manual
 Shlax is built mostly around 3 moving pieces:
 - Target: a target host and protocol
 - Action: execute a shlax action
 - Strategy: defines how to apply actions on targets (scripted only)
 Shlax executes mostly in 3 ways:
 - Execute actions on targets with the command line
 - With your shlaxfile as first argument: offer defined Actions
 - With the name of a module in shlax.repo: a community maintained shlaxfile
 """
-import ast
+
-import asyncio
+import copy
 import cli2
 import glob
 import inspect
 import importlib
 import glob
 import os
 import sys
-
+from .actions.base import Action
-class Group(cli2.Group):
+from .exceptions import ShlaxException, WrongResult
-    def __init__(self, *args, **kwargs):
+from .strategies import Script
        super().__init__(*args, **kwargs)
        self.cmdclass = Command
-class Command(cli2.Command):
+class ConsoleScript(cli2.ConsoleScript):
-    def call(self, *args, **kwargs):
+    class Parser(cli2.Parser):
-        return self.shlax_target(self.target)
+        def __init__(self, *args, **kwargs):
            self.targets = dict()
            super().__init__(*args, **kwargs)
-    def __call__(self, *argv):
+        def append(self, arg):
-        from shlax.targets.base import Target
+            if '=' not in arg and '@' in arg:
-        self.shlax_target = Target()
+                if '://' in arg:
-        result = super().__call__(*argv)
+                    kind, spec = arg.split('://')
-        self.shlax_target.output.results(self.shlax_target)
+                else:
-        return result
+                    kind = 'ssh'
                    spec = arg
                mod = importlib.import_module('shlax.targets.' + kind)
                target = getattr(mod, kind.capitalize())(spec)
                self.targets[str(target)] = target
            else:
                super().append(arg)
-class ActionCommand(Command):
+    def __call__(self):
-    def call(self, *args, **kwargs):
+        if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
-        self.target = self.target(*args, **kwargs)
+            pass
-        return super().call(*args, **kwargs)
+        else:
            scripts = glob.glob(os.path.join(
                os.path.dirname(__file__), 'actions', '*.py'))
            for script in scripts:
                modname = script.split('/')[-1].replace('.py', '')
                mod = importlib.import_module('shlax.actions.' + modname)
                for key, value in mod.__dict__.items():
                    if key.lower() != modname:
                        continue
                    break
                self[modname] = cli2.Callable(
                    modname, self.action_class(value))
            scripts = glob.glob(os.path.join(
                os.path.dirname(__file__), 'repo', '*.py'))
            for script in scripts:
                modname = script.split('/')[-1].replace('.py', '')
                mod = importlib.import_module('shlax.repo.' + modname)
                self[modname] = cli2.Group(key, doc=inspect.getdoc(mod))
                for key, value in mod.__dict__.items():
                    if not isinstance(value, Action):
                        continue
                    doc = (inspect.getdoc(mod) or '').split("\n")[0]
                    if key == 'main':
                        if len(value.steps()) == 1:
                            self[modname] = cli2.Callable(
                                modname, self.action(value), doc=doc)
                        else:
                            for name, method in value.steps().items():
                                self[modname][name] = cli2.Callable(
                                    modname, self.action(value),
                                    doc=inspect.getdoc(method)
                                )
                    else:
                        if len(value.steps()) == 1:
                            self[modname][key] = cli2.Callable(
                                modname, self.action(value), doc=doc)
                        else:
                            self[modname][key] = cli2.Group('steps')
                            for step in value.steps():
                                self[modname][key][step] = cli2.Callable(
                                    modname, self.action(value), doc='lol')
-class ConsoleScript(Group):
+        return super().__call__()
    def __call__(self, *argv):
        self.load_actions()
        #self.load_shlaxfiles()  # wip
        return super().__call__(*argv)
-    def load_shlaxfiles(self):
+    def action(self, action):
-        filesdir = os.path.dirname(__file__) + '/shlaxfiles/'
+        async def cb(*args, **kwargs):
-        for filename in os.listdir(filesdir):
+            options = dict(steps=args)
-            filepath = filesdir + filename
+            options.update(self.parser.options)
-            if not os.path.isfile(filepath):
+            # UnboundLocalError: local variable 'action' referenced before assignment
-                continue
+            # ??? gotta be missing something, commenting meanwhile
            # action = copy.deepcopy(action)
            return await action(*self.parser.targets, **options)
        return cb
-            with open(filepath, 'r') as f:
+    def action_class(self, action_class):
-                tree = ast.parse(f.read())
+        async def cb(*args, **kwargs):
-            group = self.group(filename[:-3])
+            argspec = inspect.getfullargspec(action_class)
            required = argspec.args[1:]
            missing = []
            for i, name in enumerate(required):
                if len(args) - 1 <= i:
                    continue
                if name in kwargs:
                    continue
                missing.append(name)
            if missing:
                if not args:
                    print('No args provided after action name ' + action_class.__name__.lower())
                print('Required arguments: ' + ', '.join(argspec.args[1:]))
                if args:
                    print('Provided: ' + ', '.join(args))
                print('Missing arguments: ' + ', '.join(missing))
                print('Try to just add args on the command line separated with a space')
                print(inspect.getdoc(action_class))
                example = 'Example: shlax action '
                example += action_class.__name__.lower()
                if args:
                    example += ' ' + ' '.join(args)
                example += ' ' + ' '.join(missing)
                print(example)
                return
-            main = Group(doc=__doc__).load(shlax)
+            _args = []
            steps = []
            for arg in args:
                if arg in action_class.steps():
                    steps.append(arg)
                else:
                    _args.append(arg)
-    def load_actions(self):
+            options = dict(steps=steps)
        actionsdir = os.path.dirname(__file__) + '/actions/'
        for filename in os.listdir(actionsdir):
            filepath = actionsdir + filename
            if not os.path.isfile(filepath):
                continue
            with open(filepath, 'r') as f:
                tree = ast.parse(f.read())
            cls = [
                node
                for node in tree.body
                if isinstance(node, ast.ClassDef)
            ]
            if not cls:
                continue
            mod = importlib.import_module('shlax.actions.' + filename[:-3])
            cls = getattr(mod, cls[0].name)
            self.add(cls, name=filename[:-3], cmdclass=ActionCommand)
            '''
            varargs = argspec.varargs
            if varargs:
                extra = args[len(argspec.args) - 1:]
                args = args[:len(argspec.args) - 1]
                options = dict(steps=extra)
            else:
                extra = args[len(argspec.args) - 1:]
                args = args[:len(argspec.args) - 1]
                options = dict(steps=extra)
            '''
            options.update(self.parser.options)
            return await action_class(*_args, **kwargs)(*self.parser.targets, **options)
        cb.__doc__ = (inspect.getdoc(action_class) or '').split("\n")[0]
        return cb
-cli = ConsoleScript(doc=__doc__)
+    def call(self, command):
        try:
            return super().call(command)
        except WrongResult as e:
            print(e)
            self.exit_code = e.proc.rc
        except ShlaxException as e:
            print(e)
            self.exit_code = 1
 cli = ConsoleScript(__doc__).add_module('shlax.cli')
@@ -1,32 +0,0 @@
 import os
 from .image import Image
 class Container:
    def __init__(self, build=None, image=None):
        self.build = build
        self.image = self.build.image
        prefix = os.getcwd().split('/')[-1]
        repo = self.image.repository.replace('/', '-')
        if prefix == repo:
            self.name = repo
        else:
            self.name = '-'.join([prefix, repo])
    async def start(self, target):
        """Start the container"""
        await target.rexec(
            'podman',
            'run',
            '--name',
            self.name,
            str(self.image),
        )
    async def stop(self, target):
        """Start the container"""
        await target.rexec('podman', 'stop', self.name)
    def __str__(self):
        return f'Container(name={self.name}, image={self.image})'
@@ -0,0 +1,22 @@
 class ShlaxException(Exception):
    pass
 class Mistake(ShlaxException):
    pass
 class WrongResult(ShlaxException):
    def __init__(self, proc):
        self.proc = proc
        msg = f'FAIL exit with {proc.rc} ' + proc.args[0]
        if not proc.debug or 'cmd' not in str(proc.debug):
            msg += '\n' + proc.cmd
        if not proc.debug or 'out' not in str(proc.debug):
            msg += '\n' + proc.out
            msg += '\n' + proc.err
        super().__init__(msg)
@@ -1,9 +1,19 @@
 import copy
 import os
 import re
 class Image:
    ENV_TAGS = (
        # gitlab
        'CI_COMMIT_SHORT_SHA',
        'CI_COMMIT_REF_NAME',
        'CI_COMMIT_TAG',
        # CircleCI
        'CIRCLE_SHA1',
        'CIRCLE_TAG',
        'CIRCLE_BRANCH',
        # contributions welcome here
    )
    PATTERN = re.compile(
        '^((?P<backend>[a-z]*)://)?((?P<registry>[^/]*[.][^/]*)/)?((?P<repository>[^:]+))?(:(?P<tags>.*))?$'  # noqa
        , re.I
@@ -33,6 +43,12 @@ class Image:
        if self.registry == 'docker.io':
            self.format = 'docker'
        # figure tags from CI vars
        for name in self.ENV_TAGS:
            value = os.getenv(name)
            if value:
                self.tags.append(value)
        # filter out tags which resolved to None
        self.tags = [t for t in self.tags if t]
@@ -40,6 +56,10 @@ class Image:
        if not self.tags:
            self.tags = ['latest']
    async def __call__(self, action, *args, **kwargs):
        args = list(args)
        return await action.exec(*args, **self.kwargs)
    def __str__(self):
        return f'{self.repository}:{self.tags[-1]}'
@@ -53,8 +73,3 @@ class Image:
        for tag in self.tags:
            await action.exec('buildah', 'push', f'{self.repository}:{tag}')
    def layer(self, key):
        layer = copy.deepcopy(self)
        layer.tags = ['layer-' + key]
        return layer
@@ -1,6 +1,5 @@
 import re
 import sys
 import types
 from .colors import colors
@@ -26,23 +25,7 @@ class Output:
    def colorize(self, code, content):
        return self.color(code) + content + self.color()
-    def colorized(self, action):
+    def __init__(self, prefix=None, regexps=None, debug=False, write=None, flush=None, **kwargs):
        if hasattr(action, 'colorized'):
            return action.colorized(self.colors)
        elif isinstance(action, types.MethodType):
            return f'{action.__self__}.{action.__name__}'
        else:
            return str(action)
    def __init__(
            self,
            prefix=None,
            regexps=None,
            debug='cmd,visit,out',
            write=None,
            flush=None,
            **kwargs
        ):
        self.prefix = prefix
        self.debug = debug
        self.prefix_length = 0
@@ -116,21 +99,22 @@ class Output:
        return line
    def test(self, action):
-        self(''.join([
+        if self.debug is True:
-            self.colors['purplebold'],
+            self(''.join([
-            '!  TEST   ',
+                self.colors['purplebold'],
-            self.colors['reset'],
+                '!  TEST   ',
-            self.colorized(action),
+                self.colors['reset'],
-            '\n',
+                action.colorized(self.colors),
-        ]))
+                '\n',
            ]))
    def clean(self, action):
-        if self.debug:
+        if self.debug is True:
            self(''.join([
                self.colors['bluebold'],
                '+  CLEAN  ',
                self.colors['reset'],
-                self.colorized(action),
+                action.colorized(self.colors),
                '\n',
            ]))
@@ -140,27 +124,7 @@ class Output:
                self.colors['orangebold'],
                '⚠  START  ',
                self.colors['reset'],
-                self.colorized(action),
+                action.colorized(self.colors),
                '\n',
            ]))
    def info(self, text):
        if self.debug is True or 'visit' in str(self.debug):
            self(''.join([
                self.colors['cyanbold'],
                '➤   INFO  ',
                self.colors['reset'],
                text,
                '\n',
            ]))
    def skip(self, action):
        if self.debug is True or 'visit' in str(self.debug):
            self(''.join([
                self.colors['yellowbold'],
                '↪️   SKIP  ',
                self.colors['reset'],
                self.colorized(action),
                '\n',
            ]))
@@ -170,7 +134,7 @@ class Output:
                self.colors['greenbold'],
                '✔ SUCCESS ',
                self.colors['reset'],
-                self.colorized(action),
+                action.colorized(self.colors) if hasattr(action, 'colorized') else str(action),
                '\n',
            ]))
@@ -180,32 +144,6 @@ class Output:
                self.colors['redbold'],
                '✘  FAIL   ',
                self.colors['reset'],
-                self.colorized(action),
+                action.colorized(self.colors) if hasattr(action, 'colorized') else str(action),
                '\n',
            ]))
    def results(self, action):
        success = 0
        fail = 0
        for result in action.results:
            if result.status == 'success':
                success += 1
            if result.status == 'failure':
                fail += 1
        self(''.join([
            self.colors['greenbold'],
            '✔ SUCCESS REPORT: ',
            self.colors['reset'],
            str(success),
            '\n',
        ]))
        if fail:
            self(''.join([
                self.colors['redbold'],
                '✘  FAIL REPORT: ',
                self.colors['reset'],
                str(fail),
                '\n',
            ]))
@@ -0,0 +1,9 @@
 from .targets import Localhost
 class Play:
    def __init__(self, *actions, targets=None, options=None):
        self.options = options or {}
        self.targets = targets or dict(localhost=Localhost())
        self.actions =
@@ -1,26 +0,0 @@
 import cli2
 from shlax.targets.base import Target
 from shlax.actions.parallel import Parallel
 class Pod:
    """Help text"""
    def __init__(self, **containers):
        self.containers = containers
    async def _call(self, target, method, *names):
        methods = [
            getattr(container, method)
            for name, container in self.containers.items()
            if not names or name in names
        ]
        await target(Parallel(*methods))
    async def build(self, target, *names):
        """Build container images"""
        await self._call(target, 'build', *names)
    async def start(self, target, *names):
        """Start container images"""
        await self._call(target, 'start', *names)
@@ -7,46 +7,31 @@ import os
 import shlex
 import sys
 from .exceptions import WrongResult
 from .output import Output
 class ProcFailure(Exception):
    def __init__(self, proc):
        self.proc = proc
        msg = f'FAIL exit with {proc.rc} ' + proc.args[0]
        if not proc.output.debug or 'cmd' not in str(proc.output.debug):
            msg += '\n' + proc.cmd
        if not proc.output.debug or 'out' not in str(proc.output.debug):
            msg += '\n' + proc.out
            msg += '\n' + proc.err
        super().__init__(msg)
 class PrefixStreamProtocol(asyncio.subprocess.SubprocessStreamProtocol):
    """
    Internal subprocess stream protocol to add a prefix in front of output to
    make asynchronous output readable.
    """
-    def __init__(self, proc, *args, **kwargs):
+    def __init__(self, output, *args, **kwargs):
-        self.proc = proc
+        self.output = output
        super().__init__(*args, **kwargs)
    def pipe_data_received(self, fd, data):
-        if self.proc.output.debug is True or 'out' in str(self.proc.output.debug):
+        if self.output.debug is True or 'out' in str(self.output.debug):
            if fd in (1, 2):
-                self.proc.output(data)
+                self.output(data)
        super().pipe_data_received(fd, data)
-def protocol_factory(proc):
+def protocol_factory(output):
    def _p():
        return PrefixStreamProtocol(
-            proc,
+            output,
            limit=asyncio.streams._DEFAULT_LIMIT,
            loop=asyncio.events.get_event_loop()
        )
@@ -69,11 +54,9 @@ class Proc:
    """
    test = False
-    def __init__(self, *args, prefix=None, raises=True, output=None, quiet=False):
+    def __init__(self, *args, prefix=None, raises=True, debug=None, output=None):
-        if quiet:
+        self.debug = debug if not self.test else False
-            self.output = Output(debug=False)
+        self.output = output or Output()
        else:
            self.output = output or Output()
        self.cmd = ' '.join(args)
        self.args = args
        self.prefix = prefix
@@ -104,7 +87,7 @@ class Proc:
        if self.called:
            raise Exception('Already called: ' + self.cmd)
-        if 'cmd' in str(self.output.debug):
+        if self.debug is True or 'cmd' in str(self.debug):
            self.output.cmd(self.cmd)
        if self.test:
@@ -115,7 +98,7 @@ class Proc:
        loop = asyncio.events.get_event_loop()
        transport, protocol = await loop.subprocess_exec(
-            protocol_factory(self), *self.args)
+            protocol_factory(self.output), *self.args)
        self.proc = asyncio.subprocess.Process(transport, protocol, loop)
        self.called = True
@@ -140,7 +123,7 @@ class Proc:
        if not self.communicated:
            await self.communicate()
        if self.raises and self.proc.returncode:
-            raise ProcFailure(self)
+            raise WrongResult(self)
        return self
    @property
@@ -0,0 +1,35 @@
 #!/usr/bin/env shlax
 """
 Manage a traefik container maintained by Shlax community.
 """
 from shlax.shortcuts import *
 main = Docker(
    name='traefik',
    image='traefik:v2.0.0',
    install=Htpasswd(
        './htpasswd', 'root', doc='Install root user in ./htpasswd'
    ),
    networks=['web'],
    command=[
        '--entrypoints.web.address=:80',
        '--providers.docker',
        '--api',
    ],
    ports=[
        '80:80',
        '443:443',
    ],
    volumes=[
        '/var/run/docker.sock:/var/run/docker.sock:ro',
        '/etc/traefik/acme/:/etc/traefik/acme/',
        '/etc/traefik/htpasswd:/htpasswd:ro',
    ],
    labels=[
        'traefik.http.routers.traefik.rule=Host(`{{ url.split("/")[2] }}`)',
        'traefik.http.routers.traefik.service=api@internal',
        'traefik.http.routers.traefik.entrypoints=web',
    ],
 )
@@ -1,13 +1,7 @@
 class Result:
-    def __init__(self, target, action):
+    def __init__(self, action, target):
        self.target = target
        self.action = action
        self.target = target
        self.status = 'pending'
        self.exception = None
 class Results(list):
    def new(self, target, action):
        result = Result(target, action)
        self.append(result)
        return result
@@ -0,0 +1,28 @@
 import importlib
 import os
 from .actions.base import Action
 class Shlaxfile:
    def __init__(self, actions=None, tests=None):
        self.actions = actions or {}
        self.tests = tests or {}
        self.paths = []
    def parse(self, path):
        spec = importlib.util.spec_from_file_location('shlaxfile', path)
        mod = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(mod)
        for name, value in mod.__dict__.items():
            if isinstance(value, Action):
                value.__name__ = name
                self.actions[name] = value
            elif callable(value) and getattr(value, '__name__', '').startswith('test_'):
                self.tests[value.__name__] = value
        self.paths.append(path)
    @property
    def path(self):
        return self.paths[0]
@@ -1,18 +1,14 @@
 from .targets.base import Target
 from .targets.buildah import Buildah
 from .targets.localhost import Localhost
 from .targets.stub import Stub
 from .actions.copy import Copy
-from .actions.packages import Packages
+from .actions.packages import Packages  # noqa
-from .actions.run import Run
+from .actions.base import Action  # noqa
 from .actions.htpasswd import Htpasswd
 from .actions.run import Run  # noqa
 from .actions.pip import Pip
-from .actions.parallel import Parallel
+from .actions.service import Service
 from .actions.user import User
-from .cli import Command, Group
+from .targets.buildah import Buildah
 from .targets.docker import Docker
 from .targets.localhost import Localhost
 from .targets.ssh import Ssh
 from .container import Container
 from .pod import Pod
 from os import getenv, environ
@@ -0,0 +1,3 @@
 from .asyn import Async
 from .script import Script
 from .pod import Pod, Container
@@ -0,0 +1,11 @@
 import asyncio
 from .script import Script
 class Async(Script):
    async def call(self, *args, **kwargs):
        return await asyncio.gather(*[
            action(*args, **kwargs)
            for action in self.actions
        ])
@@ -0,0 +1,44 @@
 import os
 from .script import Script
 from ..image import Image
 class Container(Script):
    """
    Wolcome to crazy container control cli
    Such wow
    """
    def __init__(self, *args, **kwargs):
        kwargs.setdefault('start', dict())
        super().__init__(*args, **kwargs)
    async def call(self, *args, **kwargs):
        if step('build'):
            await self.kwargs['build'](**kwargs)
            self.image = self.kwargs['build'].image
        else:
            self.image = kwargs.get('image', 'alpine')
        if isinstance(self.image, str):
            self.image = Image(self.image)
        if step('install'):
            await self.install(*args, **kwargs)
        if step('test'):
            self.output.test(self)
            await self.action('Docker',
                *self.kwargs['test'].actions,
                image=self.image,
                mount={'.': '/app'},
                workdir='/app',
            )(**kwargs)
        if step('push'):
            await self.image.push(action=self)
        #name = kwargs.get('name', os.getcwd()).split('/')[-1]
 class Pod(Script):
    pass
@@ -0,0 +1,41 @@
 import copy
 import os
 from ..exceptions import WrongResult
 from ..actions.base import Action
 from ..proc import Proc
 class Actions(list):
    def __init__(self, owner, actions):
        self.owner = owner
        super().__init__()
        for action in actions:
            self.append(action)
    def append(self, value):
        action = copy.deepcopy(value)
        action.parent = self.owner
        action.status = 'pending'
        super().append(action)
 class Script(Action):
    contextualize = ['shargs', 'exec', 'rexec', 'env', 'which', 'copy']
    def __init__(self, *actions, **kwargs):
        self.home = kwargs.pop('home', os.getcwd())
        super().__init__(**kwargs)
        self.actions = Actions(self, actions)
    async def call(self, *args, **kwargs):
        for action in self.actions:
            result = await action(*args, **kwargs)
            if action.status != 'success':
                break
    def pollute(self, gbls):
        for name, script in self.kwargs.items():
            if not isinstance(script, Script):
                continue
            gbls[name] = script
@@ -0,0 +1,7 @@
 from .script import Script
 class Test(Script):
    async def call(self, *args, backend=None, **kwargs):
        backend = backend or 'Docker'
        breakpoint()
        return await self.action(backend, self.actions, **kwargs)
@@ -1,146 +0,0 @@
 import asyncio
 import copy
 from pathlib import Path
 import os
 import re
 import sys
 from ..output import Output
 from ..proc import Proc
 from ..result import Result, Results
 class Target:
    def __init__(self, *actions, root=None):
        self.actions = actions
        self.results = []
        self.output = Output()
        self.parent = None
        self.root = root or os.getcwd()
    @property
    def parent(self):
        return self._parent or Target()
    @parent.setter
    def parent(self, value):
        self._parent = value
    @property
    def caller(self):
        """Traverse parents and return the top-levels Target."""
        if not self._parent:
            return self
        caller = self._parent
        while caller._parent:
            caller = caller._parent
        return caller
    async def __call__(self, *actions, target=None):
        if target:
            # that's going to be used by other target methods, to access
            # the calling target
            self.parent = target
        for action in actions or self.actions:
            if await self.action(action, reraise=bool(actions)):
                break
    async def action(self, action, reraise=False):
        result = Result(self, action)
        self.output.start(action)
        try:
            await action(target=self)
        except Exception as e:
            self.output.fail(action, e)
            result.status = 'failure'
            result.exception = e
            if reraise:
                # nested call, re-raise
                raise
            else:
                import traceback
                traceback.print_exception(type(e), e, sys.exc_info()[2])
                return True
        else:
            self.output.success(action)
            result.status = 'success'
        finally:
            self.caller.results.append(result)
            clean = getattr(action, 'clean', None)
            if clean:
                self.output.clean(action)
                await clean(self, result)
    async def rexec(self, *args, **kwargs):
        kwargs['user'] = 'root'
        return await self.exec(*args, **kwargs)
    async def which(self, *cmd):
        """
        Return the first path to the cmd in the container.
        If cmd argument is a list then it will try all commands.
        """
        proc = await self.exec('type ' + ' '.join(cmd), raises=False)
        result = []
        for res in proc.out.split('\n'):
            match = re.match('([^ ]+) is ([^ ]+)$', res.strip())
            if match:
                result.append(match.group(1))
        return result
    def shargs(self, *args, **kwargs):
        user = kwargs.pop('user', None)
        args = [str(arg) for arg in args if args is not None]
        if args and ' ' in args[0]:
            if len(args) == 1:
                args = ['sh', '-euc', args[0]]
            else:
                args = ['sh', '-euc'] + list(args)
        if user == 'root':
            args = ['sudo'] + args
        elif user:
            args = ['sudo', '-u', user] + args
        return args, kwargs
        if self.parent:
            return self.parent.shargs(*args, **kwargs)
        else:
            return args, kwargs
    async def exec(self, *args, **kwargs):
        kwargs['output'] = self.output
        args, kwargs = self.shargs(*args, **kwargs)
        proc = await Proc(*args, **kwargs)()
        if kwargs.get('wait', True):
            await proc.wait()
        return proc
    @property
    def root(self):
        return self._root
    @root.setter
    def root(self, value):
        self._root = Path(value or os.getcwd())
    def path(self, path):
        if str(path).startswith('/'):
            path = str(path)[1:]
        return self.root / path
    async def mkdir(self, path):
        if '_mkdir' not in self.__dict__:
            self._mkdir = []
        path = str(path)
        if path not in self._mkdir:
            await self.exec('mkdir', '-p', path)
            self._mkdir.append(path)
    async def copy(self, *args):
        return await self.exec('cp', '-a', *args)
@@ -1,224 +1,156 @@
 import asyncio
 import copy
 import hashlib
 import json
 import os
-import sys
+import asyncio
 from pathlib import Path
 import signal
 import shlex
 import subprocess
 import sys
 import textwrap
-from .base import Target
+from ..actions.base import Action
-
+from ..exceptions import Mistake
 from ..image import Image
 from ..proc import Proc
 from ..image import Image
 from .localhost import Localhost
-class Buildah(Target):
+class Buildah(Localhost):
-    """Build container image with buildah"""
+    """
    The build script iterates over visitors and runs the build functions, it
    also provides wrappers around the buildah command.
    """
    contextualize = Localhost.contextualize + ['mnt', 'ctr', 'mount', 'image']
-    def __init__(self,
+    def __init__(self, base, *args, commit=None, push=False, cmd=None, **kwargs):
-                 *actions,
+        if isinstance(base, Action):
-                 base=None, commit=None,
+            args = [base] + list(args)
-                 cmd=None):
+            base = 'alpine'  # default selection in case of mistake
-        self.base = base or 'alpine'
+        super().__init__(*args, **kwargs)
-        self.image = Image(commit) if commit else None
+        self.base = base
        self.ctr = None
        self.root = None
        self.mounts = dict()
-
+        self.ctr = None
-        self.config = dict(
+        self.mnt = None
        self.image = Image(commit) if commit else None
        self.config= dict(
            cmd=cmd or 'sh',
        )
-        # Always consider localhost as parent for now
+    def shargs(self, *args, user=None, buildah=True, **kwargs):
-        self.parent = Target()
+        if not buildah or args[0].startswith('buildah'):
            return super().shargs(*args, user=user, **kwargs)
        super().__init__(*actions)
    def is_runnable(self):
        return Proc.test or os.getuid() == 0
    def __str__(self):
        if not self.is_runnable():
            return 'Replacing with: buildah unshare ' + ' '.join(sys.argv)
        return f'Buildah({self.image})'
    async def __call__(self, *actions, target=None):
        if target:
            self.parent = target
        if not self.is_runnable():
            os.execvp('buildah', ['buildah', 'unshare'] + sys.argv)
            # program has been replaced
        layers = await self.layers()
        keep = await self.cache_setup(layers, *actions)
        keepnames = [*map(lambda x: 'localhost/' + str(x), keep)]
        self.invalidate = [name for name in layers if name not in keepnames]
        if self.invalidate:
            self.output.info('Invalidating old layers')
            await self.parent.exec(
                'buildah', 'rmi', *self.invalidate, raises=False)
        if actions:
            actions = actions[len(keep):]
            if not actions:
                return self.uptodate()
        else:
            self.actions = self.actions[len(keep):]
            if not self.actions:
                return self.uptodate()
        self.ctr = (await self.parent.exec('buildah', 'from', self.base)).out
        self.root = Path((await self.parent.exec('buildah', 'mount', self.ctr)).out)
        return await super().__call__(*actions)
    def uptodate(self):
        self.clean = None
        self.output.success('Image up to date')
        return
    async def layers(self):
        ret = set()
        results = await self.parent.exec(
            'buildah images --json',
            quiet=True,
        )
        results = json.loads(results.out)
        prefix = 'localhost/' + self.image.repository + ':layer-'
        for result in results:
            if not result.get('names', None):
                continue
            for name in result['names']:
                if name.startswith(prefix):
                    ret.add(name)
        return ret
    async def cache_setup(self, layers, *actions):
        keep = []
        self.image_previous = Image(self.base)
        for action in actions or self.actions:
            action_image = await self.action_image(action)
            name = 'localhost/' + str(action_image)
            if name in layers:
                self.base = self.image_previous = action_image
                keep.append(action_image)
                self.output.skip(
                    f'Found layer for {action}: {action_image.tags[0]}'
                )
            else:
                break
        return keep
    async def action_image(self, action):
        prefix = str(self.image_previous)
        for tag in self.image_previous.tags:
            if tag.startswith('layer-'):
                prefix = tag
                break
        if hasattr(action, 'cachekey'):
            action_key = action.cachekey()
            if asyncio.iscoroutine(action_key):
                action_key = str(await action_key)
        else:
            action_key = str(action)
        key = prefix + action_key
        sha1 = hashlib.sha1(key.encode('ascii'))
        return self.image.layer(sha1.hexdigest())
    async def action(self, action, reraise=False):
        stop = await super().action(action, reraise)
        if not stop:
            action_image = await self.action_image(action)
            self.output.info(f'Commiting {action_image} for {action}')
            await self.parent.exec(
                'buildah',
                'commit',
                '--format=' + action_image.format,
                self.ctr,
                action_image,
            )
            self.image_previous = action_image
        return stop
    async def clean(self, target, result):
        for src, dst in self.mounts.items():
            await self.parent.exec('umount', self.root / str(dst)[1:])
        if self.root is not None:
            await self.parent.exec('buildah', 'umount', self.ctr)
        if self.ctr is not None:
            if result.status == 'success':
                await self.commit()
            await self.parent.exec('buildah', 'rm', self.ctr)
            if result.status == 'success' and os.getenv('BUILDAH_PUSH'):
                await self.image.push(target)
    async def mount(self, src, dst):
        """Mount a host directory into the container."""
        target = self.root / str(dst)[1:]
        await self.parent.exec(f'mkdir -p {src} {target}')
        await self.parent.exec(f'mount -o bind {src} {target}')
        self.mounts[src] = dst
    async def exec(self, *args, user=None, **kwargs):
        _args = ['buildah', 'run']
        if user:
            _args += ['--user', user]
        _args += [self.ctr, '--', 'sh', '-euc']
-        _args += [' '.join([str(a) for a in args])]
+        return super().shargs(
-        return await self.parent.exec(*_args, **kwargs)
+            *(
-
+                _args
-    async def commit(self, image=None):
+                + [' '.join([str(a) for a in args])]
-        image = image or self.image
+            ),
-        if not image:
+            **kwargs
            return
        if not image:
            # don't go through that if layer commit
            for key, value in self.config.items():
                await self.parent.exec(f'buildah config --{key} "{value}" {self.ctr}')
        self.sha = (await self.parent.exec(
            'buildah',
            'commit',
            '--format=' + image.format,
            self.ctr,
        )).out
        ENV_TAGS = (
            # gitlab
            'CI_COMMIT_SHORT_SHA',
            'CI_COMMIT_REF_NAME',
            'CI_COMMIT_TAG',
            # CircleCI
            'CIRCLE_SHA1',
            'CIRCLE_TAG',
            'CIRCLE_BRANCH',
            # contributions welcome here
        )
-        # figure tags from CI vars
+    def __repr__(self):
-        for name in ENV_TAGS:
+        return f'Base({self.base})'
            value = os.getenv(name)
            if value:
                self.image.tags.append(value)
-        if image.tags:
+    async def config(self, line):
-            tags = [f'{image.repository}:{tag}' for tag in image.tags]
+        """Run buildah config."""
-        else:
+        return await self.exec(f'buildah config {line} {self.ctr}', buildah=False)
            tags = [image.repository]
        for tag in tags:
            await self.parent.exec('buildah', 'tag', self.sha, tag)
    async def mkdir(self, path):
        return await self.parent.mkdir(self.path(path))
    async def copy(self, *args):
-        return await self.parent.copy(*args[:-1], self.path(args[-1]))
+        """Run buildah copy to copy a file from host into container."""
        src = args[:-1]
        dst = args[-1]
        await self.mkdir(dst)
        procs = []
        for s in src:
            if Path(s).is_dir():
                target = self.mnt / s
                if not target.exists():
                    await self.mkdir(target)
                args = ['buildah', 'copy', self.ctr, s, Path(dst) / s]
            else:
                args = ['buildah', 'copy', self.ctr, s, dst]
            procs.append(self.exec(*args, buildah=False))
        return await asyncio.gather(*procs)
    async def mount(self, src, dst):
        """Mount a host directory into the container."""
        target = self.mnt / str(dst)[1:]
        await self.exec(f'mkdir -p {src} {target}', buildah=False)
        await self.exec(f'mount -o bind {src} {target}', buildah=False)
        self.mounts[src] = dst
    def is_runnable(self):
        return (
            Proc.test
            or os.getuid() == 0
        )
    async def call(self, *args, **kwargs):
        if self.is_runnable():
            self.ctr = (await self.exec('buildah', 'from', self.base, buildah=False)).out
            self.mnt = Path((await self.exec('buildah', 'mount', self.ctr, buildah=False)).out)
            result = await super().call(*args, **kwargs)
            return result
        from shlax.cli import cli
        debug = kwargs.get('debug', False)
        # restart under buildah unshare environment
        argv = [
            'buildah', 'unshare',
            sys.argv[0],  # current script location
            cli.shlaxfile.path,  # current shlaxfile location
        ]
        if debug is True:
            argv.append('-d')
        elif isinstance(debug, str) and debug:
            argv.append('-d=' + debug)
        argv += [
            cli.parser.command.name,  # script name ?
        ]
        await self.exec(*argv)
    async def commit(self):
        if not self.image:
            return
        for key, value in self.config.items():
            await self.exec(f'buildah config --{key} "{value}" {self.ctr}')
        self.sha = (await self.exec(
            'buildah',
            'commit',
            '--format=' + self.image.format,
            self.ctr,
            buildah=False,
        )).out
        if self.image.tags:
            tags = [f'{self.image.repository}:{tag}' for tag in self.image.tags]
        else:
            tags = [self.image.repository]
        for tag in tags:
            await self.exec('buildah', 'tag', self.sha, tag, buildah=False)
    async def clean(self, *args, **kwargs):
        if self.is_runnable():
            for src, dst in self.mounts.items():
                await self.exec('umount', self.mnt / str(dst)[1:], buildah=False)
            if self.status == 'success':
                await self.commit()
                if 'push' in args:
                    await self.image.push(action=self)
            if self.mnt is not None:
                await self.exec('buildah', 'umount', self.ctr, buildah=False)
            if self.ctr is not None:
                await self.exec('buildah', 'rm', self.ctr, buildah=False)
@@ -0,0 +1,111 @@
 import asyncio
 from pathlib import Path
 import os
 from ..image import Image
 from .localhost import Localhost
 class Docker(Localhost):
    """Manage a docker container."""
    default_steps = ['install', 'up']
    def __init__(self, *args, **kwargs):
        self.image = kwargs.get('image', 'alpine')
        self.name = kwargs.get('name', os.getcwd().split('/')[-1])
        if not isinstance(self.image, Image):
            self.image = Image(self.image)
        super().__init__(*args, **kwargs)
    def shargs(self, *args, daemon=False, **kwargs):
        if args[0] == 'docker':
            return args, kwargs
        extra = []
        if 'user' in kwargs:
            extra += ['--user', kwargs.pop('user')]
        args, kwargs = super().shargs(*args, **kwargs)
        if self.name:
            executor = 'exec'
            extra = [self.name]
            return [self.kwargs.get('docker', 'docker'), executor, '-t'] + extra + list(args), kwargs
        executor = 'run'
        cwd = os.getcwd()
        if daemon:
            extra += ['-d']
        extra = extra + ['-v', f'{cwd}:{cwd}', '-w', f'{cwd}']
        return [self.kwargs.get('docker', 'docker'), executor, '-t'] + extra + [str(self.image)] + list(args), kwargs
    async def call(self, *args, **kwargs):
        def step(step):
            return not args or step in args
        # self.name = (
        #     await self.exec(
        #         'docker', 'ps', '-aq', '--filter',
        #         'name=' + self.name,
        #         raises=False
        #     )
        # ).out.split('\n')[0]
        if step('install') and 'install' in self.kwargs:
            breakpoint()
            await self.action(self.kwargs['install'], *args, **kwargs)
        if step('rm') and await self.exists():
            await self.exec('docker', 'rm', '-f', self.name)
        if step('up'):
            if await self.exists():
                self.name = (await self.exec('docker', 'start', self.name)).out
            else:
                self.id = (await self.exec(
                    'docker', 'run', '-d', '--name', self.name, str(self.image))
                ).out
        return await super().call(*args, **kwargs)
    async def exists(self):
        proc = await self.exec(
            'docker', 'ps', '-aq', '--filter',
            'name=' + self.name,
            raises=False
        )
        return bool(proc.out.strip())
    async def copy(self, *args):
        src = args[:-1]
        dst = args[-1]
        await self.mkdir(dst)
        procs = []
        for s in src:
            '''
            if Path(s).is_dir():
                await self.mkdir(s)
                args = ['docker', 'copy', self.ctr, s, Path(dst) / s]
            else:
                args = ['docker', 'copy', self.ctr, s, dst]
            '''
            args = ['docker', 'cp', s, self.name + ':' + dst]
            procs.append(self.exec(*args))
        return await asyncio.gather(*procs)
    async def up(self):
        """Ensure container is up and running."""
        if await self.exists():
            self.name = (await self.exec('docker', 'start', self.name)).out
        else:
            self.id = (await self.exec(
                'docker', 'run', '-d', '--name', self.name, str(self.image))
            ).out
    up.shlaxstep = True
    async def rm(self):
        """Remove container."""
        await self.exec('docker', 'rm', '-f', self.name)
    rm.shlaxstep = True
@@ -1,14 +1,19 @@
-import copy
+import os
 import re
-from ..output import Output
+from shlax.proc import Proc
 from ..proc import Proc
 from ..result import Result, Results
-from .base import Target
+from ..strategies.script import Script
-class Localhost(Target):
+class Localhost(Script):
    root = '/'
    contextualize = Script.contextualize + ['home']
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.home = kwargs.pop('home', os.getcwd())
    def shargs(self, *args, **kwargs):
        user = kwargs.pop('user', None)
        args = [str(arg) for arg in args if args is not None]
@@ -24,8 +29,6 @@ class Localhost(Target):
        elif user:
            args = ['sudo', '-u', user] + args
        return args, kwargs
        if self.parent:
            return self.parent.shargs(*args, **kwargs)
        else:
@@ -38,3 +41,40 @@ class Localhost(Target):
        if kwargs.get('wait', True):
            await proc.wait()
        return proc
    async def rexec(self, *args, **kwargs):
        kwargs['user'] = 'root'
        return await self.exec(*args, **kwargs)
    async def env(self, name):
        return (await self.exec('echo $' + name)).out
    async def exists(self, *paths):
        proc = await self.exec('type ' + ' '.join(cmd), raises=False)
    async def which(self, *cmd):
        """
        Return the first path to the cmd in the container.
        If cmd argument is a list then it will try all commands.
        """
        proc = await self.exec('type ' + ' '.join(cmd), raises=False)
        result = []
        for res in proc.out.split('\n'):
            match = re.match('([^ ]+) is ([^ ]+)$', res.strip())
            if match:
                result.append(match.group(1))
        return result
    async def copy(self, *args):
        if args[-1].startswith('./'):
            args = list(args)
            args[-1] = self.home + '/' + args[-1][2:]
        args = ['cp', '-rua'] + list(args)
        return await self.exec(*args)
    async def mount(self, *dirs):
        pass
    async def mkdir(self, *dirs):
        return await self.exec(*['mkdir', '-p'] + list(dirs))
@@ -0,0 +1,17 @@
 import os
 from shlax.proc import Proc
 from .localhost import Localhost
 class Ssh(Localhost):
    root = '/'
    def __init__(self, host, *args, **kwargs):
        self.host = host
        super().__init__(*args, **kwargs)
    def shargs(self, *args, **kwargs):
        args, kwargs = super().shargs(*args, **kwargs)
        return (['ssh', self.host] + list(args)), kwargs
@@ -1,23 +0,0 @@
 from ..proc import Proc
 from .base import Target
 class ProcStub(Proc):
    async def __call__(self, wait=True):
        return self
    async def communicate(self):
        self.communicated = True
        return self
    async def wait(self):
        return self
 class Stub(Target):
    async def exec(self, *args, **kwargs):
        proc = await ProcStub(*args, **kwargs)()
        if kwargs.get('wait', True):
            await proc.wait()
        return proc
@@ -1,20 +1,55 @@
-#!/usr/bin/env python
+#!/usr/bin/env shlax
-"""
+from shlax.contrib.gitlab import *
 Shlaxfile for shlax itself.
 """
-from shlax.shortcuts import *
+PYTEST = 'py.test -svv tests'
-shlax = Container(
+test = Script(
-    build=Buildah(
+    Pip('.[test]'),
-        Packages('python38', 'buildah', 'unzip', 'findutils', upgrade=False),
+    Run(PYTEST),
        Copy('setup.py', 'shlax', '/app'),
        Pip('/app'),
        base='quay.io/podman/stable',
        commit='shlax',
    ),
 )
 build = Buildah(
    'quay.io/podman/stable',
    Packages('python38', 'buildah', 'unzip', 'findutils', 'python3-yaml', upgrade=False),
    Async(
        # dancing for pip on centos python3.8
        Run('''
        curl -o setuptools.zip https://files.pythonhosted.org/packages/42/3e/2464120172859e5d103e5500315fb5555b1e908c0dacc73d80d35a9480ca/setuptools-45.1.0.zip
        unzip setuptools.zip
        mkdir -p /usr/local/lib/python3.8/site-packages/
        sh -c "cd setuptools-* && python3.8 setup.py install"
        easy_install-3.8 pip
        echo python3.8 -m pip > /usr/bin/pip
        chmod +x /usr/bin/pip
        '''),
        Copy('shlax/', 'setup.py', '/app'),
    ),
    Pip('/app[full]'),
    commit='docker.io/yourlabs/shlax',
    workdir='/app',
 )
-if __name__ == '__main__':
+shlax = Container(
-    print(Group(doc=__doc__).load(shlax).entry_point())
+    build=build,
    test=Script(Run('./shlaxfile.py -d test')),
 )
 gitlabci = GitLabCI(
    test=dict(
        stage='build',
        script='pip install -U --user -e .[test] && ' + PYTEST,
        image='yourlabs/python',
    ),
    build=dict(
        stage='build',
        image='yourlabs/shlax',
        script='pip install -U --user -e . && CACHE_DIR=$(pwd)/.cache ./shlaxfile.py -d shlax build push',
        cache=dict(paths=['.cache'], key='cache'),
    ),
    pypi=dict(
        stage='deploy',
        only=['tags'],
        image='yourlabs/python',
        script='pypi-release',
    ),
 )
@@ -0,0 +1,53 @@
 from shlax import *
 inner = Run()
 other = Run('ls')
 middle = Buildah('alpine', inner, other)
 outer = Localhost(middle)
 middle = outer.actions[0]
 other = middle.actions[1]
 inner = middle.actions[0]
 def test_action_init_args():
    assert other.args == ('ls',)
 def test_action_parent_autoset():
    assert list(outer.actions) == [middle]
    assert middle.parent == outer
    assert inner.parent == middle
    assert other.parent == middle
 def test_action_context():
    assert outer.context is inner.context
    assert middle.context is inner.context
    assert middle.context is outer.context
    assert other.context is outer.context
 def test_action_sibblings():
    assert inner.sibblings() == [other]
    assert inner.sibblings(lambda s: s.args[0] == 'ls') == [other]
    assert inner.sibblings(lambda s: s.args[0] == 'foo') == []
    assert inner.sibblings(type='run') == [other]
    assert inner.sibblings(args=('ls',)) == [other]
 def test_actions_parents():
    assert other.parents() == [middle, outer]
    assert other.parents(lambda p: p.base == 'alpine') == [middle]
    assert inner.parents(type='localhost') == [outer]
    assert inner.parents(type='buildah') == [middle]
 def test_action_childrens():
    assert middle.children() == [inner, other]
    assert middle.children(lambda a: a.args[0] == 'ls') == [other]
    assert outer.children() == [middle, inner, other]
 def test_action_getattr():
    assert other.exec == middle.exec
    assert other.shargs == middle.shargs
@@ -1,7 +1,7 @@
 import pytest
 import os
-from shlax.image import Image
+from shlax import Image
 tests = {
@@ -25,3 +25,9 @@ def test_args(arg, expected):
    im = Image(arg)
    for k, v in expected.items():
        assert getattr(im, k) == v
 def test_args_env():
    os.environ['IMAGE_TEST_ARGS_ENV'] = 'foo'
    Image.ENV_TAGS = ['IMAGE_TEST_ARGS_ENV']
    im = Image('re/po:x,y')
    assert im.tags == ['x', 'y', 'foo']
@@ -1,5 +1,5 @@
 import pytest
-from shlax.output import Output
+from shlax import Output
 class Write:
@@ -0,0 +1,65 @@
 import pytest
 from unittest.mock import patch
 from shlax import *
 from shlax import proc
 test_args_params = [
    (
        Localhost(Run('echo hi')),
        [('sh', '-euc', 'echo hi')]
    ),
    (
        Localhost(Run('echo hi', user='jimi')),
        [('sudo', '-u', 'jimi', 'sh', '-euc', 'echo hi')]
    ),
    (
        Localhost(Run('echo hi', user='root')),
        [('sudo', 'sh', '-euc', 'echo hi')]
    ),
    (
        Ssh('host', Run('echo hi', user='root')),
        [('ssh', 'host', 'sudo', 'sh', '-euc', 'echo hi')]
    ),
    (
        Buildah('alpine', Run('echo hi')),
        [
            ('buildah', 'from', 'alpine'),
            ('buildah', 'mount', ''),
            ('buildah', 'run', '', '--', 'sh', '-euc', 'echo hi'),
            ('buildah', 'umount', ''),
            ('buildah', 'rm', ''),
        ]
    ),
    (
        Buildah('alpine', Run('echo hi', user='root')),
        [
            ('buildah', 'from', 'alpine'),
            ('buildah', 'mount', ''),
            ('buildah', 'run', '--user', 'root', '', '--', 'sh', '-euc', 'echo hi'),
            ('buildah', 'umount', ''),
            ('buildah', 'rm', ''),
        ]
    ),
    (
        Ssh('host', Buildah('alpine', Run('echo hi', user='root'))),
        [
            ('ssh', 'host', 'buildah', 'from', 'alpine'),
            ('ssh', 'host', 'buildah', 'mount', ''),
            ('ssh', 'host', 'buildah', 'run', '--user', 'root', '', '--', 'sh', '-euc', 'echo hi'),
            ('ssh', 'host', 'buildah', 'umount', ''),
            ('ssh', 'host', 'buildah', 'rm', ''),
        ]
    ),
 ]
@pytest.mark.parametrize(
    'script,commands',
    test_args_params
 )
@pytest.mark.asyncio
 async def test_args(script, commands):
    with Proc.mock():
        await script()
        assert commands == Proc.test
@@ -1,101 +0,0 @@
 import pytest
 from shlax.targets.stub import Stub
 from shlax.actions.run import Run
 from shlax.actions.parallel import Parallel
 from shlax.result import Result
 class Error:
    async def __call__(self, target):
        raise Exception('lol')
@pytest.mark.asyncio
 async def test_success():
    action = Run('echo hi')
    target = Stub(action)
    await target()
    assert target.results[0].action == action
    assert target.results[0].status == 'success'
@pytest.mark.asyncio
 async def test_error():
    action = Error()
    target = Stub(action)
    await target()
    assert target.results[0].action == action
    assert target.results[0].status == 'failure'
@pytest.mark.asyncio
 async def test_nested():
    nested = Error()
    class Nesting:
        async def __call__(self, target):
            await target(nested)
    nesting = Nesting()
    target = Stub(nesting)
    await target()
    assert len(target.results) == 2
    assert target.results[0].status == 'failure'
    assert target.results[0].action == nested
    assert target.results[1].status == 'failure'
    assert target.results[1].action == nesting
@pytest.mark.asyncio
 async def test_parallel():
    winner = Run('echo hi')
    looser = Error()
    parallel = Parallel(winner, looser)
    target = Stub(parallel)
    await target()
    assert len(target.results) == 3
    assert target.results[0].status == 'success'
    assert target.results[0].action == winner
    assert target.results[1].status == 'failure'
    assert target.results[1].action == looser
    assert target.results[2].status == 'failure'
    assert target.results[2].action == parallel
@pytest.mark.asyncio
 async def test_function():
    async def hello(target):
        await target.exec('hello')
    await Stub()(hello)
@pytest.mark.asyncio
 async def test_method():
    class Example:
        def __init__(self):
            self.was_called = False
        async def test(self, target):
            self.was_called = True
    example = Example()
    action = example.test
    target = Stub()
    await target(action)
    assert example.was_called
@pytest.mark.asyncio
 async def test_target_action():
    child = Stub(Run('echo hi'))
    parent = Stub(child)
    grandpa = Stub()
    await grandpa(parent)
    assert len(grandpa.results) == 3
    grandpa = Stub(parent)
    await grandpa()
    assert len(grandpa.results) == 3
Author	SHA1	Message	Date
jpic	ea061db51f	wip	2020-02-20 13:18:53 +01:00
jpic	2db971234a	Trying to get somewhere with traefik module	2020-02-17 01:00:59 +01:00
jpic	41ec8db301	Magic command line	2020-02-16 21:34:41 +01:00
jpic	33c37f8e44	wip	2020-02-16 20:54:12 +01:00
jpic	f5ab14d383	Trying to enrich shlax command in a scalable fashion	2020-02-16 20:53:49 +01:00
jpic	97255866f8	Remove old code	2020-02-16 20:14:20 +01:00