action_base.py

"""Base class for all actions of remote client."""
import abc
from functools import lru_cache

import podman


class AbstractActionBase(abc.ABC):
    """Base class for all actions of remote client."""

    @classmethod
    @abc.abstractmethod
    def subparser(cls, parent):
        """Define parser for this action.  Subclasses must implement.

        API:
        Use set_defaults() to set attributes "class_" and "method". These will
        be invoked as class_(parsed_args).method()
        """
        parent.add_flag(
            '--all',
            help='list all items.')
        parent.add_flag(
            '--truncate',
            '--trunc',
            default=True,
            help="Truncate id's and other long fields.")
        parent.add_flag(
            '--heading',
            default=True,
            help='Include table headings in the output.')
        parent.add_flag(
            '--quiet',
            help='List only the IDs.')

    def __init__(self, args):
        """Construct class."""
        # Dump all unset arguments before transmitting to service
        self._args = args
        self.opts = {
            k: v
            for k, v in vars(self._args).items() if v is not None
        }

    @property
    def remote_uri(self):
        """URI for remote side of connection."""
        return self._args.remote_uri

    @property
    def local_uri(self):
        """URI for local side of connection."""
        return self._args.local_uri

    @property
    def identity_file(self):
        """Key for authenication."""
        return self._args.identity_file

    @property
    def ignore_hosts(self):
        """Ignore ssh host keys."""
        return self._args.ignore_hosts

    @property
    def known_hosts(self):
        """File for known hosts."""
        return self._args.known_hosts

    @property
    @lru_cache(maxsize=1)
    def client(self):
        """Podman remote client for communicating."""
        if self._args.host is None:
            return podman.Client(uri=self.local_uri)
        return podman.Client(
            uri=self.local_uri,
            remote_uri=self.remote_uri,
            identity_file=self.identity_file,
            ignore_hosts=self.ignore_hosts,
            known_hosts=self.known_hosts)

    def __repr__(self):
        """Compute the “official” string representation of object."""
        return ("{}(local_uri='{}', remote_uri='{}',"
                " identity_file='{}', ignore_hosts='{}', known_hosts='{}')").format(
                    self.__class__,
                    self.local_uri,
                    self.remote_uri,
                    self.identity_file,
                    self.ignore_hosts,
                    self.known_hosts,
                )