# -*- coding: utf-8 -*-
import abc
import six
import logging
from freckles.utils.host_utils import parse_target_string
from frutils import dict_merge
log = logging.getLogger("freckles")
[docs]@six.add_metaclass(abc.ABCMeta)
class FrecklesRunTarget(object):
def __init__(self, target_dict=None, target_string=None):
self._target_string = target_string
if target_dict is None:
target_dict = {}
self._target_dict = target_dict
self._target_dict_base = None
self._config = None
self._protocol = None
self._user = None
self._port = None
self._host = None
self._connection_type = None
self._ssh_key = None
self._become_pass = None
self._login_pass = None
self._warning_showed = False
self._invalidated = True
def _init_config(self):
if self._target_string is not None:
self._target_dict_base = parse_target_string(self._target_string)
else:
self._target_dict_base = {}
self._config = dict_merge(
self._target_dict_base, self._target_dict, copy_dct=False
)
if "host" not in self._config.keys():
self._config["host"] = "localhost"
self._protocol = self._config.get("protocol", None)
self._user = self._config.get("user", None)
self._port = self._config.get("port", None)
self._host = self._config.get("host", None)
self._connection_type = self._config.get("connection_type", None)
self._ssh_key = self._config.get("ssh_key", None)
self._become_pass = self._config.get("become_pass", None)
self._login_pass = self._config.get("login_pass", None)
if self._connection_type == "lxd":
if self._user is None:
self._user = "root"
if self._user != "root":
if not self._warning_showed:
log.warning(
"lxd connection type does not support different user than 'root', ignoring specified user: {}".format(
self._user
)
)
self._warning_showed = True
self._user = "root"
self._invalidated = False
@property
def connection_type(self):
if self._invalidated:
self._init_config()
return self._connection_type
@connection_type.setter
def connection_type(self, connection_type):
self._target_dict["connection_type"] = connection_type
self._invalidated = True
@property
def ssh_key(self):
if self._invalidated:
self._init_config()
return self._ssh_key
@ssh_key.setter
def ssh_key(self, ssh_key):
self._target_dict["ssh_key"] = ssh_key
self._invalidated = True
@property
def become_pass(self):
if self._invalidated:
self._init_config()
return self._become_pass
@become_pass.setter
def become_pass(self, become_pass):
self._target_dict["become_pass"] = become_pass
self._invalidated = True
@property
def login_pass(self):
if self._invalidated:
self._init_config()
return self._login_pass
@login_pass.setter
def login_pass(self, login_pass):
self._target_dict["login_pass"] = login_pass
self._invalidated = True
@property
def protocol(self):
if self._invalidated:
self._init_config()
return self._protocol
@protocol.setter
def protocol(self, protocol):
self._target_dict["protocol"] = protocol
self._invalidated = True
@property
def user(self):
if self._invalidated:
self._init_config()
return self._user
@user.setter
def user(self, user):
self._target_dict["user"] = user
self._invalidated = True
@property
def port(self):
if self._invalidated:
self._init_config()
return self._port
@port.setter
def port(self, port):
self._target_dict["port"] = port
self._invalidated = True
@property
def host(self):
if self._invalidated:
self._init_config()
return self._host
@host.setter
def host(self, host):
self._target_dict["host"] = host
self._invalidated = True
@property
def config(self):
if self._invalidated:
self._init_config()
result = {}
if self.protocol is not None:
result["protocol"] = self.protocol
if self.user is not None:
result["user"] = self.user
if self.port is not None:
result["port"] = self.port
if self.host is not None:
result["host"] = self.host
if self.connection_type is not None:
result["connection_type"] = self.connection_type
if self.ssh_key is not None:
result["ssh_key"] = self.ssh_key
if self.become_pass is not None:
result["become_pass"] = self.become_pass
if self.login_pass is not None:
result["login_pass"] = self.login_pass
return result
[docs]class FrecklesRunConfig(FrecklesRunTarget):
[docs] @classmethod
def create(self, target_dict_or_string, elevated=None, no_run=False, metadata=None):
if isinstance(target_dict_or_string, six.string_types):
run_config = FrecklesRunConfig(
target_string=target_dict_or_string,
target_dict=None,
elevated=elevated,
no_run=no_run,
metadata=metadata,
)
else:
run_config = FrecklesRunConfig(
target_string=None,
target_dict=target_dict_or_string,
elevated=elevated,
no_run=no_run,
metadata=metadata,
)
return run_config
def __init__(
self,
target_dict=None,
target_string=None,
elevated=None,
no_run=False,
metadata=None,
):
super(FrecklesRunConfig, self).__init__(
target_dict=target_dict, target_string=target_string
)
self._elevated = elevated
self._no_run = no_run
if metadata is None:
metadata = {}
self._metadata = metadata
def _init_config(self):
super(FrecklesRunConfig, self)._init_config()
@property
def elevated(self):
return self._elevated
@elevated.setter
def elevated(self, elevated):
self._elevated = elevated
@property
def no_run(self):
return self._no_run
@no_run.setter
def no_run(self, no_run):
self._no_run = no_run
@property
def metadata(self):
return self._metadata
@metadata.setter
def metadata(self, metadata):
self._metadata = metadata
@property
def config(self):
temp = super(FrecklesRunConfig, self).config
temp["no_run"] = self.no_run
temp["metadata"] = self.metadata
if self.elevated is not None:
temp["elevated"] = self.elevated
return temp