6 files changed, 458 insertions, 1 deletions
diff --git a/roles/lib_openshift/src/lib/clusterrole.py b/roles/lib_openshift/src/lib/clusterrole.py
new file mode 100644
index 000000000..93ffababf
--- /dev/null
+++ b/roles/lib_openshift/src/lib/clusterrole.py
@@ -0,0 +1,68 @@
+# pylint: skip-file
+# flake8: noqa
+
+
+# pylint: disable=too-many-public-methods
+class ClusterRole(Yedit):
+    ''' Class to model an openshift ClusterRole'''
+    rules_path = "rules"
+
+    def __init__(self, name=None, content=None):
+        ''' Constructor for clusterrole '''
+        if content is None:
+            content = ClusterRole.builder(name).yaml_dict
+
+        super(ClusterRole, self).__init__(content=content)
+
+        self.__rules = Rule.parse_rules(self.get(ClusterRole.rules_path)) or []
+
+    @property
+    def rules(self):
+        return self.__rules
+
+    @rules.setter
+    def rules(self, data):
+        self.__rules = data
+        self.put(ClusterRole.rules_path, self.__rules)
+
+    def rule_exists(self, inc_rule):
+        '''attempt to find the inc_rule in the rules list'''
+        for rule in self.rules:
+            if rule == inc_rule:
+                return True
+
+        return False
+
+    def compare(self, other, verbose=False):
+        '''compare function for clusterrole'''
+        for rule in other.rules:
+            if rule not in self.rules:
+                if verbose:
+                    print('Rule in other not found in self. [{}]'.format(rule))
+                return False
+
+        for rule in self.rules:
+            if rule not in other.rules:
+                if verbose:
+                    print('Rule in self not found in other. [{}]'.format(rule))
+                return False
+
+        return True
+
+    @staticmethod
+    def builder(name='default_clusterrole', rules=None):
+        '''return a clusterrole with name and/or rules'''
+        if rules is None:
+            rules = [{'apiGroups': [""],
+                      'attributeRestrictions': None,
+                      'verbs': [],
+                      'resources': []}]
+        content = {
+            'apiVersion': 'v1',
+            'kind': 'ClusterRole',
+            'metadata': {'name': '{}'.format(name)},
+            'rules': rules,
+        }
+
+        return ClusterRole(content=content)
+
diff --git a/roles/lib_openshift/src/lib/group.py b/roles/lib_openshift/src/lib/group.py
new file mode 100644
index 000000000..fac5fcbc2
--- /dev/null
+++ b/roles/lib_openshift/src/lib/group.py
@@ -0,0 +1,36 @@
+# pylint: skip-file
+# flake8: noqa
+
+
+class GroupConfig(object):
+    ''' Handle route options '''
+    # pylint: disable=too-many-arguments
+    def __init__(self,
+                 sname,
+                 namespace,
+                 kubeconfig):
+        ''' constructor for handling group options '''
+        self.kubeconfig = kubeconfig
+        self.name = sname
+        self.namespace = namespace
+        self.data = {}
+
+        self.create_dict()
+
+    def create_dict(self):
+        ''' return a service as a dict '''
+        self.data['apiVersion'] = 'v1'
+        self.data['kind'] = 'Group'
+        self.data['metadata'] = {}
+        self.data['metadata']['name'] = self.name
+        self.data['users'] = None
+
+
+# pylint: disable=too-many-instance-attributes
+class Group(Yedit):
+    ''' Class to wrap the oc command line tools '''
+    kind = 'group'
+
+    def __init__(self, content):
+        '''Group constructor'''
+        super(Group, self).__init__(content=content)
diff --git a/roles/lib_openshift/src/lib/pvc.py b/roles/lib_openshift/src/lib/pvc.py
new file mode 100644
index 000000000..929b50990
--- /dev/null
+++ b/roles/lib_openshift/src/lib/pvc.py
@@ -0,0 +1,167 @@
+# pylint: skip-file
+# flake8: noqa
+
+
+# pylint: disable=too-many-instance-attributes
+class PersistentVolumeClaimConfig(object):
+    ''' Handle pvc options '''
+    # pylint: disable=too-many-arguments
+    def __init__(self,
+                 sname,
+                 namespace,
+                 kubeconfig,
+                 access_modes=None,
+                 vol_capacity='1G'):
+        ''' constructor for handling pvc options '''
+        self.kubeconfig = kubeconfig
+        self.name = sname
+        self.namespace = namespace
+        self.access_modes = access_modes
+        self.vol_capacity = vol_capacity
+        self.data = {}
+
+        self.create_dict()
+
+    def create_dict(self):
+        ''' return a service as a dict '''
+        # version
+        self.data['apiVersion'] = 'v1'
+        # kind
+        self.data['kind'] = 'PersistentVolumeClaim'
+        # metadata
+        self.data['metadata'] = {}
+        self.data['metadata']['name'] = self.name
+        # spec
+        self.data['spec'] = {}
+        self.data['spec']['accessModes'] = ['ReadWriteOnce']
+        if self.access_modes:
+            self.data['spec']['accessModes'] = self.access_modes
+
+        # storage capacity
+        self.data['spec']['resources'] = {}
+        self.data['spec']['resources']['requests'] = {}
+        self.data['spec']['resources']['requests']['storage'] = self.vol_capacity
+
+
+# pylint: disable=too-many-instance-attributes,too-many-public-methods
+class PersistentVolumeClaim(Yedit):
+    ''' Class to wrap the oc command line tools '''
+    access_modes_path = "spec.accessModes"
+    volume_capacity_path = "spec.requests.storage"
+    volume_name_path = "spec.volumeName"
+    bound_path = "status.phase"
+    kind = 'PersistentVolumeClaim'
+
+    def __init__(self, content):
+        '''RoleBinding constructor'''
+        super(PersistentVolumeClaim, self).__init__(content=content)
+        self._access_modes = None
+        self._volume_capacity = None
+        self._volume_name = None
+
+    @property
+    def volume_name(self):
+        ''' volume_name property '''
+        if self._volume_name is None:
+            self._volume_name = self.get_volume_name()
+        return self._volume_name
+
+    @volume_name.setter
+    def volume_name(self, data):
+        ''' volume_name property setter'''
+        self._volume_name = data
+
+    @property
+    def access_modes(self):
+        ''' access_modes property '''
+        if self._access_modes is None:
+            self._access_modes = self.get_access_modes()
+            if not isinstance(self._access_modes, list):
+                self._access_modes = list(self._access_modes)
+
+        return self._access_modes
+
+    @access_modes.setter
+    def access_modes(self, data):
+        ''' access_modes property setter'''
+        if not isinstance(data, list):
+            data = list(data)
+
+        self._access_modes = data
+
+    @property
+    def volume_capacity(self):
+        ''' volume_capacity property '''
+        if self._volume_capacity is None:
+            self._volume_capacity = self.get_volume_capacity()
+        return self._volume_capacity
+
+    @volume_capacity.setter
+    def volume_capacity(self, data):
+        ''' volume_capacity property setter'''
+        self._volume_capacity = data
+
+    def get_access_modes(self):
+        '''get access_modes'''
+        return self.get(PersistentVolumeClaim.access_modes_path) or []
+
+    def get_volume_capacity(self):
+        '''get volume_capacity'''
+        return self.get(PersistentVolumeClaim.volume_capacity_path) or []
+
+    def get_volume_name(self):
+        '''get volume_name'''
+        return self.get(PersistentVolumeClaim.volume_name_path) or []
+
+    def is_bound(self):
+        '''return whether volume is bound'''
+        return self.get(PersistentVolumeClaim.bound_path) or []
+
+    #### ADD #####
+    def add_access_mode(self, inc_mode):
+        ''' add an access_mode'''
+        if self.access_modes:
+            self.access_modes.append(inc_mode)
+        else:
+            self.put(PersistentVolumeClaim.access_modes_path, [inc_mode])
+
+        return True
+
+    #### /ADD #####
+
+    #### Remove #####
+    def remove_access_mode(self, inc_mode):
+        ''' remove an access_mode'''
+        try:
+            self.access_modes.remove(inc_mode)
+        except ValueError as _:
+            return False
+
+        return True
+
+    #### /REMOVE #####
+
+    #### UPDATE #####
+    def update_access_mode(self, inc_mode):
+        ''' update an access_mode'''
+        try:
+            index = self.access_modes.index(inc_mode)
+        except ValueError as _:
+            return self.add_access_mode(inc_mode)
+
+        self.access_modes[index] = inc_mode
+
+        return True
+
+    #### /UPDATE #####
+
+    #### FIND ####
+    def find_access_mode(self, inc_mode):
+        ''' find a user '''
+        index = None
+        try:
+            index = self.access_modes.index(inc_mode)
+        except ValueError as _:
+            return index
+
+        return index
diff --git a/roles/lib_openshift/src/lib/rule.py b/roles/lib_openshift/src/lib/rule.py
new file mode 100644
index 000000000..4590dcf90
--- /dev/null
+++ b/roles/lib_openshift/src/lib/rule.py
@@ -0,0 +1,144 @@
+# pylint: skip-file
+# flake8: noqa
+
+
+class Rule(object):
+    '''class to represent a clusterrole rule
+
+    Example Rule Object's yaml:
+    - apiGroups:
+    - ""
+    attributeRestrictions: null
+    resources:
+    - persistentvolumes
+    verbs:
+    - create
+    - delete
+    - deletecollection
+    - get
+    - list
+    - patch
+    - update
+    - watch
+
+    '''
+    def __init__(self,
+                 api_groups=None,
+                 attr_restrictions=None,
+                 resources=None,
+                 verbs=None):
+        self.__api_groups = api_groups if api_groups is not None else [""]
+        self.__verbs = verbs if verbs is not None else []
+        self.__resources = resources if resources is not None else []
+        self.__attribute_restrictions = attr_restrictions if attr_restrictions is not None else None
+
+    @property
+    def verbs(self):
+        '''property for verbs'''
+        if self.__verbs is None:
+            return []
+
+        return self.__verbs
+
+    @verbs.setter
+    def verbs(self, data):
+        '''setter for verbs'''
+        self.__verbs = data
+
+    @property
+    def api_groups(self):
+        '''property for api_groups'''
+        if self.__api_groups is None:
+            return []
+        return self.__api_groups
+
+    @api_groups.setter
+    def api_groups(self, data):
+        '''setter for api_groups'''
+        self.__api_groups = data
+
+    @property
+    def resources(self):
+        '''property for resources'''
+        if self.__resources is None:
+            return []
+
+        return self.__resources
+
+    @resources.setter
+    def resources(self, data):
+        '''setter for resources'''
+        self.__resources = data
+
+    @property
+    def attribute_restrictions(self):
+        '''property for attribute_restrictions'''
+        return self.__attribute_restrictions
+
+    @attribute_restrictions.setter
+    def attribute_restrictions(self, data):
+        '''setter for attribute_restrictions'''
+        self.__attribute_restrictions = data
+
+    def add_verb(self, inc_verb):
+        '''add a verb to the verbs array'''
+        self.verbs.append(inc_verb)
+
+    def add_api_group(self, inc_apigroup):
+        '''add an api_group to the api_groups array'''
+        self.api_groups.append(inc_apigroup)
+
+    def add_resource(self, inc_resource):
+        '''add an resource to the resources array'''
+        self.resources.append(inc_resource)
+
+    def remove_verb(self, inc_verb):
+        '''add a verb to the verbs array'''
+        try:
+            self.verbs.remove(inc_verb)
+            return True
+        except ValueError:
+            pass
+
+        return False
+
+    def remove_api_group(self, inc_api_group):
+        '''add a verb to the verbs array'''
+        try:
+            self.api_groups.remove(inc_api_group)
+            return True
+        except ValueError:
+            pass
+
+        return False
+
+    def remove_resource(self, inc_resource):
+        '''add a verb to the verbs array'''
+        try:
+            self.resources.remove(inc_resource)
+            return True
+        except ValueError:
+            pass
+
+        return False
+
+    def __eq__(self, other):
+        '''return whether rules are equal'''
+        return (self.attribute_restrictions == other.attribute_restrictions and
+                self.api_groups == other.api_groups and
+                self.resources == other.resources and
+                self.verbs == other.verbs)
+
+
+    @staticmethod
+    def parse_rules(inc_rules):
+        '''create rules from an array'''
+
+        results = []
+        for rule in inc_rules:
+            results.append(Rule(rule['apiGroups'],
+                                rule['attributeRestrictions'],
+                                rule['resources'],
+                                rule['verbs']))
+
+        return results
diff --git a/roles/lib_openshift/src/lib/user.py b/roles/lib_openshift/src/lib/user.py
new file mode 100644
index 000000000..a14d5fc91
--- /dev/null
+++ b/roles/lib_openshift/src/lib/user.py
@@ -0,0 +1,37 @@
+# pylint: skip-file
+# flake8: noqa
+
+
+class UserConfig(object):
+    ''' Handle user options '''
+    def __init__(self,
+                 kubeconfig,
+                 username,
+                 full_name):
+        ''' constructor for handling user options '''
+        self.kubeconfig = kubeconfig
+        self.username = username
+        self.full_name = full_name
+
+        self.data = {}
+        self.create_dict()
+
+    def create_dict(self):
+        ''' return a user as a dict '''
+        self.data['apiVersion'] = 'v1'
+        self.data['fullName'] = self.full_name
+        self.data['groups'] = None
+        self.data['identities'] = None
+        self.data['kind'] = 'User'
+        self.data['metadata'] = {}
+        self.data['metadata']['name'] = self.username
+
+
+# pylint: disable=too-many-instance-attributes
+class User(Yedit):
+    ''' Class to wrap the oc command line tools '''
+    kind = 'user'
+
+    def __init__(self, content):
+        '''User constructor'''
+        super(User, self).__init__(content=content)
diff --git a/roles/lib_openshift/src/lib/volume.py b/roles/lib_openshift/src/lib/volume.py
index e0abb1d1b..c049c8b49 100644
--- a/roles/lib_openshift/src/lib/volume.py
+++ b/roles/lib_openshift/src/lib/volume.py
@@ -2,7 +2,7 @@
 # flake8: noqa
 
 class Volume(object):
-    ''' Class to model an openshift volume object'''
+    ''' Class to represent an openshift volume object'''
     volume_mounts_path = {"pod": "spec.containers[0].volumeMounts",
                           "dc":  "spec.template.spec.containers[0].volumeMounts",
                           "rc":  "spec.template.spec.containers[0].volumeMounts",
@@ -34,5 +34,10 @@ class Volume(object):
         elif volume_type == 'hostpath':
             volume['hostPath'] = {}
             volume['hostPath']['path'] = volume_info['path']
+        elif volume_type == 'configmap':
+            volume['configMap'] = {}
+            volume['configMap']['name'] = volume_info['configmap_name']
+            volume_mount = {'mountPath': volume_info['path'],
+                            'name': volume_info['name']}
 
         return (volume, volume_mount)