refactor: renamed module with utilities for management of software for given users and groups
This commit is contained in:
173
servs.py
Normal file
173
servs.py
Normal file
@@ -0,0 +1,173 @@
|
||||
from typing import TypedDict as Dict
|
||||
from typing import Self, Literal, Never
|
||||
from collections.abc import Sequence
|
||||
from custtypes import Roles, Scopes, PathCollection, PathRoles, Software, SoftwareRoles, ExecutedPath, PacMans, UserName, GroupName, IdlePath, ExecutedPath
|
||||
from pathlib import Path, PurePath
|
||||
from sshkey import SSHKeyCollection, SSHKeyType, SSHKey
|
||||
from whereami import PROJ_ROLES
|
||||
|
||||
class App:
|
||||
def __init__(self, name: Software, role: SoftwareRoles = SoftwareRoles.client, paths: PathRoles | None = None):
|
||||
self.__name = name
|
||||
# @TODO create dict type hint for below data struct
|
||||
self.alt_names = dict()
|
||||
self.alt_names[PacMans.APT] = self.__name
|
||||
self.role = role
|
||||
if paths is not None:
|
||||
if Roles.EXE in paths:
|
||||
setattr(self, "_" + Roles.EXE.name.lower(), paths[Roles.EXE.name.lower()])
|
||||
if Roles.CONF in paths:
|
||||
setattr(self, "_" + Roles.CONF.name.lower(), paths[Roles.CONF.name.lower()])
|
||||
if Roles.DATA in paths:
|
||||
setattr(self, "_" + Roles.DATA.name.lower(), paths[Roles.DATA.name.lower()])
|
||||
self.__parents: tuple[Self] | None = None
|
||||
self.__children: tuple[Self| None] = []
|
||||
self.__api: str | None = None
|
||||
self.__current_filepath: IdlePath | ExecutedPath | None = None
|
||||
self.__content: str | None = None
|
||||
|
||||
@property
|
||||
def conf_paths(self):
|
||||
if hasattr(self, "_" + Roles.CONF.name.lower()):
|
||||
return self._conf
|
||||
else:
|
||||
raise Exception
|
||||
|
||||
@property
|
||||
def data_paths(self):
|
||||
if hasattr(self, "_" + Roles.DATA.name.lower()):
|
||||
return self._data
|
||||
else:
|
||||
raise Exception
|
||||
|
||||
@property
|
||||
def exec_paths(self):
|
||||
if hasattr(self, "_" + Roles.EXE.name.lower()):
|
||||
return self._exe
|
||||
else:
|
||||
raise Exception
|
||||
|
||||
def append(self, datatype: Roles = Roles.CONF, scope: Scopes | None = None, path: IdlePath | ExecutedPath | str | PathCollection | None = None):
|
||||
if path is None:
|
||||
raise TypeError
|
||||
|
||||
datatype = datatype.name.lower()
|
||||
|
||||
if hasattr(self, "_" + datatype):
|
||||
paths = getattr(self, "_" + datatype)
|
||||
else:
|
||||
setattr(self, "_" + datatype, dict())
|
||||
|
||||
if scope is not None:
|
||||
if isinstance(path, str):
|
||||
path: ExecutedPath = Path(path)
|
||||
|
||||
if scope.name.lower() not in paths:
|
||||
paths[scope.name.lower()] = []
|
||||
|
||||
paths[scope.name.lower()].append(path)
|
||||
else:
|
||||
paths: PathCollection = path
|
||||
|
||||
setattr(self, "_" + datatype, paths)
|
||||
|
||||
def inherit(self, other):
|
||||
if other._App__children is None:
|
||||
other._App__children = tuple()
|
||||
|
||||
if self not in other._App__children:
|
||||
other.adopt(self)
|
||||
|
||||
self.__parents = (*self.__parents, other)
|
||||
|
||||
def adopt(self, other: Self):
|
||||
if other._App__parents is None:
|
||||
other._App__parents = tuple()
|
||||
|
||||
if self not in other._App__parent:
|
||||
other.inherit(self)
|
||||
|
||||
self.__children = (*self.__children, other)
|
||||
|
||||
def __enter__(self) -> dict | Sequence:
|
||||
self.__content = self.__current_filepath.read_text()
|
||||
return self.__content
|
||||
|
||||
def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
|
||||
# txt = yams.dump(self.__content)
|
||||
# self.__file.write(txt)
|
||||
# del txt
|
||||
self.__file.close()
|
||||
|
||||
def __call__(self, path = str, mode = "r+", scope: Scopes = Scopes.PROJ, index: int = 0) -> None:
|
||||
if not hasattr(self, "_" + Roles.CONF.name.lower()):
|
||||
raise Exception
|
||||
|
||||
conf_coll = self._conf[scope.name.lower()]
|
||||
|
||||
if isinstance(conf_coll, Sequence):
|
||||
conf_coll = conf_coll[index]
|
||||
|
||||
if isinstance(conf_coll, str):
|
||||
conf_coll = Path(conf_coll)
|
||||
|
||||
filepath = conf_coll / path
|
||||
|
||||
self.__current_filepath = filepath
|
||||
self.__file = open(str(filepath), mode)
|
||||
|
||||
# @TODO write below method to duplicate file or template in local to project role file/template
|
||||
def clone(self, source_scope: Scopes = Scopes.SYS, target_scope: Scopes = Scopes.PROJ, index: int = 0) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
# @TODO rewrite below using DIR_ROOTS var from whereami module
|
||||
sshd_paths: PathRoles = {
|
||||
Roles.CONF.name.lower(): {
|
||||
Scopes.PROJ.name.lower(): [
|
||||
PROJ_ROLES / "bootstrap" / "files" / "sshd_config.d",
|
||||
PROJ_ROLES / "bootstrap" / "templates" / "sshd_config.d"
|
||||
],
|
||||
}
|
||||
}
|
||||
sshd = App(Software.sshd, SoftwareRoles.server, sshd_paths)
|
||||
|
||||
class Group:
|
||||
def __init__(self, group_name: GroupName = GroupName.sudo, gid: int = 27):
|
||||
self.group_name = group_name
|
||||
self.id = gid
|
||||
self.category: Literal["system", "regular"] = "system"
|
||||
|
||||
class User:
|
||||
def __init__(self, username: UserName = UserName.root.name, password: str = "test", services: list = [Software.sshd.name.lower()], uid: int = 0):
|
||||
self.exists = True
|
||||
self.username = username
|
||||
self.id = uid
|
||||
self.password = password
|
||||
self.services: tuple = tuple(services)
|
||||
self.shell = "/bin/bash"
|
||||
self.home = "/"
|
||||
self.category: Literal["system", "regular"] = "regular"
|
||||
group = Group(username, self.id)
|
||||
self.primary_group = group
|
||||
self.supp_groups = None
|
||||
|
||||
if self.supp_groups is None:
|
||||
self.is_admin = True
|
||||
elif isinstance(self.supp_groups, Sequence) and GroupName.sudo in self.supp_groups:
|
||||
self.is_admin = True
|
||||
else:
|
||||
self.is_admin = False
|
||||
|
||||
ssh_keys = SSHKeyCollection()
|
||||
ssh_keys.pull()
|
||||
self.ssh_keys = ssh_keys
|
||||
pubkeys = ssh_keys.publish(SSHKeyType.pubkey.name.lower(), datatype=list)
|
||||
self.__auth_keys: list[str] = list(map(lambda k: k.read_text(), pubkeys))
|
||||
privkeys = ssh_keys.publish(SSHKeyType.privkey.name.lower(), datatype=list)
|
||||
self.__priv_keys: list[str] = list(map(lambda k: str(k), privkeys[0]))
|
||||
self.__priv_key_pref: int = privkeys[1]
|
||||
self.__apps = (sshd,)
|
||||
|
||||
def add_keypair(self, private_key, public_key):
|
||||
raise NotImplementedError
|
||||
|
||||
182
softman.py
182
softman.py
@@ -1,182 +0,0 @@
|
||||
"""
|
||||
Library of classes modeling software and software-related
|
||||
data as represented in or used by Ansible.
|
||||
"""
|
||||
|
||||
from typing import TypeAlias as Neotype
|
||||
from typing import TypedDict as Dict
|
||||
from typing import Never, Union, Callable
|
||||
from custtypes import ExecutedPath, IdlePath
|
||||
from enum import Enum
|
||||
from pathlib import Path, PurePath
|
||||
from whereami import USER_PATH, PROJ_ROOT
|
||||
from collections.abc import Sequence
|
||||
|
||||
AppPath: Neotype = Union[ExecutedPath, IdlePath]
|
||||
|
||||
class SoftScope(Enum):
|
||||
PERSONAL = 0
|
||||
LOCAL = 1
|
||||
GLOBAL = 2
|
||||
|
||||
class SoftPathGroup(Enum):
|
||||
CONFIG = 0
|
||||
DATA = 1
|
||||
MEM = 2
|
||||
EXE = 3
|
||||
|
||||
_SubAppParams = Dict("_SubAppParams", {
|
||||
SoftScope.PERSONAL.name: IdlePath | list[IdlePath],
|
||||
SoftScope.LOCAL.name: IdlePath | list[IdlePath],
|
||||
SoftScope.GLOBAL.name: IdlePath | list[IdlePath]
|
||||
}, total=False)
|
||||
AppParams = Dict("AppParams", {
|
||||
SoftPathGroup.CONFIG.name: _SubAppParams,
|
||||
SoftPathGroup.DATA.name: _SubAppParams,
|
||||
SoftPathGroup.MEM.name: _SubAppParams,
|
||||
SoftPathGroup.EXE.name: _SubAppParams
|
||||
}, total=False)
|
||||
|
||||
def __AppsInit(self, CONFIG = None, DATA = None, MEM = None, EXE = None):
|
||||
self.CONFIG = CONFIG
|
||||
self.DATA = DATA
|
||||
self.MEM = MEM
|
||||
self.EXE = EXE
|
||||
__app_input = {
|
||||
SoftPathGroup.CONFIG.name: {
|
||||
SoftScope.PERSONAL.name: [],
|
||||
SoftScope.LOCAL.name: [],
|
||||
SoftScope.GLOBAL.name: []
|
||||
},
|
||||
SoftPathGroup.DATA.name: {
|
||||
SoftScope.PERSONAL.name: [],
|
||||
SoftScope.LOCAL.name: [],
|
||||
SoftScope.GLOBAL.name: []
|
||||
},
|
||||
SoftPathGroup.MEM.name: {
|
||||
SoftScope.PERSONAL.name: [],
|
||||
SoftScope.LOCAL.name: [],
|
||||
SoftScope.GLOBAL.name: []
|
||||
},
|
||||
SoftPathGroup.EXE.name: {
|
||||
SoftScope.PERSONAL.name: [],
|
||||
SoftScope.LOCAL.name: [],
|
||||
SoftScope.GLOBAL.name: []
|
||||
},
|
||||
"__init__": __AppsInit
|
||||
}
|
||||
Apps = type("Apps", (), __app_input)
|
||||
|
||||
# @TODO continue adding magic methods to below class
|
||||
# @NOTE https://rszalski.github.io/magicmethods/#sequence
|
||||
class Software (Sequence):
|
||||
__user_path: ExecutedPath = USER_PATH
|
||||
|
||||
def __init__(self):
|
||||
self._fqdn: str | None = None
|
||||
|
||||
# @TODO fix NameError for 'Software' in parameter type check
|
||||
def append(self, name: str, **kwpaths: _SubAppParams) -> AppParams:
|
||||
keyword_args: AppParams = kwpaths
|
||||
|
||||
app = Apps(**keyword_args)
|
||||
setattr(self, name, app)
|
||||
return app
|
||||
|
||||
def __getitem__(self, key: str) -> AppParams | Never:
|
||||
if hasattr(self, key):
|
||||
app: Apps = getattr(self, key)
|
||||
else:
|
||||
raise KeyError
|
||||
return app
|
||||
|
||||
def __setitem__(self, key: tuple[str, SoftPathGroup], **value: IdlePath | list[IdlePath]) -> None | Never:
|
||||
if len(value) < 1 or len(value) > 3:
|
||||
raise ValueError
|
||||
|
||||
app_params: _SubAppParams = value
|
||||
|
||||
if hasattr(self, key[0]):
|
||||
app: Apps = getattr(self, key[0])
|
||||
|
||||
if hasattr(app, key[1]):
|
||||
app_child: _SubAppParams = getattr(app, key[1])
|
||||
|
||||
for k, v in app_params.items():
|
||||
v = [v] if not isinstance(v, list) else v
|
||||
app_child[k]: IdlePath | list[IdlePath] = v
|
||||
setattr(app, key[1], app_child)
|
||||
else:
|
||||
raise KeyError
|
||||
|
||||
setattr(self, key[0], app)
|
||||
else:
|
||||
raise KeyError
|
||||
|
||||
def __delitem__(self, key: tuple[str | SoftPathGroup]) -> None | Never:
|
||||
if len(key) < 1 or len(key) > 3:
|
||||
raise KeyError
|
||||
|
||||
if not hasattr(self, key[0]):
|
||||
raise KeyError
|
||||
|
||||
if len(key) == 1:
|
||||
delattr(self, key[0])
|
||||
elif len(key) > 1:
|
||||
app: Apps = getattr(self, key[0])
|
||||
delattr(app, key[1])
|
||||
setattr(self, key[0], app)
|
||||
|
||||
def show(self, contents: bool = False) -> tuple[str]:
|
||||
apps: tuple[str] | tuple[Apps] = tuple(
|
||||
filter(
|
||||
lambda a: isinstance(getattr(self, a), Apps),
|
||||
dir(self)
|
||||
)
|
||||
)
|
||||
|
||||
if contents:
|
||||
apps = tuple(
|
||||
map(
|
||||
lambda a: getattr(self, a),
|
||||
apps
|
||||
)
|
||||
)
|
||||
|
||||
return apps
|
||||
|
||||
def __len__(self) -> int:
|
||||
apps: tuple[str] = tuple(
|
||||
filter(
|
||||
lambda a: isinstance(getattr(self, a), Apps),
|
||||
dir(self)
|
||||
)
|
||||
)
|
||||
return len(apps)
|
||||
|
||||
def pop(self) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
def remove(self) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
def __contains__(self) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
def count(self) -> Never:
|
||||
return NotImplementedError
|
||||
|
||||
def __missing__(self) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
def __iter__(self) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
def reverse(self) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
def sort(self, key: Callable = (lambda e: e), reverse: bool = False) -> Never:
|
||||
raise NotImplementedError
|
||||
|
||||
class Softs(Enum):
|
||||
ssh = 0
|
||||
Reference in New Issue
Block a user