From 07331b47724dbb7cd6952c1a2af54275ace7726e Mon Sep 17 00:00:00 2001 From: Kenny Woodson Date: Fri, 13 Jan 2017 12:37:30 -0500 Subject: lib_openshift modules. This is the first one. oc_route. --- roles/lib_openshift/library/oc_route.py | 1518 ++++++++++++++++++++ roles/lib_openshift/src/ansible/oc_route.py | 82 ++ roles/lib_openshift/src/class/oc_route.py | 167 +++ roles/lib_openshift/src/doc/license | 16 + roles/lib_openshift/src/doc/route | 120 ++ roles/lib_openshift/src/generate.py | 45 + roles/lib_openshift/src/generate_sources.yml | 10 + roles/lib_openshift/src/lib/base.py | 458 ++++++ roles/lib_openshift/src/lib/import.py | 16 + roles/lib_openshift/src/lib/route.py | 101 ++ roles/lib_utils/library/yedit.py | 108 +- roles/lib_utils/src/ansible/yedit.py | 45 +- roles/lib_utils/src/class/yedit.py | 62 +- .../src/test/integration/kube-manager-test.yaml | 58 + .../test/integration/kube-manager-test.yaml.orig | 52 + 15 files changed, 2750 insertions(+), 108 deletions(-) create mode 100644 roles/lib_openshift/library/oc_route.py create mode 100644 roles/lib_openshift/src/ansible/oc_route.py create mode 100644 roles/lib_openshift/src/class/oc_route.py create mode 100644 roles/lib_openshift/src/doc/license create mode 100644 roles/lib_openshift/src/doc/route create mode 100755 roles/lib_openshift/src/generate.py create mode 100644 roles/lib_openshift/src/generate_sources.yml create mode 100644 roles/lib_openshift/src/lib/base.py create mode 100644 roles/lib_openshift/src/lib/import.py create mode 100644 roles/lib_openshift/src/lib/route.py create mode 100644 roles/lib_utils/src/test/integration/kube-manager-test.yaml create mode 100644 roles/lib_utils/src/test/integration/kube-manager-test.yaml.orig diff --git a/roles/lib_openshift/library/oc_route.py b/roles/lib_openshift/library/oc_route.py new file mode 100644 index 000000000..9efa6d0c7 --- /dev/null +++ b/roles/lib_openshift/library/oc_route.py @@ -0,0 +1,1518 @@ +#!/usr/bin/env python +# pylint: disable=missing-docstring +# ___ ___ _ _ ___ ___ _ _____ ___ ___ +# / __| __| \| | __| _ \ /_\_ _| __| \ +# | (_ | _|| .` | _|| / / _ \| | | _|| |) | +# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____ +# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _| +# | |) | (_) | | .` | (_) || | | _|| |) | | | | +# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_| +# +# Copyright 2016 Red Hat, Inc. and/or its affiliates +# and other contributors as indicated by the @author tags. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +''' + OpenShiftCLI class that wraps the oc commands in a subprocess +''' +# pylint: disable=too-many-lines + + +import atexit +import json +import os +import re +import ruamel.yaml as yaml +import shutil +import subprocess +from ansible.module_utils.basic import AnsibleModule + +DOCUMENTATION = ''' +--- +module: yedit +short_description: Create, modify, and idempotently manage yaml files. +description: + - Modify yaml files programmatically. +options: + state: + description: + - State represents whether to create, modify, delete, or list + required: true + default: present + choices: ["present", "absent", "list"] + aliases: [] + kubeconfig: + description: + - The path for the kubeconfig file to use for authentication + required: false + default: /etc/origin/master/admin.kubeconfig + aliases: [] + debug: + description: + - Turn on debug output. + required: false + default: False + aliases: [] + name: + description: + - Name of the object that is being queried. + required: false + default: None + aliases: [] + namespace: + description: + - The namespace where the object lives. + required: false + default: str + aliases: [] + tls_termination: + description: + - The options for termination. e.g. reencrypt + required: false + default: None + aliases: [] + dest_cacert_path: + description: + - The path to the dest_cacert + required: false + default: None + aliases: [] + cacert_path: + description: + - The path to the cacert + required: false + default: None + aliases: [] + cert_path: + description: + - The path to the cert + required: false + default: None + aliases: [] + key_path: + description: + - The path to the key + required: false + default: None + aliases: [] + dest_cacert_content: + description: + - The dest_cacert content + required: false + default: None + aliases: [] + cacert_content: + description: + - The cacert content + required: false + default: None + aliases: [] + cert_content: + description: + - The cert content + required: false + default: None + aliases: [] + service_name: + description: + - The name of the service that this route points to. + required: false + default: None + aliases: [] + host: + description: + - The host that the route will use. e.g. myapp.x.y.z + required: false + default: None + aliases: [] +author: +- "Kenny Woodson " +extends_documentation_fragment: [] +''' + +EXAMPLES = ''' +- name: Configure certificates for reencrypt route + oc_route: + name: myapproute + namespace: awesomeapp + cert_path: "/etc/origin/master/named_certificates/myapp_cert + key_path: "/etc/origin/master/named_certificates/myapp_key + cacert_path: "/etc/origin/master/named_certificates/myapp_cacert + dest_cacert_content: "{{ dest_cacert_content }}" + service_name: myapp_php + host: myapp.awesomeapp.openshift.com + tls_termination: reencrypt + run_once: true +''' +''' + OpenShiftCLI class that wraps the oc commands in a subprocess +''' +# pylint: disable=too-many-lines + + +class OpenShiftCLIError(Exception): + '''Exception class for openshiftcli''' + pass + + +# pylint: disable=too-few-public-methods +class OpenShiftCLI(object): + ''' Class to wrap the command line tools ''' + def __init__(self, + namespace, + kubeconfig='/etc/origin/master/admin.kubeconfig', + verbose=False, + all_namespaces=False): + ''' Constructor for OpenshiftCLI ''' + self.namespace = namespace + self.verbose = verbose + self.kubeconfig = kubeconfig + self.all_namespaces = all_namespaces + + # Pylint allows only 5 arguments to be passed. + # pylint: disable=too-many-arguments + def _replace_content(self, resource, rname, content, force=False, sep='.'): + ''' replace the current object with the content ''' + res = self._get(resource, rname) + if not res['results']: + return res + + fname = '/tmp/%s' % rname + yed = Yedit(fname, res['results'][0], separator=sep) + changes = [] + for key, value in content.items(): + changes.append(yed.put(key, value)) + + if any([change[0] for change in changes]): + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self._replace(fname, force) + + return {'returncode': 0, 'updated': False} + + def _replace(self, fname, force=False): + '''return all pods ''' + cmd = ['-n', self.namespace, 'replace', '-f', fname] + if force: + cmd.append('--force') + return self.openshift_cmd(cmd) + + def _create_from_content(self, rname, content): + '''return all pods ''' + fname = '/tmp/%s' % rname + yed = Yedit(fname, content=content) + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self._create(fname) + + def _create(self, fname): + '''return all pods ''' + return self.openshift_cmd(['create', '-f', fname, '-n', self.namespace]) + + def _delete(self, resource, rname, selector=None): + '''return all pods ''' + cmd = ['delete', resource, rname, '-n', self.namespace] + if selector: + cmd.append('--selector=%s' % selector) + + return self.openshift_cmd(cmd) + + def _process(self, template_name, create=False, params=None, template_data=None): # noqa: E501 + '''return all pods ''' + cmd = ['process', '-n', self.namespace] + if template_data: + cmd.extend(['-f', '-']) + else: + cmd.append(template_name) + if params: + param_str = ["%s=%s" % (key, value) for key, value in params.items()] + cmd.append('-v') + cmd.extend(param_str) + + results = self.openshift_cmd(cmd, output=True, input_data=template_data) + + if results['returncode'] != 0 or not create: + return results + + fname = '/tmp/%s' % template_name + yed = Yedit(fname, results['results']) + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self.openshift_cmd(['-n', self.namespace, 'create', '-f', fname]) + + def _get(self, resource, rname=None, selector=None): + '''return a resource by name ''' + cmd = ['get', resource] + if selector: + cmd.append('--selector=%s' % selector) + if self.all_namespaces: + cmd.extend(['--all-namespaces']) + elif self.namespace: + cmd.extend(['-n', self.namespace]) + + cmd.extend(['-o', 'json']) + + if rname: + cmd.append(rname) + + rval = self.openshift_cmd(cmd, output=True) + + # Ensure results are retuned in an array + if 'items' in rval: + rval['results'] = rval['items'] + elif not isinstance(rval['results'], list): + rval['results'] = [rval['results']] + + return rval + + def _schedulable(self, node=None, selector=None, schedulable=True): + ''' perform oadm manage-node scheduable ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + cmd.append('--schedulable=%s' % schedulable) + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') # noqa: E501 + + def _list_pods(self, node=None, selector=None, pod_selector=None): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) + + cmd.extend(['--list-pods', '-o', 'json']) + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + + # pylint: disable=too-many-arguments + def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + if dry_run: + cmd.append('--dry-run') + + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) + + if grace_period: + cmd.append('--grace-period=%s' % int(grace_period)) + + if force: + cmd.append('--force') + + cmd.append('--evacuate') + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + + def _import_image(self, url=None, name=None, tag=None): + ''' perform image import ''' + cmd = ['import-image'] + + image = '{0}'.format(name) + if tag: + image += ':{0}'.format(tag) + + cmd.append(image) + + if url: + cmd.append('--from={0}/{1}'.format(url, image)) + + cmd.append('-n{0}'.format(self.namespace)) + + cmd.append('--confirm') + return self.openshift_cmd(cmd) + + # pylint: disable=too-many-arguments + def openshift_cmd(self, cmd, oadm=False, output=False, output_type='json', input_data=None): + '''Base command for oc ''' + cmds = [] + if oadm: + cmds = ['/usr/bin/oadm'] + else: + cmds = ['/usr/bin/oc'] + + cmds.extend(cmd) + + rval = {} + results = '' + err = None + + if self.verbose: + print ' '.join(cmds) + + proc = subprocess.Popen(cmds, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env={'KUBECONFIG': self.kubeconfig}) + + stdout, stderr = proc.communicate(input_data) + rval = {"returncode": proc.returncode, + "results": results, + "cmd": ' '.join(cmds)} + + if proc.returncode == 0: + if output: + if output_type == 'json': + try: + rval['results'] = json.loads(stdout) + except ValueError as err: + if "No JSON object could be decoded" in err.message: + err = err.message + elif output_type == 'raw': + rval['results'] = stdout + + if self.verbose: + print stdout + print stderr + + if err: + rval.update({"err": err, + "stderr": stderr, + "stdout": stdout, + "cmd": cmds}) + + else: + rval.update({"stderr": stderr, + "stdout": stdout, + "results": {}}) + + return rval + + +class Utils(object): + ''' utilities for openshiftcli modules ''' + @staticmethod + def create_file(rname, data, ftype='yaml'): + ''' create a file in tmp with name and contents''' + path = os.path.join('/tmp', rname) + with open(path, 'w') as fds: + if ftype == 'yaml': + fds.write(yaml.dump(data, Dumper=yaml.RoundTripDumper)) + + elif ftype == 'json': + fds.write(json.dumps(data)) + else: + fds.write(data) + + # Register cleanup when module is done + atexit.register(Utils.cleanup, [path]) + return path + + @staticmethod + def create_files_from_contents(content, content_type=None): + '''Turn an array of dict: filename, content into a files array''' + if not isinstance(content, list): + content = [content] + files = [] + for item in content: + path = Utils.create_file(item['path'], item['data'], ftype=content_type) + files.append({'name': os.path.basename(path), 'path': path}) + return files + + @staticmethod + def cleanup(files): + '''Clean up on exit ''' + for sfile in files: + if os.path.exists(sfile): + if os.path.isdir(sfile): + shutil.rmtree(sfile) + elif os.path.isfile(sfile): + os.remove(sfile) + + @staticmethod + def exists(results, _name): + ''' Check to see if the results include the name ''' + if not results: + return False + + if Utils.find_result(results, _name): + return True + + return False + + @staticmethod + def find_result(results, _name): + ''' Find the specified result by name''' + rval = None + for result in results: + if 'metadata' in result and result['metadata']['name'] == _name: + rval = result + break + + return rval + + @staticmethod + def get_resource_file(sfile, sfile_type='yaml'): + ''' return the service file ''' + contents = None + with open(sfile) as sfd: + contents = sfd.read() + + if sfile_type == 'yaml': + contents = yaml.load(contents, yaml.RoundTripLoader) + elif sfile_type == 'json': + contents = json.loads(contents) + + return contents + + # Disabling too-many-branches. This is a yaml dictionary comparison function + # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements + @staticmethod + def check_def_equal(user_def, result_def, skip_keys=None, debug=False): + ''' Given a user defined definition, compare it with the results given back by our query. ''' + + # Currently these values are autogenerated and we do not need to check them + skip = ['metadata', 'status'] + if skip_keys: + skip.extend(skip_keys) + + for key, value in result_def.items(): + if key in skip: + continue + + # Both are lists + if isinstance(value, list): + if key not in user_def: + if debug: + print 'User data does not have key [%s]' % key + print 'User data: %s' % user_def + return False + + if not isinstance(user_def[key], list): + if debug: + print 'user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key]) + return False + + if len(user_def[key]) != len(value): + if debug: + print "List lengths are not equal." + print "key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value)) + print "user_def: %s" % user_def[key] + print "value: %s" % value + return False + + for values in zip(user_def[key], value): + if isinstance(values[0], dict) and isinstance(values[1], dict): + if debug: + print 'sending list - list' + print type(values[0]) + print type(values[1]) + result = Utils.check_def_equal(values[0], values[1], skip_keys=skip_keys, debug=debug) + if not result: + print 'list compare returned false' + return False + + elif value != user_def[key]: + if debug: + print 'value should be identical' + print value + print user_def[key] + return False + + # recurse on a dictionary + elif isinstance(value, dict): + if key not in user_def: + if debug: + print "user_def does not have key [%s]" % key + return False + if not isinstance(user_def[key], dict): + if debug: + print "dict returned false: not instance of dict" + return False + + # before passing ensure keys match + api_values = set(value.keys()) - set(skip) + user_values = set(user_def[key].keys()) - set(skip) + if api_values != user_values: + if debug: + print "keys are not equal in dict" + print api_values + print user_values + return False + + result = Utils.check_def_equal(user_def[key], value, skip_keys=skip_keys, debug=debug) + if not result: + if debug: + print "dict returned false" + print result + return False + + # Verify each key, value pair is the same + else: + if key not in user_def or value != user_def[key]: + if debug: + print "value not equal; user_def does not have key" + print key + print value + if key in user_def: + print user_def[key] + return False + + if debug: + print 'returning true' + return True + + +class OpenShiftCLIConfig(object): + '''Generic Config''' + def __init__(self, rname, namespace, kubeconfig, options): + self.kubeconfig = kubeconfig + self.name = rname + self.namespace = namespace + self._options = options + + @property + def config_options(self): + ''' return config options ''' + return self._options + + def to_option_list(self): + '''return all options as a string''' + return self.stringify() + + def stringify(self): + ''' return the options hash as cli params in a string ''' + rval = [] + for key, data in self.config_options.items(): + if data['include'] \ + and (data['value'] or isinstance(data['value'], int)): + rval.append('--%s=%s' % (key.replace('_', '-'), data['value'])) + + return rval + + +class YeditException(Exception): + ''' Exception class for Yedit ''' + pass + + +class Yedit(object): + ''' Class to modify yaml files ''' + re_valid_key = r"(((\[-?\d+\])|([0-9a-zA-Z%s/_-]+)).?)+$" + re_key = r"(?:\[(-?\d+)\])|([0-9a-zA-Z%s/_-]+)" + com_sep = set(['.', '#', '|', ':']) + + # pylint: disable=too-many-arguments + def __init__(self, + filename=None, + content=None, + content_type='yaml', + separator='.', + backup=False): + self.content = content + self._separator = separator + self.filename = filename + self.__yaml_dict = content + self.content_type = content_type + self.backup = backup + self.load(content_type=self.content_type) + if self.__yaml_dict is None: + self.__yaml_dict = {} + + @property + def separator(self): + ''' getter method for yaml_dict ''' + return self._separator + + @separator.setter + def separator(self): + ''' getter method for yaml_dict ''' + return self._separator + + @property + def yaml_dict(self): + ''' getter method for yaml_dict ''' + return self.__yaml_dict + + @yaml_dict.setter + def yaml_dict(self, value): + ''' setter method for yaml_dict ''' + self.__yaml_dict = value + + @staticmethod + def parse_key(key, sep='.'): + '''parse the key allowing the appropriate separator''' + common_separators = list(Yedit.com_sep - set([sep])) + return re.findall(Yedit.re_key % ''.join(common_separators), key) + + @staticmethod + def valid_key(key, sep='.'): + '''validate the incoming key''' + common_separators = list(Yedit.com_sep - set([sep])) + if not re.match(Yedit.re_valid_key % ''.join(common_separators), key): + return False + + return True + + @staticmethod + def remove_entry(data, key, sep='.'): + ''' remove data at location key ''' + if key == '' and isinstance(data, dict): + data.clear() + return True + elif key == '' and isinstance(data, list): + del data[:] + return True + + if not (key and Yedit.valid_key(key, sep)) and \ + isinstance(data, (list, dict)): + return None + + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes[:-1]: + if dict_key and isinstance(data, dict): + data = data.get(dict_key, None) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None + + # process last index for remove + # expected list entry + if key_indexes[-1][0]: + if isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 + del data[int(key_indexes[-1][0])] + return True + + # expected dict entry + elif key_indexes[-1][1]: + if isinstance(data, dict): + del data[key_indexes[-1][1]] + return True + + @staticmethod + def add_entry(data, key, item=None, sep='.'): + ''' Get an item from a dictionary with key notation a.b.c + d = {'a': {'b': 'c'}}} + key = a#b + return c + ''' + if key == '': + pass + elif (not (key and Yedit.valid_key(key, sep)) and + isinstance(data, (list, dict))): + return None + + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes[:-1]: + if dict_key: + if isinstance(data, dict) and dict_key in data and data[dict_key]: # noqa: E501 + data = data[dict_key] + continue + + elif data and not isinstance(data, dict): + return None + + data[dict_key] = {} + data = data[dict_key] + + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None + + if key == '': + data = item + + # process last index for add + # expected list entry + elif key_indexes[-1][0] and isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 + data[int(key_indexes[-1][0])] = item + + # expected dict entry + elif key_indexes[-1][1] and isinstance(data, dict): + data[key_indexes[-1][1]] = item + + return data + + @staticmethod + def get_entry(data, key, sep='.'): + ''' Get an item from a dictionary with key notation a.b.c + d = {'a': {'b': 'c'}}} + key = a.b + return c + ''' + if key == '': + pass + elif (not (key and Yedit.valid_key(key, sep)) and + isinstance(data, (list, dict))): + return None + + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes: + if dict_key and isinstance(data, dict): + data = data.get(dict_key, None) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None + + return data + + def write(self): + ''' write to file ''' + if not self.filename: + raise YeditException('Please specify a filename.') + + if self.backup and self.file_exists(): + shutil.copy(self.filename, self.filename + '.orig') + + tmp_filename = self.filename + '.yedit' + with open(tmp_filename, 'w') as yfd: + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + self.yaml_dict.fa.set_block_style() + + yfd.write(yaml.dump(self.yaml_dict, Dumper=yaml.RoundTripDumper)) + + os.rename(tmp_filename, self.filename) + + return (True, self.yaml_dict) + + def read(self): + ''' read from file ''' + # check if it exists + if self.filename is None or not self.file_exists(): + return None + + contents = None + with open(self.filename) as yfd: + contents = yfd.read() + + return contents + + def file_exists(self): + ''' return whether file exists ''' + if os.path.exists(self.filename): + return True + + return False + + def load(self, content_type='yaml'): + ''' return yaml file ''' + contents = self.read() + + if not contents and not self.content: + return None + + if self.content: + if isinstance(self.content, dict): + self.yaml_dict = self.content + return self.yaml_dict + elif isinstance(self.content, str): + contents = self.content + + # check if it is yaml + try: + if content_type == 'yaml' and contents: + self.yaml_dict = yaml.load(contents, yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + self.yaml_dict.fa.set_block_style() + elif content_type == 'json' and contents: + self.yaml_dict = json.loads(contents) + except yaml.YAMLError as err: + # Error loading yaml or json + raise YeditException('Problem with loading yaml file. %s' % err) + + return self.yaml_dict + + def get(self, key): + ''' get a specified key''' + try: + entry = Yedit.get_entry(self.yaml_dict, key, self.separator) + except KeyError: + entry = None + + return entry + + def pop(self, path, key_or_item): + ''' remove a key, value pair from a dict or an item for a list''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry is None: + return (False, self.yaml_dict) + + if isinstance(entry, dict): + # pylint: disable=no-member,maybe-no-member + if key_or_item in entry: + entry.pop(key_or_item) + return (True, self.yaml_dict) + return (False, self.yaml_dict) + + elif isinstance(entry, list): + # pylint: disable=no-member,maybe-no-member + ind = None + try: + ind = entry.index(key_or_item) + except ValueError: + return (False, self.yaml_dict) + + entry.pop(ind) + return (True, self.yaml_dict) + + return (False, self.yaml_dict) + + def delete(self, path): + ''' remove path from a dict''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry is None: + return (False, self.yaml_dict) + + result = Yedit.remove_entry(self.yaml_dict, path, self.separator) + if not result: + return (False, self.yaml_dict) + + return (True, self.yaml_dict) + + def exists(self, path, value): + ''' check if value exists at path''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if isinstance(entry, list): + if value in entry: + return True + return False + + elif isinstance(entry, dict): + if isinstance(value, dict): + rval = False + for key, val in value.items(): + if entry[key] != val: + rval = False + break + else: + rval = True + return rval + + return value in entry + + return entry == value + + def append(self, path, value): + '''append value to a list''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry is None: + self.put(path, []) + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + if not isinstance(entry, list): + return (False, self.yaml_dict) + + # pylint: disable=no-member,maybe-no-member + entry.append(value) + return (True, self.yaml_dict) + + # pylint: disable=too-many-arguments + def update(self, path, value, index=None, curr_value=None): + ''' put path, value into a dict ''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if isinstance(entry, dict): + # pylint: disable=no-member,maybe-no-member + if not isinstance(value, dict): + raise YeditException('Cannot replace key, value entry in ' + + 'dict with non-dict type. value=[%s] [%s]' % (value, type(value))) # noqa: E501 + + entry.update(value) + return (True, self.yaml_dict) + + elif isinstance(entry, list): + # pylint: disable=no-member,maybe-no-member + ind = None + if curr_value: + try: + ind = entry.index(curr_value) + except ValueError: + return (False, self.yaml_dict) + + elif index is not None: + ind = index + + if ind is not None and entry[ind] != value: + entry[ind] = value + return (True, self.yaml_dict) + + # see if it exists in the list + try: + ind = entry.index(value) + except ValueError: + # doesn't exist, append it + entry.append(value) + return (True, self.yaml_dict) + + # already exists, return + if ind is not None: + return (False, self.yaml_dict) + return (False, self.yaml_dict) + + def put(self, path, value): + ''' put path, value into a dict ''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry == value: + return (False, self.yaml_dict) + + # deepcopy didn't work + tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, + default_flow_style=False), + yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + tmp_copy.fa.set_block_style() + result = Yedit.add_entry(tmp_copy, path, value, self.separator) + if not result: + return (False, self.yaml_dict) + + self.yaml_dict = tmp_copy + + return (True, self.yaml_dict) + + def create(self, path, value): + ''' create a yaml file ''' + if not self.file_exists(): + # deepcopy didn't work + tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, default_flow_style=False), # noqa: E501 + yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + tmp_copy.fa.set_block_style() + result = Yedit.add_entry(tmp_copy, path, value, self.separator) + if result: + self.yaml_dict = tmp_copy + return (True, self.yaml_dict) + + return (False, self.yaml_dict) + + @staticmethod + def get_curr_value(invalue, val_type): + '''return the current value''' + if invalue is None: + return None + + curr_value = invalue + if val_type == 'yaml': + curr_value = yaml.load(invalue) + elif val_type == 'json': + curr_value = json.loads(invalue) + + return curr_value + + @staticmethod + def parse_value(inc_value, vtype=''): + '''determine value type passed''' + true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', + 'on', 'On', 'ON', ] + false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', + 'off', 'Off', 'OFF'] + + # It came in as a string but you didn't specify value_type as string + # we will convert to bool if it matches any of the above cases + if isinstance(inc_value, str) and 'bool' in vtype: + if inc_value not in true_bools and inc_value not in false_bools: + raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' + % (inc_value, vtype)) + elif isinstance(inc_value, bool) and 'str' in vtype: + inc_value = str(inc_value) + + # If vtype is not str then go ahead and attempt to yaml load it. + if isinstance(inc_value, str) and 'str' not in vtype: + try: + inc_value = yaml.load(inc_value) + except Exception: + raise YeditException('Could not determine type of incoming ' + + 'value. value=[%s] vtype=[%s]' + % (type(inc_value), vtype)) + + return inc_value + + # pylint: disable=too-many-return-statements,too-many-branches + @staticmethod + def run_ansible(module): + '''perform the idempotent crud operations''' + yamlfile = Yedit(filename=module.params['src'], + backup=module.params['backup'], + separator=module.params['separator']) + + if module.params['src']: + rval = yamlfile.load() + + if yamlfile.yaml_dict is None and \ + module.params['state'] != 'present': + return {'failed': True, + 'msg': 'Error opening file [%s]. Verify that the ' + + 'file exists, that it is has correct' + + ' permissions, and is valid yaml.'} + + if module.params['state'] == 'list': + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + yamlfile.yaml_dict = content + + if module.params['key']: + rval = yamlfile.get(module.params['key']) or {} + + return {'changed': False, 'result': rval, 'state': "list"} + + elif module.params['state'] == 'absent': + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + yamlfile.yaml_dict = content + + if module.params['update']: + rval = yamlfile.pop(module.params['key'], + module.params['value']) + else: + rval = yamlfile.delete(module.params['key']) + + if rval[0] and module.params['src']: + yamlfile.write() + + return {'changed': rval[0], 'result': rval[1], 'state': "absent"} + + elif module.params['state'] == 'present': + # check if content is different than what is in the file + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + + # We had no edits to make and the contents are the same + if yamlfile.yaml_dict == content and \ + module.params['value'] is None: + return {'changed': False, + 'result': yamlfile.yaml_dict, + 'state': "present"} + + yamlfile.yaml_dict = content + + # we were passed a value; parse it + if module.params['value']: + value = Yedit.parse_value(module.params['value'], + module.params['value_type']) + key = module.params['key'] + if module.params['update']: + # pylint: disable=line-too-long + curr_value = Yedit.get_curr_value(Yedit.parse_value(module.params['curr_value']), # noqa: E501 + module.params['curr_value_format']) # noqa: E501 + + rval = yamlfile.update(key, value, module.params['index'], curr_value) # noqa: E501 + + elif module.params['append']: + rval = yamlfile.append(key, value) + else: + rval = yamlfile.put(key, value) + + if rval[0] and module.params['src']: + yamlfile.write() + + return {'changed': rval[0], + 'result': rval[1], 'state': "present"} + + # no edits to make + if module.params['src']: + # pylint: disable=redefined-variable-type + rval = yamlfile.write() + return {'changed': rval[0], + 'result': rval[1], + 'state': "present"} + + return {'failed': True, 'msg': 'Unkown state passed'} + + +# pylint: disable=too-many-instance-attributes +class RouteConfig(object): + ''' Handle route options ''' + # pylint: disable=too-many-arguments + def __init__(self, + sname, + namespace, + kubeconfig, + destcacert=None, + cacert=None, + cert=None, + key=None, + host=None, + tls_termination=None, + service_name=None): + ''' constructor for handling route options ''' + self.kubeconfig = kubeconfig + self.name = sname + self.namespace = namespace + self.host = host + self.tls_termination = tls_termination + self.destcacert = destcacert + self.cacert = cacert + self.cert = cert + self.key = key + self.service_name = service_name + self.data = {} + + self.create_dict() + + def create_dict(self): + ''' return a service as a dict ''' + self.data['apiVersion'] = 'v1' + self.data['kind'] = 'Route' + self.data['metadata'] = {} + self.data['metadata']['name'] = self.name + self.data['metadata']['namespace'] = self.namespace + self.data['spec'] = {} + + self.data['spec']['host'] = self.host + + if self.tls_termination: + self.data['spec']['tls'] = {} + + if self.tls_termination == 'reencrypt': + self.data['spec']['tls']['destinationCACertificate'] = self.destcacert + self.data['spec']['tls']['key'] = self.key + self.data['spec']['tls']['caCertificate'] = self.cacert + self.data['spec']['tls']['certificate'] = self.cert + self.data['spec']['tls']['termination'] = self.tls_termination + + self.data['spec']['to'] = {'kind': 'Service', 'name': self.service_name} + + +# pylint: disable=too-many-instance-attributes,too-many-public-methods +class Route(Yedit): + ''' Class to wrap the oc command line tools ''' + host_path = "spec.host" + service_path = "spec.to.name" + cert_path = "spec.tls.certificate" + cacert_path = "spec.tls.caCertificate" + destcacert_path = "spec.tls.destinationCACertificate" + termination_path = "spec.tls.termination" + key_path = "spec.tls.key" + kind = 'route' + + def __init__(self, content): + '''Route constructor''' + super(Route, self).__init__(content=content) + + def get_destcacert(self): + ''' return cert ''' + return self.get(Route.destcacert_path) + + def get_cert(self): + ''' return cert ''' + return self.get(Route.cert_path) + + def get_key(self): + ''' return key ''' + return self.get(Route.key_path) + + def get_cacert(self): + ''' return cacert ''' + return self.get(Route.cacert_path) + + def get_service(self): + ''' return service name ''' + return self.get(Route.service_path) + + def get_termination(self): + ''' return tls termination''' + return self.get(Route.termination_path) + + def get_host(self): + ''' return host ''' + return self.get(Route.host_path) + + +# pylint: disable=too-many-instance-attributes +class OCRoute(OpenShiftCLI): + ''' Class to wrap the oc command line tools ''' + kind = 'route' + + def __init__(self, + config, + verbose=False): + ''' Constructor for OCVolume ''' + super(OCRoute, self).__init__(config.namespace, config.kubeconfig) + self.config = config + self.namespace = config.namespace + self._route = None + + @property + def route(self): + ''' property function for route''' + if not self._route: + self.get() + return self._route + + @route.setter + def route(self, data): + ''' setter function for route ''' + self._route = data + + def exists(self): + ''' return whether a route exists ''' + if self.route: + return True + + return False + + def get(self): + '''return route information ''' + result = self._get(self.kind, self.config.name) + if result['returncode'] == 0: + self.route = Route(content=result['results'][0]) + elif 'routes \"%s\" not found' % self.config.name in result['stderr']: + result['returncode'] = 0 + result['results'] = [{}] + + return result + + def delete(self): + '''delete the object''' + return self._delete(self.kind, self.config.name) + + def create(self): + '''create the object''' + return self._create_from_content(self.config.name, self.config.data) + + def update(self): + '''update the object''' + # need to update the tls information and the service name + return self._replace_content(self.kind, self.config.name, self.config.data) + + def needs_update(self): + ''' verify an update is needed ''' + skip = [] + return not Utils.check_def_equal(self.config.data, self.route.yaml_dict, skip_keys=skip, debug=True) + + @staticmethod + def run_ansible(params, files, check_mode=False): + ''' run the idempotent asnible code + + params comes from the ansible portion for this module + files: a dictionary for the certificates + {'cert': {'path': '', + 'content': '', + 'value': '' + } + } + check_mode: does the module support check mode. (module.check_mode) + ''' + + rconfig = RouteConfig(params['name'], + params['namespace'], + params['kubeconfig'], + files['destcacert']['value'], + files['cacert']['value'], + files['cert']['value'], + files['key']['value'], + params['host'], + params['tls_termination'], + params['service_name']) + + oc_route = OCRoute(rconfig, verbose=params['debug']) + + state = params['state'] + + api_rval = oc_route.get() + + ##### + # Get + ##### + if state == 'list': + return {'changed': False, + 'results': api_rval['results'], + 'state': 'list'} + + ######## + # Delete + ######## + if state == 'absent': + if oc_route.exists(): + + if check_mode: + return {'changed': False, 'msg': 'CHECK_MODE: Would have performed a delete.'} # noqa: E501 + + api_rval = oc_route.delete() + + return {'changed': True, 'results': api_rval, 'state': "absent"} # noqa: E501 + return {'changed': False, 'state': 'absent'} + + if state == 'present': + ######## + # Create + ######## + if not oc_route.exists(): + + if check_mode: + return {'changed': True, 'msg': 'CHECK_MODE: Would have performed a create.'} # noqa: E501 + + # Create it here + api_rval = oc_route.create() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + # return the created object + api_rval = oc_route.get() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + return {'changed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + ######## + # Update + ######## + if oc_route.needs_update(): + + if check_mode: + return {'changed': True, 'msg': 'CHECK_MODE: Would have performed an update.'} # noqa: E501 + + api_rval = oc_route.update() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + # return the created object + api_rval = oc_route.get() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + return {'changed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + return {'changed': False, 'results': api_rval, 'state': "present"} + + # catch all + return {'failed': True, 'msg': "Unknown State passed"} + + +def get_cert_data(path, content): + '''get the data for a particular value''' + if not path and not content: + return None + + rval = None + if path and os.path.exists(path) and os.access(path, os.R_OK): + rval = open(path).read() + elif content: + rval = content + + return rval + + +# pylint: disable=too-many-branches +def main(): + ''' + ansible oc module for route + ''' + module = AnsibleModule( + argument_spec=dict( + kubeconfig=dict(default='/etc/origin/master/admin.kubeconfig', type='str'), + state=dict(default='present', type='str', + choices=['present', 'absent', 'list']), + debug=dict(default=False, type='bool'), + name=dict(default=None, required=True, type='str'), + namespace=dict(default=None, required=True, type='str'), + tls_termination=dict(default=None, type='str'), + dest_cacert_path=dict(default=None, type='str'), + cacert_path=dict(default=None, type='str'), + cert_path=dict(default=None, type='str'), + key_path=dict(default=None, type='str'), + dest_cacert_content=dict(default=None, type='str'), + cacert_content=dict(default=None, type='str'), + cert_content=dict(default=None, type='str'), + key_content=dict(default=None, type='str'), + service_name=dict(default=None, type='str'), + host=dict(default=None, type='str'), + ), + mutually_exclusive=[('dest_cacert_path', 'dest_cacert_content'), + ('cacert_path', 'cacert_content'), + ('cert_path', 'cert_content'), + ('key_path', 'key_content'), ], + supports_check_mode=True, + ) + files = {'destcacert': {'path': module.params['dest_cacert_path'], + 'content': module.params['dest_cacert_content'], + 'value': None, }, + 'cacert': {'path': module.params['cacert_path'], + 'content': module.params['cacert_content'], + 'value': None, }, + 'cert': {'path': module.params['cert_path'], + 'content': module.params['cert_content'], + 'value': None, }, + 'key': {'path': module.params['key_path'], + 'content': module.params['key_content'], + 'value': None, }, } + + if module.params['tls_termination']: + for key, option in files.items(): + if key == 'destcacert' and module.params['tls_termination'] != 'reencrypt': + continue + + option['value'] = get_cert_data(option['path'], option['content']) + + if not option['value']: + module.fail_json(msg='Verify that you pass a value for %s' % key) + + results = OCRoute.run_ansible(module.params, files, module.check_mode) + + if 'failed' in results: + module.fail_json(**results) + + module.exit_json(**results) + + +if __name__ == '__main__': + main() diff --git a/roles/lib_openshift/src/ansible/oc_route.py b/roles/lib_openshift/src/ansible/oc_route.py new file mode 100644 index 000000000..3dcae052c --- /dev/null +++ b/roles/lib_openshift/src/ansible/oc_route.py @@ -0,0 +1,82 @@ +# pylint: skip-file +# flake8: noqa + + +def get_cert_data(path, content): + '''get the data for a particular value''' + if not path and not content: + return None + + rval = None + if path and os.path.exists(path) and os.access(path, os.R_OK): + rval = open(path).read() + elif content: + rval = content + + return rval + + +# pylint: disable=too-many-branches +def main(): + ''' + ansible oc module for route + ''' + module = AnsibleModule( + argument_spec=dict( + kubeconfig=dict(default='/etc/origin/master/admin.kubeconfig', type='str'), + state=dict(default='present', type='str', + choices=['present', 'absent', 'list']), + debug=dict(default=False, type='bool'), + name=dict(default=None, required=True, type='str'), + namespace=dict(default=None, required=True, type='str'), + tls_termination=dict(default=None, type='str'), + dest_cacert_path=dict(default=None, type='str'), + cacert_path=dict(default=None, type='str'), + cert_path=dict(default=None, type='str'), + key_path=dict(default=None, type='str'), + dest_cacert_content=dict(default=None, type='str'), + cacert_content=dict(default=None, type='str'), + cert_content=dict(default=None, type='str'), + key_content=dict(default=None, type='str'), + service_name=dict(default=None, type='str'), + host=dict(default=None, type='str'), + ), + mutually_exclusive=[('dest_cacert_path', 'dest_cacert_content'), + ('cacert_path', 'cacert_content'), + ('cert_path', 'cert_content'), + ('key_path', 'key_content'), ], + supports_check_mode=True, + ) + files = {'destcacert': {'path': module.params['dest_cacert_path'], + 'content': module.params['dest_cacert_content'], + 'value': None, }, + 'cacert': {'path': module.params['cacert_path'], + 'content': module.params['cacert_content'], + 'value': None, }, + 'cert': {'path': module.params['cert_path'], + 'content': module.params['cert_content'], + 'value': None, }, + 'key': {'path': module.params['key_path'], + 'content': module.params['key_content'], + 'value': None, }, } + + if module.params['tls_termination']: + for key, option in files.items(): + if key == 'destcacert' and module.params['tls_termination'] != 'reencrypt': + continue + + option['value'] = get_cert_data(option['path'], option['content']) + + if not option['value']: + module.fail_json(msg='Verify that you pass a value for %s' % key) + + results = OCRoute.run_ansible(module.params, files, module.check_mode) + + if 'failed' in results: + module.fail_json(**results) + + module.exit_json(**results) + + +if __name__ == '__main__': + main() diff --git a/roles/lib_openshift/src/class/oc_route.py b/roles/lib_openshift/src/class/oc_route.py new file mode 100644 index 000000000..f0cfa5820 --- /dev/null +++ b/roles/lib_openshift/src/class/oc_route.py @@ -0,0 +1,167 @@ +# pylint: skip-file +# flake8: noqa + + +# pylint: disable=too-many-instance-attributes +class OCRoute(OpenShiftCLI): + ''' Class to wrap the oc command line tools ''' + kind = 'route' + + def __init__(self, + config, + verbose=False): + ''' Constructor for OCVolume ''' + super(OCRoute, self).__init__(config.namespace, config.kubeconfig) + self.config = config + self.namespace = config.namespace + self._route = None + + @property + def route(self): + ''' property function for route''' + if not self._route: + self.get() + return self._route + + @route.setter + def route(self, data): + ''' setter function for route ''' + self._route = data + + def exists(self): + ''' return whether a route exists ''' + if self.route: + return True + + return False + + def get(self): + '''return route information ''' + result = self._get(self.kind, self.config.name) + if result['returncode'] == 0: + self.route = Route(content=result['results'][0]) + elif 'routes \"%s\" not found' % self.config.name in result['stderr']: + result['returncode'] = 0 + result['results'] = [{}] + + return result + + def delete(self): + '''delete the object''' + return self._delete(self.kind, self.config.name) + + def create(self): + '''create the object''' + return self._create_from_content(self.config.name, self.config.data) + + def update(self): + '''update the object''' + # need to update the tls information and the service name + return self._replace_content(self.kind, self.config.name, self.config.data) + + def needs_update(self): + ''' verify an update is needed ''' + skip = [] + return not Utils.check_def_equal(self.config.data, self.route.yaml_dict, skip_keys=skip, debug=True) + + @staticmethod + def run_ansible(params, files, check_mode=False): + ''' run the idempotent asnible code + + params comes from the ansible portion for this module + files: a dictionary for the certificates + {'cert': {'path': '', + 'content': '', + 'value': '' + } + } + check_mode: does the module support check mode. (module.check_mode) + ''' + + rconfig = RouteConfig(params['name'], + params['namespace'], + params['kubeconfig'], + files['destcacert']['value'], + files['cacert']['value'], + files['cert']['value'], + files['key']['value'], + params['host'], + params['tls_termination'], + params['service_name']) + + oc_route = OCRoute(rconfig, verbose=params['debug']) + + state = params['state'] + + api_rval = oc_route.get() + + ##### + # Get + ##### + if state == 'list': + return {'changed': False, + 'results': api_rval['results'], + 'state': 'list'} + + ######## + # Delete + ######## + if state == 'absent': + if oc_route.exists(): + + if check_mode: + return {'changed': False, 'msg': 'CHECK_MODE: Would have performed a delete.'} # noqa: E501 + + api_rval = oc_route.delete() + + return {'changed': True, 'results': api_rval, 'state': "absent"} # noqa: E501 + return {'changed': False, 'state': 'absent'} + + if state == 'present': + ######## + # Create + ######## + if not oc_route.exists(): + + if check_mode: + return {'changed': True, 'msg': 'CHECK_MODE: Would have performed a create.'} # noqa: E501 + + # Create it here + api_rval = oc_route.create() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + # return the created object + api_rval = oc_route.get() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + return {'changed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + ######## + # Update + ######## + if oc_route.needs_update(): + + if check_mode: + return {'changed': True, 'msg': 'CHECK_MODE: Would have performed an update.'} # noqa: E501 + + api_rval = oc_route.update() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + # return the created object + api_rval = oc_route.get() + + if api_rval['returncode'] != 0: + return {'failed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + return {'changed': True, 'results': api_rval, 'state': "present"} # noqa: E501 + + return {'changed': False, 'results': api_rval, 'state': "present"} + + # catch all + return {'failed': True, 'msg': "Unknown State passed"} diff --git a/roles/lib_openshift/src/doc/license b/roles/lib_openshift/src/doc/license new file mode 100644 index 000000000..717bb7f17 --- /dev/null +++ b/roles/lib_openshift/src/doc/license @@ -0,0 +1,16 @@ +# +# Copyright 2016 Red Hat, Inc. and/or its affiliates +# and other contributors as indicated by the @author tags. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# diff --git a/roles/lib_openshift/src/doc/route b/roles/lib_openshift/src/doc/route new file mode 100644 index 000000000..256f6b8f3 --- /dev/null +++ b/roles/lib_openshift/src/doc/route @@ -0,0 +1,120 @@ +# flake8: noqa +# pylint: skip-file + +DOCUMENTATION = ''' +--- +module: yedit +short_description: Create, modify, and idempotently manage yaml files. +description: + - Modify yaml files programmatically. +options: + state: + description: + - State represents whether to create, modify, delete, or list + required: true + default: present + choices: ["present", "absent", "list"] + aliases: [] + kubeconfig: + description: + - The path for the kubeconfig file to use for authentication + required: false + default: /etc/origin/master/admin.kubeconfig + aliases: [] + debug: + description: + - Turn on debug output. + required: false + default: False + aliases: [] + name: + description: + - Name of the object that is being queried. + required: false + default: None + aliases: [] + namespace: + description: + - The namespace where the object lives. + required: false + default: str + aliases: [] + tls_termination: + description: + - The options for termination. e.g. reencrypt + required: false + default: None + aliases: [] + dest_cacert_path: + description: + - The path to the dest_cacert + required: false + default: None + aliases: [] + cacert_path: + description: + - The path to the cacert + required: false + default: None + aliases: [] + cert_path: + description: + - The path to the cert + required: false + default: None + aliases: [] + key_path: + description: + - The path to the key + required: false + default: None + aliases: [] + dest_cacert_content: + description: + - The dest_cacert content + required: false + default: None + aliases: [] + cacert_content: + description: + - The cacert content + required: false + default: None + aliases: [] + cert_content: + description: + - The cert content + required: false + default: None + aliases: [] + service_name: + description: + - The name of the service that this route points to. + required: false + default: None + aliases: [] + host: + description: + - The host that the route will use. e.g. myapp.x.y.z + required: false + default: None + aliases: [] +author: +- "Kenny Woodson " +extends_documentation_fragment: [] +''' + +EXAMPLES = ''' +- name: Configure certificates for reencrypt route + oc_route: + name: myapproute + namespace: awesomeapp + cert_path: "/etc/origin/master/named_certificates/myapp_cert + key_path: "/etc/origin/master/named_certificates/myapp_key + cacert_path: "/etc/origin/master/named_certificates/myapp_cacert + dest_cacert_content: "{{ dest_cacert_content }}" + service_name: myapp_php + host: myapp.awesomeapp.openshift.com + tls_termination: reencrypt + run_once: true +''' diff --git a/roles/lib_openshift/src/generate.py b/roles/lib_openshift/src/generate.py new file mode 100755 index 000000000..f4b46aa91 --- /dev/null +++ b/roles/lib_openshift/src/generate.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python +''' + Generate the openshift-ansible/roles/lib_openshift_cli/library/ modules. +''' + +import os +import yaml + +# pylint: disable=anomalous-backslash-in-string +GEN_STR = "#!/usr/bin/env python\n" + \ + "# pylint: disable=missing-docstring\n" + \ + "# ___ ___ _ _ ___ ___ _ _____ ___ ___\n" + \ + "# / __| __| \| | __| _ \ /_\_ _| __| \\\n" + \ + "# | (_ | _|| .` | _|| / / _ \| | | _|| |) |\n" + \ + "# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____\n" + \ + "# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _|\n" + \ + "# | |) | (_) | | .` | (_) || | | _|| |) | | | |\n" + \ + "# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_|\n" + +OPENSHIFT_ANSIBLE_PATH = os.path.dirname(os.path.realpath(__file__)) +OPENSHIFT_ANSIBLE_SOURCES_PATH = os.path.join(OPENSHIFT_ANSIBLE_PATH, 'generate_sources.yml') # noqa: E501 + + +def main(): + ''' combine the necessary files to create the ansible module ''' + + library = os.path.join(OPENSHIFT_ANSIBLE_PATH, '..', 'library/') + sources = yaml.load(open(OPENSHIFT_ANSIBLE_SOURCES_PATH).read()) + for fname, parts in sources.items(): + with open(os.path.join(library, fname), 'w') as afd: + afd.seek(0) + afd.write(GEN_STR) + for fpart in parts: + with open(os.path.join(OPENSHIFT_ANSIBLE_PATH, fpart)) as pfd: + # first line is pylint disable so skip it + for idx, line in enumerate(pfd): + if idx in [0, 1] and 'flake8: noqa' in line \ + or 'pylint: skip-file' in line: + continue + + afd.write(line) + + +if __name__ == '__main__': + main() diff --git a/roles/lib_openshift/src/generate_sources.yml b/roles/lib_openshift/src/generate_sources.yml new file mode 100644 index 000000000..d8fcc6141 --- /dev/null +++ b/roles/lib_openshift/src/generate_sources.yml @@ -0,0 +1,10 @@ +--- +oc_route.py: +- doc/license +- lib/import.py +- doc/route +- lib/base.py +- ../../lib_utils/src/class/yedit.py +- lib/route.py +- class/oc_route.py +- ansible/oc_route.py diff --git a/roles/lib_openshift/src/lib/base.py b/roles/lib_openshift/src/lib/base.py new file mode 100644 index 000000000..9830150be --- /dev/null +++ b/roles/lib_openshift/src/lib/base.py @@ -0,0 +1,458 @@ +# pylint: skip-file +# flake8: noqa +''' + OpenShiftCLI class that wraps the oc commands in a subprocess +''' +# pylint: disable=too-many-lines + + +class OpenShiftCLIError(Exception): + '''Exception class for openshiftcli''' + pass + + +# pylint: disable=too-few-public-methods +class OpenShiftCLI(object): + ''' Class to wrap the command line tools ''' + def __init__(self, + namespace, + kubeconfig='/etc/origin/master/admin.kubeconfig', + verbose=False, + all_namespaces=False): + ''' Constructor for OpenshiftCLI ''' + self.namespace = namespace + self.verbose = verbose + self.kubeconfig = kubeconfig + self.all_namespaces = all_namespaces + + # Pylint allows only 5 arguments to be passed. + # pylint: disable=too-many-arguments + def _replace_content(self, resource, rname, content, force=False, sep='.'): + ''' replace the current object with the content ''' + res = self._get(resource, rname) + if not res['results']: + return res + + fname = '/tmp/%s' % rname + yed = Yedit(fname, res['results'][0], separator=sep) + changes = [] + for key, value in content.items(): + changes.append(yed.put(key, value)) + + if any([change[0] for change in changes]): + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self._replace(fname, force) + + return {'returncode': 0, 'updated': False} + + def _replace(self, fname, force=False): + '''return all pods ''' + cmd = ['-n', self.namespace, 'replace', '-f', fname] + if force: + cmd.append('--force') + return self.openshift_cmd(cmd) + + def _create_from_content(self, rname, content): + '''return all pods ''' + fname = '/tmp/%s' % rname + yed = Yedit(fname, content=content) + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self._create(fname) + + def _create(self, fname): + '''return all pods ''' + return self.openshift_cmd(['create', '-f', fname, '-n', self.namespace]) + + def _delete(self, resource, rname, selector=None): + '''return all pods ''' + cmd = ['delete', resource, rname, '-n', self.namespace] + if selector: + cmd.append('--selector=%s' % selector) + + return self.openshift_cmd(cmd) + + def _process(self, template_name, create=False, params=None, template_data=None): # noqa: E501 + '''return all pods ''' + cmd = ['process', '-n', self.namespace] + if template_data: + cmd.extend(['-f', '-']) + else: + cmd.append(template_name) + if params: + param_str = ["%s=%s" % (key, value) for key, value in params.items()] + cmd.append('-v') + cmd.extend(param_str) + + results = self.openshift_cmd(cmd, output=True, input_data=template_data) + + if results['returncode'] != 0 or not create: + return results + + fname = '/tmp/%s' % template_name + yed = Yedit(fname, results['results']) + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self.openshift_cmd(['-n', self.namespace, 'create', '-f', fname]) + + def _get(self, resource, rname=None, selector=None): + '''return a resource by name ''' + cmd = ['get', resource] + if selector: + cmd.append('--selector=%s' % selector) + if self.all_namespaces: + cmd.extend(['--all-namespaces']) + elif self.namespace: + cmd.extend(['-n', self.namespace]) + + cmd.extend(['-o', 'json']) + + if rname: + cmd.append(rname) + + rval = self.openshift_cmd(cmd, output=True) + + # Ensure results are retuned in an array + if 'items' in rval: + rval['results'] = rval['items'] + elif not isinstance(rval['results'], list): + rval['results'] = [rval['results']] + + return rval + + def _schedulable(self, node=None, selector=None, schedulable=True): + ''' perform oadm manage-node scheduable ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + cmd.append('--schedulable=%s' % schedulable) + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') # noqa: E501 + + def _list_pods(self, node=None, selector=None, pod_selector=None): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) + + cmd.extend(['--list-pods', '-o', 'json']) + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + + # pylint: disable=too-many-arguments + def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + if dry_run: + cmd.append('--dry-run') + + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) + + if grace_period: + cmd.append('--grace-period=%s' % int(grace_period)) + + if force: + cmd.append('--force') + + cmd.append('--evacuate') + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + + def _import_image(self, url=None, name=None, tag=None): + ''' perform image import ''' + cmd = ['import-image'] + + image = '{0}'.format(name) + if tag: + image += ':{0}'.format(tag) + + cmd.append(image) + + if url: + cmd.append('--from={0}/{1}'.format(url, image)) + + cmd.append('-n{0}'.format(self.namespace)) + + cmd.append('--confirm') + return self.openshift_cmd(cmd) + + # pylint: disable=too-many-arguments + def openshift_cmd(self, cmd, oadm=False, output=False, output_type='json', input_data=None): + '''Base command for oc ''' + cmds = [] + if oadm: + cmds = ['/usr/bin/oadm'] + else: + cmds = ['/usr/bin/oc'] + + cmds.extend(cmd) + + rval = {} + results = '' + err = None + + if self.verbose: + print ' '.join(cmds) + + proc = subprocess.Popen(cmds, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env={'KUBECONFIG': self.kubeconfig}) + + stdout, stderr = proc.communicate(input_data) + rval = {"returncode": proc.returncode, + "results": results, + "cmd": ' '.join(cmds)} + + if proc.returncode == 0: + if output: + if output_type == 'json': + try: + rval['results'] = json.loads(stdout) + except ValueError as err: + if "No JSON object could be decoded" in err.message: + err = err.message + elif output_type == 'raw': + rval['results'] = stdout + + if self.verbose: + print stdout + print stderr + + if err: + rval.update({"err": err, + "stderr": stderr, + "stdout": stdout, + "cmd": cmds}) + + else: + rval.update({"stderr": stderr, + "stdout": stdout, + "results": {}}) + + return rval + + +class Utils(object): + ''' utilities for openshiftcli modules ''' + @staticmethod + def create_file(rname, data, ftype='yaml'): + ''' create a file in tmp with name and contents''' + path = os.path.join('/tmp', rname) + with open(path, 'w') as fds: + if ftype == 'yaml': + fds.write(yaml.dump(data, Dumper=yaml.RoundTripDumper)) + + elif ftype == 'json': + fds.write(json.dumps(data)) + else: + fds.write(data) + + # Register cleanup when module is done + atexit.register(Utils.cleanup, [path]) + return path + + @staticmethod + def create_files_from_contents(content, content_type=None): + '''Turn an array of dict: filename, content into a files array''' + if not isinstance(content, list): + content = [content] + files = [] + for item in content: + path = Utils.create_file(item['path'], item['data'], ftype=content_type) + files.append({'name': os.path.basename(path), 'path': path}) + return files + + @staticmethod + def cleanup(files): + '''Clean up on exit ''' + for sfile in files: + if os.path.exists(sfile): + if os.path.isdir(sfile): + shutil.rmtree(sfile) + elif os.path.isfile(sfile): + os.remove(sfile) + + @staticmethod + def exists(results, _name): + ''' Check to see if the results include the name ''' + if not results: + return False + + if Utils.find_result(results, _name): + return True + + return False + + @staticmethod + def find_result(results, _name): + ''' Find the specified result by name''' + rval = None + for result in results: + if 'metadata' in result and result['metadata']['name'] == _name: + rval = result + break + + return rval + + @staticmethod + def get_resource_file(sfile, sfile_type='yaml'): + ''' return the service file ''' + contents = None + with open(sfile) as sfd: + contents = sfd.read() + + if sfile_type == 'yaml': + contents = yaml.load(contents, yaml.RoundTripLoader) + elif sfile_type == 'json': + contents = json.loads(contents) + + return contents + + # Disabling too-many-branches. This is a yaml dictionary comparison function + # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements + @staticmethod + def check_def_equal(user_def, result_def, skip_keys=None, debug=False): + ''' Given a user defined definition, compare it with the results given back by our query. ''' + + # Currently these values are autogenerated and we do not need to check them + skip = ['metadata', 'status'] + if skip_keys: + skip.extend(skip_keys) + + for key, value in result_def.items(): + if key in skip: + continue + + # Both are lists + if isinstance(value, list): + if key not in user_def: + if debug: + print 'User data does not have key [%s]' % key + print 'User data: %s' % user_def + return False + + if not isinstance(user_def[key], list): + if debug: + print 'user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key]) + return False + + if len(user_def[key]) != len(value): + if debug: + print "List lengths are not equal." + print "key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value)) + print "user_def: %s" % user_def[key] + print "value: %s" % value + return False + + for values in zip(user_def[key], value): + if isinstance(values[0], dict) and isinstance(values[1], dict): + if debug: + print 'sending list - list' + print type(values[0]) + print type(values[1]) + result = Utils.check_def_equal(values[0], values[1], skip_keys=skip_keys, debug=debug) + if not result: + print 'list compare returned false' + return False + + elif value != user_def[key]: + if debug: + print 'value should be identical' + print value + print user_def[key] + return False + + # recurse on a dictionary + elif isinstance(value, dict): + if key not in user_def: + if debug: + print "user_def does not have key [%s]" % key + return False + if not isinstance(user_def[key], dict): + if debug: + print "dict returned false: not instance of dict" + return False + + # before passing ensure keys match + api_values = set(value.keys()) - set(skip) + user_values = set(user_def[key].keys()) - set(skip) + if api_values != user_values: + if debug: + print "keys are not equal in dict" + print api_values + print user_values + return False + + result = Utils.check_def_equal(user_def[key], value, skip_keys=skip_keys, debug=debug) + if not result: + if debug: + print "dict returned false" + print result + return False + + # Verify each key, value pair is the same + else: + if key not in user_def or value != user_def[key]: + if debug: + print "value not equal; user_def does not have key" + print key + print value + if key in user_def: + print user_def[key] + return False + + if debug: + print 'returning true' + return True + + +class OpenShiftCLIConfig(object): + '''Generic Config''' + def __init__(self, rname, namespace, kubeconfig, options): + self.kubeconfig = kubeconfig + self.name = rname + self.namespace = namespace + self._options = options + + @property + def config_options(self): + ''' return config options ''' + return self._options + + def to_option_list(self): + '''return all options as a string''' + return self.stringify() + + def stringify(self): + ''' return the options hash as cli params in a string ''' + rval = [] + for key, data in self.config_options.items(): + if data['include'] \ + and (data['value'] or isinstance(data['value'], int)): + rval.append('--%s=%s' % (key.replace('_', '-'), data['value'])) + + return rval + diff --git a/roles/lib_openshift/src/lib/import.py b/roles/lib_openshift/src/lib/import.py new file mode 100644 index 000000000..1fc75f466 --- /dev/null +++ b/roles/lib_openshift/src/lib/import.py @@ -0,0 +1,16 @@ +# pylint: skip-file +# flake8: noqa +''' + OpenShiftCLI class that wraps the oc commands in a subprocess +''' +# pylint: disable=too-many-lines + + +import atexit +import json +import os +import re +import ruamel.yaml as yaml +import shutil +import subprocess +from ansible.module_utils.basic import AnsibleModule diff --git a/roles/lib_openshift/src/lib/route.py b/roles/lib_openshift/src/lib/route.py new file mode 100644 index 000000000..11dc1dfbf --- /dev/null +++ b/roles/lib_openshift/src/lib/route.py @@ -0,0 +1,101 @@ +# pylint: skip-file +# flake8: noqa + + +# pylint: disable=too-many-instance-attributes +class RouteConfig(object): + ''' Handle route options ''' + # pylint: disable=too-many-arguments + def __init__(self, + sname, + namespace, + kubeconfig, + destcacert=None, + cacert=None, + cert=None, + key=None, + host=None, + tls_termination=None, + service_name=None): + ''' constructor for handling route options ''' + self.kubeconfig = kubeconfig + self.name = sname + self.namespace = namespace + self.host = host + self.tls_termination = tls_termination + self.destcacert = destcacert + self.cacert = cacert + self.cert = cert + self.key = key + self.service_name = service_name + self.data = {} + + self.create_dict() + + def create_dict(self): + ''' return a service as a dict ''' + self.data['apiVersion'] = 'v1' + self.data['kind'] = 'Route' + self.data['metadata'] = {} + self.data['metadata']['name'] = self.name + self.data['metadata']['namespace'] = self.namespace + self.data['spec'] = {} + + self.data['spec']['host'] = self.host + + if self.tls_termination: + self.data['spec']['tls'] = {} + + if self.tls_termination == 'reencrypt': + self.data['spec']['tls']['destinationCACertificate'] = self.destcacert + self.data['spec']['tls']['key'] = self.key + self.data['spec']['tls']['caCertificate'] = self.cacert + self.data['spec']['tls']['certificate'] = self.cert + self.data['spec']['tls']['termination'] = self.tls_termination + + self.data['spec']['to'] = {'kind': 'Service', 'name': self.service_name} + + +# pylint: disable=too-many-instance-attributes,too-many-public-methods +class Route(Yedit): + ''' Class to wrap the oc command line tools ''' + host_path = "spec.host" + service_path = "spec.to.name" + cert_path = "spec.tls.certificate" + cacert_path = "spec.tls.caCertificate" + destcacert_path = "spec.tls.destinationCACertificate" + termination_path = "spec.tls.termination" + key_path = "spec.tls.key" + kind = 'route' + + def __init__(self, content): + '''Route constructor''' + super(Route, self).__init__(content=content) + + def get_destcacert(self): + ''' return cert ''' + return self.get(Route.destcacert_path) + + def get_cert(self): + ''' return cert ''' + return self.get(Route.cert_path) + + def get_key(self): + ''' return key ''' + return self.get(Route.key_path) + + def get_cacert(self): + ''' return cacert ''' + return self.get(Route.cacert_path) + + def get_service(self): + ''' return service name ''' + return self.get(Route.service_path) + + def get_termination(self): + ''' return tls termination''' + return self.get(Route.termination_path) + + def get_host(self): + ''' return host ''' + return self.get(Route.host_path) diff --git a/roles/lib_utils/library/yedit.py b/roles/lib_utils/library/yedit.py index fb545c7c8..90c7fd4d7 100644 --- a/roles/lib_utils/library/yedit.py +++ b/roles/lib_utils/library/yedit.py @@ -24,7 +24,6 @@ # limitations under the License. # - # pylint: disable=wrong-import-order import json import os @@ -164,7 +163,6 @@ EXAMPLES = ''' # c: d ''' - class YeditException(Exception): ''' Exception class for Yedit ''' pass @@ -590,6 +588,48 @@ class Yedit(object): return (False, self.yaml_dict) + @staticmethod + def get_curr_value(invalue, val_type): + '''return the current value''' + if invalue is None: + return None + + curr_value = invalue + if val_type == 'yaml': + curr_value = yaml.load(invalue) + elif val_type == 'json': + curr_value = json.loads(invalue) + + return curr_value + + @staticmethod + def parse_value(inc_value, vtype=''): + '''determine value type passed''' + true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', + 'on', 'On', 'ON', ] + false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', + 'off', 'Off', 'OFF'] + + # It came in as a string but you didn't specify value_type as string + # we will convert to bool if it matches any of the above cases + if isinstance(inc_value, str) and 'bool' in vtype: + if inc_value not in true_bools and inc_value not in false_bools: + raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' + % (inc_value, vtype)) + elif isinstance(inc_value, bool) and 'str' in vtype: + inc_value = str(inc_value) + + # If vtype is not str then go ahead and attempt to yaml load it. + if isinstance(inc_value, str) and 'str' not in vtype: + try: + inc_value = yaml.load(inc_value) + except Exception: + raise YeditException('Could not determine type of incoming ' + + 'value. value=[%s] vtype=[%s]' + % (type(inc_value), vtype)) + + return inc_value + # pylint: disable=too-many-return-statements,too-many-branches @staticmethod def run_ansible(module): @@ -610,8 +650,8 @@ class Yedit(object): if module.params['state'] == 'list': if module.params['content']: - content = parse_value(module.params['content'], - module.params['content_type']) + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) yamlfile.yaml_dict = content if module.params['key']: @@ -621,8 +661,8 @@ class Yedit(object): elif module.params['state'] == 'absent': if module.params['content']: - content = parse_value(module.params['content'], - module.params['content_type']) + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) yamlfile.yaml_dict = content if module.params['update']: @@ -639,8 +679,8 @@ class Yedit(object): elif module.params['state'] == 'present': # check if content is different than what is in the file if module.params['content']: - content = parse_value(module.params['content'], - module.params['content_type']) + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) # We had no edits to make and the contents are the same if yamlfile.yaml_dict == content and \ @@ -653,12 +693,13 @@ class Yedit(object): # we were passed a value; parse it if module.params['value']: - value = parse_value(module.params['value'], - module.params['value_type']) + value = Yedit.parse_value(module.params['value'], + module.params['value_type']) key = module.params['key'] if module.params['update']: # pylint: disable=line-too-long - curr_value = get_curr_value(parse_value(module.params['curr_value']), module.params['curr_value_format']) # noqa: #501 + curr_value = Yedit.get_curr_value(Yedit.parse_value(module.params['curr_value']), # noqa: E501 + module.params['curr_value_format']) # noqa: E501 rval = yamlfile.update(key, value, module.params['index'], curr_value) # noqa: E501 @@ -683,49 +724,6 @@ class Yedit(object): return {'failed': True, 'msg': 'Unkown state passed'} - -def get_curr_value(invalue, val_type): - '''return the current value''' - if invalue is None: - return None - - curr_value = invalue - if val_type == 'yaml': - curr_value = yaml.load(invalue) - elif val_type == 'json': - curr_value = json.loads(invalue) - - return curr_value - - -def parse_value(inc_value, vtype=''): - '''determine value type passed''' - true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', - 'on', 'On', 'ON', ] - false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', - 'off', 'Off', 'OFF'] - - # It came in as a string but you didn't specify value_type as string - # we will convert to bool if it matches any of the above cases - if isinstance(inc_value, str) and 'bool' in vtype: - if inc_value not in true_bools and inc_value not in false_bools: - raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' - % (inc_value, vtype)) - elif isinstance(inc_value, bool) and 'str' in vtype: - inc_value = str(inc_value) - - # If vtype is not str then go ahead and attempt to yaml load it. - if isinstance(inc_value, str) and 'str' not in vtype: - try: - inc_value = yaml.load(inc_value) - except Exception: - raise YeditException('Could not determine type of incoming ' + - 'value. value=[%s] vtype=[%s]' - % (type(inc_value), vtype)) - - return inc_value - - # pylint: disable=too-many-branches def main(): ''' ansible oc module for secrets ''' @@ -757,7 +755,7 @@ def main(): rval = Yedit.run_ansible(module) if 'failed' in rval and rval['failed']: - module.fail_json(msg=rval['msg']) + module.fail_json(**rval) module.exit_json(**rval) diff --git a/roles/lib_utils/src/ansible/yedit.py b/roles/lib_utils/src/ansible/yedit.py index a80cd520c..efe034abf 100644 --- a/roles/lib_utils/src/ansible/yedit.py +++ b/roles/lib_utils/src/ansible/yedit.py @@ -1,49 +1,6 @@ # flake8: noqa # pylint: skip-file - -def get_curr_value(invalue, val_type): - '''return the current value''' - if invalue is None: - return None - - curr_value = invalue - if val_type == 'yaml': - curr_value = yaml.load(invalue) - elif val_type == 'json': - curr_value = json.loads(invalue) - - return curr_value - - -def parse_value(inc_value, vtype=''): - '''determine value type passed''' - true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', - 'on', 'On', 'ON', ] - false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', - 'off', 'Off', 'OFF'] - - # It came in as a string but you didn't specify value_type as string - # we will convert to bool if it matches any of the above cases - if isinstance(inc_value, str) and 'bool' in vtype: - if inc_value not in true_bools and inc_value not in false_bools: - raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' - % (inc_value, vtype)) - elif isinstance(inc_value, bool) and 'str' in vtype: - inc_value = str(inc_value) - - # If vtype is not str then go ahead and attempt to yaml load it. - if isinstance(inc_value, str) and 'str' not in vtype: - try: - inc_value = yaml.load(inc_value) - except Exception: - raise YeditException('Could not determine type of incoming ' + - 'value. value=[%s] vtype=[%s]' - % (type(inc_value), vtype)) - - return inc_value - - # pylint: disable=too-many-branches def main(): ''' ansible oc module for secrets ''' @@ -75,7 +32,7 @@ def main(): rval = Yedit.run_ansible(module) if 'failed' in rval and rval['failed']: - module.fail_json(msg=rval['msg']) + module.fail_json(**rval) module.exit_json(**rval) diff --git a/roles/lib_utils/src/class/yedit.py b/roles/lib_utils/src/class/yedit.py index e110bc11e..4521009ab 100644 --- a/roles/lib_utils/src/class/yedit.py +++ b/roles/lib_utils/src/class/yedit.py @@ -1,6 +1,7 @@ # flake8: noqa # pylint: skip-file + class YeditException(Exception): ''' Exception class for Yedit ''' pass @@ -426,6 +427,48 @@ class Yedit(object): return (False, self.yaml_dict) + @staticmethod + def get_curr_value(invalue, val_type): + '''return the current value''' + if invalue is None: + return None + + curr_value = invalue + if val_type == 'yaml': + curr_value = yaml.load(invalue) + elif val_type == 'json': + curr_value = json.loads(invalue) + + return curr_value + + @staticmethod + def parse_value(inc_value, vtype=''): + '''determine value type passed''' + true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', + 'on', 'On', 'ON', ] + false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', + 'off', 'Off', 'OFF'] + + # It came in as a string but you didn't specify value_type as string + # we will convert to bool if it matches any of the above cases + if isinstance(inc_value, str) and 'bool' in vtype: + if inc_value not in true_bools and inc_value not in false_bools: + raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' + % (inc_value, vtype)) + elif isinstance(inc_value, bool) and 'str' in vtype: + inc_value = str(inc_value) + + # If vtype is not str then go ahead and attempt to yaml load it. + if isinstance(inc_value, str) and 'str' not in vtype: + try: + inc_value = yaml.load(inc_value) + except Exception: + raise YeditException('Could not determine type of incoming ' + + 'value. value=[%s] vtype=[%s]' + % (type(inc_value), vtype)) + + return inc_value + # pylint: disable=too-many-return-statements,too-many-branches @staticmethod def run_ansible(module): @@ -446,8 +489,8 @@ class Yedit(object): if module.params['state'] == 'list': if module.params['content']: - content = parse_value(module.params['content'], - module.params['content_type']) + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) yamlfile.yaml_dict = content if module.params['key']: @@ -457,8 +500,8 @@ class Yedit(object): elif module.params['state'] == 'absent': if module.params['content']: - content = parse_value(module.params['content'], - module.params['content_type']) + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) yamlfile.yaml_dict = content if module.params['update']: @@ -475,8 +518,8 @@ class Yedit(object): elif module.params['state'] == 'present': # check if content is different than what is in the file if module.params['content']: - content = parse_value(module.params['content'], - module.params['content_type']) + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) # We had no edits to make and the contents are the same if yamlfile.yaml_dict == content and \ @@ -489,12 +532,13 @@ class Yedit(object): # we were passed a value; parse it if module.params['value']: - value = parse_value(module.params['value'], - module.params['value_type']) + value = Yedit.parse_value(module.params['value'], + module.params['value_type']) key = module.params['key'] if module.params['update']: # pylint: disable=line-too-long - curr_value = get_curr_value(parse_value(module.params['curr_value']), module.params['curr_value_format']) # noqa: #501 + curr_value = Yedit.get_curr_value(Yedit.parse_value(module.params['curr_value']), # noqa: E501 + module.params['curr_value_format']) # noqa: E501 rval = yamlfile.update(key, value, module.params['index'], curr_value) # noqa: E501 diff --git a/roles/lib_utils/src/test/integration/kube-manager-test.yaml b/roles/lib_utils/src/test/integration/kube-manager-test.yaml new file mode 100644 index 000000000..aea8e668f --- /dev/null +++ b/roles/lib_utils/src/test/integration/kube-manager-test.yaml @@ -0,0 +1,58 @@ +apiVersion: v1 +kind: Pod +metadata: + name: kube-controller-manager + namespace: kube-system +spec: + hostNetwork: true + containers: + - name: kube-controller-manager + image: openshift/kube:v1.0.0 + command: + - /hyperkube + - controller-manager + - --master=http://127.0.0.1:8080 + - --leader-elect=true + - --service-account-private-key-file=/etc/kubernetes/ssl/apiserver-key.pem + - --root-ca-file=/etc/k8s/ssl/my.pem + - --my-new-parameter=openshift + livenessProbe: + httpGet: + host: 127.0.0.1 + path: /healthz + port: 10252 + initialDelaySeconds: 15 + timeoutSeconds: 1 + volumeMounts: + - mountPath: /etc/kubernetes/ssl + name: ssl-certs-kubernetes + readOnly: true + - mountPath: /etc/ssl/certs + name: ssl-certs-host + readOnly: 'true' + volumes: + - hostPath: + path: /etc/kubernetes/ssl + name: ssl-certs-kubernetes + - hostPath: + path: /usr/share/ca-certificates + name: ssl-certs-host +yedittest: yedittest +metadata-namespace: openshift-is-awesome +nonexistingkey: +- --my-new-parameter=openshift +a: + b: + c: d +e: + f: + g: + h: + i: + j: k +z: + x: + y: + - 1 + - 2 + - 3 diff --git a/roles/lib_utils/src/test/integration/kube-manager-test.yaml.orig b/roles/lib_utils/src/test/integration/kube-manager-test.yaml.orig new file mode 100644 index 000000000..5541c3dae --- /dev/null +++ b/roles/lib_utils/src/test/integration/kube-manager-test.yaml.orig @@ -0,0 +1,52 @@ +apiVersion: v1 +kind: Pod +metadata: + name: kube-controller-manager + namespace: kube-system +spec: + hostNetwork: true + containers: + - name: kube-controller-manager + image: openshift/kube:v1.0.0 + command: + - /hyperkube + - controller-manager + - --master=http://127.0.0.1:8080 + - --leader-elect=true + - --service-account-private-key-file=/etc/kubernetes/ssl/apiserver-key.pem + - --root-ca-file=/etc/k8s/ssl/my.pem + - --my-new-parameter=openshift + livenessProbe: + httpGet: + host: 127.0.0.1 + path: /healthz + port: 10252 + initialDelaySeconds: 15 + timeoutSeconds: 1 + volumeMounts: + - mountPath: /etc/kubernetes/ssl + name: ssl-certs-kubernetes + readOnly: true + - mountPath: /etc/ssl/certs + name: ssl-certs-host + readOnly: 'true' + volumes: + - hostPath: + path: /etc/kubernetes/ssl + name: ssl-certs-kubernetes + - hostPath: + path: /usr/share/ca-certificates + name: ssl-certs-host +yedittest: yedittest +metadata-namespace: openshift-is-awesome +nonexistingkey: +- --my-new-parameter=openshift +a: + b: + c: d +e: + f: + g: + h: + i: + j: k -- cgit v1.2.3 From ea33e223e34bb2b8efae6b165f3ac9729357cb46 Mon Sep 17 00:00:00 2001 From: Kenny Woodson Date: Fri, 13 Jan 2017 14:29:48 -0500 Subject: Adding oc_edit module to lib_openshift. --- roles/lib_openshift/library/oc_edit.py | 1311 ++++++++++++++++ roles/lib_openshift/library/oc_route.py | 1643 ++++++++++---------- roles/lib_openshift/src/ansible/oc_edit.py | 48 + roles/lib_openshift/src/class/oc_edit.py | 94 ++ roles/lib_openshift/src/class/oc_route.py | 1 + roles/lib_openshift/src/doc/edit | 116 ++ roles/lib_openshift/src/doc/route | 6 +- roles/lib_openshift/src/generate.py | 3 +- roles/lib_openshift/src/generate_sources.yml | 10 - roles/lib_openshift/src/lib/base.py | 66 +- roles/lib_openshift/src/lib/import.py | 5 +- roles/lib_openshift/src/lib/route.py | 1 + roles/lib_openshift/src/sources.yml | 18 + roles/lib_openshift/src/test/integration/route.yml | 58 + roles/lib_utils/library/yedit.py | 4 + roles/lib_utils/src/ansible/yedit.py | 1 + roles/lib_utils/src/class/yedit.py | 2 + .../src/test/integration/kube-manager-test.yaml | 58 - 18 files changed, 2518 insertions(+), 927 deletions(-) create mode 100644 roles/lib_openshift/library/oc_edit.py create mode 100644 roles/lib_openshift/src/ansible/oc_edit.py create mode 100644 roles/lib_openshift/src/class/oc_edit.py create mode 100644 roles/lib_openshift/src/doc/edit delete mode 100644 roles/lib_openshift/src/generate_sources.yml create mode 100644 roles/lib_openshift/src/sources.yml create mode 100644 roles/lib_openshift/src/test/integration/route.yml delete mode 100644 roles/lib_utils/src/test/integration/kube-manager-test.yaml diff --git a/roles/lib_openshift/library/oc_edit.py b/roles/lib_openshift/library/oc_edit.py new file mode 100644 index 000000000..f78cbf2b3 --- /dev/null +++ b/roles/lib_openshift/library/oc_edit.py @@ -0,0 +1,1311 @@ +#!/usr/bin/env python +# pylint: disable=missing-docstring +# flake8: noqa: T001 +# ___ ___ _ _ ___ ___ _ _____ ___ ___ +# / __| __| \| | __| _ \ /_\_ _| __| \ +# | (_ | _|| .` | _|| / / _ \| | | _|| |) | +# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____ +# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _| +# | |) | (_) | | .` | (_) || | | _|| |) | | | | +# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_| +# +# Copyright 2016 Red Hat, Inc. and/or its affiliates +# and other contributors as indicated by the @author tags. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +''' + OpenShiftCLI class that wraps the oc commands in a subprocess +''' +# pylint: disable=too-many-lines + +from __future__ import print_function +import atexit +import json +import os +import re +import shutil +import subprocess +# pylint: disable=import-error +import ruamel.yaml as yaml +from ansible.module_utils.basic import AnsibleModule + +DOCUMENTATION = ''' +--- +module: oc_edit +short_description: Modify, and idempotently manage openshift objects. +description: + - Modify openshift objects programmatically. +options: + state: + description: + - Currently present is only supported state. + required: true + default: present + choices: ["present"] + aliases: [] + kubeconfig: + description: + - The path for the kubeconfig file to use for authentication + required: false + default: /etc/origin/master/admin.kubeconfig + aliases: [] + debug: + description: + - Turn on debug output. + required: false + default: False + aliases: [] + name: + description: + - Name of the object that is being queried. + required: false + default: None + aliases: [] + namespace: + description: + - The namespace where the object lives. + required: false + default: str + aliases: [] + kind: + description: + - The kind attribute of the object. + required: True + default: None + choices: + - bc + - buildconfig + - configmaps + - dc + - deploymentconfig + - imagestream + - imagestreamtag + - is + - istag + - namespace + - project + - projects + - node + - ns + - persistentvolume + - pv + - rc + - replicationcontroller + - routes + - scc + - secret + - securitycontextconstraints + - service + - svc + aliases: [] + file_name: + description: + - The file name in which to edit + required: false + default: None + aliases: [] + file_format: + description: + - The format of the file being edited. + required: false + default: yaml + aliases: [] + content: + description: + - Content of the file + required: false + default: None + aliases: [] + force: + description: + - Whether or not to force the operation + required: false + default: None + aliases: [] + separator: + description: + - The separator format for the edit. + required: false + default: '.' + aliases: [] +author: +- "Kenny Woodson " +extends_documentation_fragment: [] +''' + +EXAMPLES = ''' +oc_edit: + kind: rc + name: hawkular-cassandra-rc + namespace: openshift-infra + content: + spec.template.spec.containers[0].resources.limits.memory: 512 + spec.template.spec.containers[0].resources.requests.memory: 256 +''' +# noqa: E301,E302 + + +class YeditException(Exception): + ''' Exception class for Yedit ''' + pass + + +# pylint: disable=too-many-public-methods +class Yedit(object): + ''' Class to modify yaml files ''' + re_valid_key = r"(((\[-?\d+\])|([0-9a-zA-Z%s/_-]+)).?)+$" + re_key = r"(?:\[(-?\d+)\])|([0-9a-zA-Z%s/_-]+)" + com_sep = set(['.', '#', '|', ':']) + + # pylint: disable=too-many-arguments + def __init__(self, + filename=None, + content=None, + content_type='yaml', + separator='.', + backup=False): + self.content = content + self._separator = separator + self.filename = filename + self.__yaml_dict = content + self.content_type = content_type + self.backup = backup + self.load(content_type=self.content_type) + if self.__yaml_dict is None: + self.__yaml_dict = {} + + @property + def separator(self): + ''' getter method for yaml_dict ''' + return self._separator + + @separator.setter + def separator(self): + ''' getter method for yaml_dict ''' + return self._separator + + @property + def yaml_dict(self): + ''' getter method for yaml_dict ''' + return self.__yaml_dict + + @yaml_dict.setter + def yaml_dict(self, value): + ''' setter method for yaml_dict ''' + self.__yaml_dict = value + + @staticmethod + def parse_key(key, sep='.'): + '''parse the key allowing the appropriate separator''' + common_separators = list(Yedit.com_sep - set([sep])) + return re.findall(Yedit.re_key % ''.join(common_separators), key) + + @staticmethod + def valid_key(key, sep='.'): + '''validate the incoming key''' + common_separators = list(Yedit.com_sep - set([sep])) + if not re.match(Yedit.re_valid_key % ''.join(common_separators), key): + return False + + return True + + @staticmethod + def remove_entry(data, key, sep='.'): + ''' remove data at location key ''' + if key == '' and isinstance(data, dict): + data.clear() + return True + elif key == '' and isinstance(data, list): + del data[:] + return True + + if not (key and Yedit.valid_key(key, sep)) and \ + isinstance(data, (list, dict)): + return None + + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes[:-1]: + if dict_key and isinstance(data, dict): + data = data.get(dict_key, None) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None + + # process last index for remove + # expected list entry + if key_indexes[-1][0]: + if isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 + del data[int(key_indexes[-1][0])] + return True + + # expected dict entry + elif key_indexes[-1][1]: + if isinstance(data, dict): + del data[key_indexes[-1][1]] + return True + + @staticmethod + def add_entry(data, key, item=None, sep='.'): + ''' Get an item from a dictionary with key notation a.b.c + d = {'a': {'b': 'c'}}} + key = a#b + return c + ''' + if key == '': + pass + elif (not (key and Yedit.valid_key(key, sep)) and + isinstance(data, (list, dict))): + return None + + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes[:-1]: + if dict_key: + if isinstance(data, dict) and dict_key in data and data[dict_key]: # noqa: E501 + data = data[dict_key] + continue + + elif data and not isinstance(data, dict): + return None + + data[dict_key] = {} + data = data[dict_key] + + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None + + if key == '': + data = item + + # process last index for add + # expected list entry + elif key_indexes[-1][0] and isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 + data[int(key_indexes[-1][0])] = item + + # expected dict entry + elif key_indexes[-1][1] and isinstance(data, dict): + data[key_indexes[-1][1]] = item + + return data + + @staticmethod + def get_entry(data, key, sep='.'): + ''' Get an item from a dictionary with key notation a.b.c + d = {'a': {'b': 'c'}}} + key = a.b + return c + ''' + if key == '': + pass + elif (not (key and Yedit.valid_key(key, sep)) and + isinstance(data, (list, dict))): + return None + + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes: + if dict_key and isinstance(data, dict): + data = data.get(dict_key, None) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None + + return data + + def write(self): + ''' write to file ''' + if not self.filename: + raise YeditException('Please specify a filename.') + + if self.backup and self.file_exists(): + shutil.copy(self.filename, self.filename + '.orig') + + tmp_filename = self.filename + '.yedit' + with open(tmp_filename, 'w') as yfd: + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + self.yaml_dict.fa.set_block_style() + + yfd.write(yaml.dump(self.yaml_dict, Dumper=yaml.RoundTripDumper)) + + os.rename(tmp_filename, self.filename) + + return (True, self.yaml_dict) + + def read(self): + ''' read from file ''' + # check if it exists + if self.filename is None or not self.file_exists(): + return None + + contents = None + with open(self.filename) as yfd: + contents = yfd.read() + + return contents + + def file_exists(self): + ''' return whether file exists ''' + if os.path.exists(self.filename): + return True + + return False + + def load(self, content_type='yaml'): + ''' return yaml file ''' + contents = self.read() + + if not contents and not self.content: + return None + + if self.content: + if isinstance(self.content, dict): + self.yaml_dict = self.content + return self.yaml_dict + elif isinstance(self.content, str): + contents = self.content + + # check if it is yaml + try: + if content_type == 'yaml' and contents: + self.yaml_dict = yaml.load(contents, yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + self.yaml_dict.fa.set_block_style() + elif content_type == 'json' and contents: + self.yaml_dict = json.loads(contents) + except yaml.YAMLError as err: + # Error loading yaml or json + raise YeditException('Problem with loading yaml file. %s' % err) + + return self.yaml_dict + + def get(self, key): + ''' get a specified key''' + try: + entry = Yedit.get_entry(self.yaml_dict, key, self.separator) + except KeyError: + entry = None + + return entry + + def pop(self, path, key_or_item): + ''' remove a key, value pair from a dict or an item for a list''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry is None: + return (False, self.yaml_dict) + + if isinstance(entry, dict): + # pylint: disable=no-member,maybe-no-member + if key_or_item in entry: + entry.pop(key_or_item) + return (True, self.yaml_dict) + return (False, self.yaml_dict) + + elif isinstance(entry, list): + # pylint: disable=no-member,maybe-no-member + ind = None + try: + ind = entry.index(key_or_item) + except ValueError: + return (False, self.yaml_dict) + + entry.pop(ind) + return (True, self.yaml_dict) + + return (False, self.yaml_dict) + + def delete(self, path): + ''' remove path from a dict''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry is None: + return (False, self.yaml_dict) + + result = Yedit.remove_entry(self.yaml_dict, path, self.separator) + if not result: + return (False, self.yaml_dict) + + return (True, self.yaml_dict) + + def exists(self, path, value): + ''' check if value exists at path''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if isinstance(entry, list): + if value in entry: + return True + return False + + elif isinstance(entry, dict): + if isinstance(value, dict): + rval = False + for key, val in value.items(): + if entry[key] != val: + rval = False + break + else: + rval = True + return rval + + return value in entry + + return entry == value + + def append(self, path, value): + '''append value to a list''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry is None: + self.put(path, []) + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + if not isinstance(entry, list): + return (False, self.yaml_dict) + + # pylint: disable=no-member,maybe-no-member + entry.append(value) + return (True, self.yaml_dict) + + # pylint: disable=too-many-arguments + def update(self, path, value, index=None, curr_value=None): + ''' put path, value into a dict ''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if isinstance(entry, dict): + # pylint: disable=no-member,maybe-no-member + if not isinstance(value, dict): + raise YeditException('Cannot replace key, value entry in ' + + 'dict with non-dict type. value=[%s] [%s]' % (value, type(value))) # noqa: E501 + + entry.update(value) + return (True, self.yaml_dict) + + elif isinstance(entry, list): + # pylint: disable=no-member,maybe-no-member + ind = None + if curr_value: + try: + ind = entry.index(curr_value) + except ValueError: + return (False, self.yaml_dict) + + elif index is not None: + ind = index + + if ind is not None and entry[ind] != value: + entry[ind] = value + return (True, self.yaml_dict) + + # see if it exists in the list + try: + ind = entry.index(value) + except ValueError: + # doesn't exist, append it + entry.append(value) + return (True, self.yaml_dict) + + # already exists, return + if ind is not None: + return (False, self.yaml_dict) + return (False, self.yaml_dict) + + def put(self, path, value): + ''' put path, value into a dict ''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + + if entry == value: + return (False, self.yaml_dict) + + # deepcopy didn't work + tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, + default_flow_style=False), + yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + tmp_copy.fa.set_block_style() + result = Yedit.add_entry(tmp_copy, path, value, self.separator) + if not result: + return (False, self.yaml_dict) + + self.yaml_dict = tmp_copy + + return (True, self.yaml_dict) + + def create(self, path, value): + ''' create a yaml file ''' + if not self.file_exists(): + # deepcopy didn't work + tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, default_flow_style=False), # noqa: E501 + yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + tmp_copy.fa.set_block_style() + result = Yedit.add_entry(tmp_copy, path, value, self.separator) + if result: + self.yaml_dict = tmp_copy + return (True, self.yaml_dict) + + return (False, self.yaml_dict) + + @staticmethod + def get_curr_value(invalue, val_type): + '''return the current value''' + if invalue is None: + return None + + curr_value = invalue + if val_type == 'yaml': + curr_value = yaml.load(invalue) + elif val_type == 'json': + curr_value = json.loads(invalue) + + return curr_value + + @staticmethod + def parse_value(inc_value, vtype=''): + '''determine value type passed''' + true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', + 'on', 'On', 'ON', ] + false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', + 'off', 'Off', 'OFF'] + + # It came in as a string but you didn't specify value_type as string + # we will convert to bool if it matches any of the above cases + if isinstance(inc_value, str) and 'bool' in vtype: + if inc_value not in true_bools and inc_value not in false_bools: + raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' + % (inc_value, vtype)) + elif isinstance(inc_value, bool) and 'str' in vtype: + inc_value = str(inc_value) + + # If vtype is not str then go ahead and attempt to yaml load it. + if isinstance(inc_value, str) and 'str' not in vtype: + try: + inc_value = yaml.load(inc_value) + except Exception: + raise YeditException('Could not determine type of incoming ' + + 'value. value=[%s] vtype=[%s]' + % (type(inc_value), vtype)) + + return inc_value + + # pylint: disable=too-many-return-statements,too-many-branches + @staticmethod + def run_ansible(module): + '''perform the idempotent crud operations''' + yamlfile = Yedit(filename=module.params['src'], + backup=module.params['backup'], + separator=module.params['separator']) + + if module.params['src']: + rval = yamlfile.load() + + if yamlfile.yaml_dict is None and \ + module.params['state'] != 'present': + return {'failed': True, + 'msg': 'Error opening file [%s]. Verify that the ' + + 'file exists, that it is has correct' + + ' permissions, and is valid yaml.'} + + if module.params['state'] == 'list': + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + yamlfile.yaml_dict = content + + if module.params['key']: + rval = yamlfile.get(module.params['key']) or {} + + return {'changed': False, 'result': rval, 'state': "list"} + + elif module.params['state'] == 'absent': + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + yamlfile.yaml_dict = content + + if module.params['update']: + rval = yamlfile.pop(module.params['key'], + module.params['value']) + else: + rval = yamlfile.delete(module.params['key']) + + if rval[0] and module.params['src']: + yamlfile.write() + + return {'changed': rval[0], 'result': rval[1], 'state': "absent"} + + elif module.params['state'] == 'present': + # check if content is different than what is in the file + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + + # We had no edits to make and the contents are the same + if yamlfile.yaml_dict == content and \ + module.params['value'] is None: + return {'changed': False, + 'result': yamlfile.yaml_dict, + 'state': "present"} + + yamlfile.yaml_dict = content + + # we were passed a value; parse it + if module.params['value']: + value = Yedit.parse_value(module.params['value'], + module.params['value_type']) + key = module.params['key'] + if module.params['update']: + # pylint: disable=line-too-long + curr_value = Yedit.get_curr_value(Yedit.parse_value(module.params['curr_value']), # noqa: E501 + module.params['curr_value_format']) # noqa: E501 + + rval = yamlfile.update(key, value, module.params['index'], curr_value) # noqa: E501 + + elif module.params['append']: + rval = yamlfile.append(key, value) + else: + rval = yamlfile.put(key, value) + + if rval[0] and module.params['src']: + yamlfile.write() + + return {'changed': rval[0], + 'result': rval[1], 'state': "present"} + + # no edits to make + if module.params['src']: + # pylint: disable=redefined-variable-type + rval = yamlfile.write() + return {'changed': rval[0], + 'result': rval[1], + 'state': "present"} + + return {'failed': True, 'msg': 'Unkown state passed'} +# pylint: disable=too-many-lines +# noqa: E301,E302,E303,T001 + + +class OpenShiftCLIError(Exception): + '''Exception class for openshiftcli''' + pass + + +# pylint: disable=too-few-public-methods +class OpenShiftCLI(object): + ''' Class to wrap the command line tools ''' + def __init__(self, + namespace, + kubeconfig='/etc/origin/master/admin.kubeconfig', + verbose=False, + all_namespaces=False): + ''' Constructor for OpenshiftCLI ''' + self.namespace = namespace + self.verbose = verbose + self.kubeconfig = kubeconfig + self.all_namespaces = all_namespaces + + # Pylint allows only 5 arguments to be passed. + # pylint: disable=too-many-arguments + def _replace_content(self, resource, rname, content, force=False, sep='.'): + ''' replace the current object with the content ''' + res = self._get(resource, rname) + if not res['results']: + return res + + fname = '/tmp/%s' % rname + yed = Yedit(fname, res['results'][0], separator=sep) + changes = [] + for key, value in content.items(): + changes.append(yed.put(key, value)) + + if any([change[0] for change in changes]): + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self._replace(fname, force) + + return {'returncode': 0, 'updated': False} + + def _replace(self, fname, force=False): + '''return all pods ''' + cmd = ['-n', self.namespace, 'replace', '-f', fname] + if force: + cmd.append('--force') + return self.openshift_cmd(cmd) + + def _create_from_content(self, rname, content): + '''return all pods ''' + fname = '/tmp/%s' % rname + yed = Yedit(fname, content=content) + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self._create(fname) + + def _create(self, fname): + '''return all pods ''' + return self.openshift_cmd(['create', '-f', fname, '-n', self.namespace]) + + def _delete(self, resource, rname, selector=None): + '''return all pods ''' + cmd = ['delete', resource, rname, '-n', self.namespace] + if selector: + cmd.append('--selector=%s' % selector) + + return self.openshift_cmd(cmd) + + def _process(self, template_name, create=False, params=None, template_data=None): # noqa: E501 + '''return all pods ''' + cmd = ['process', '-n', self.namespace] + if template_data: + cmd.extend(['-f', '-']) + else: + cmd.append(template_name) + if params: + param_str = ["%s=%s" % (key, value) for key, value in params.items()] + cmd.append('-v') + cmd.extend(param_str) + + results = self.openshift_cmd(cmd, output=True, input_data=template_data) + + if results['returncode'] != 0 or not create: + return results + + fname = '/tmp/%s' % template_name + yed = Yedit(fname, results['results']) + yed.write() + + atexit.register(Utils.cleanup, [fname]) + + return self.openshift_cmd(['-n', self.namespace, 'create', '-f', fname]) + + def _get(self, resource, rname=None, selector=None): + '''return a resource by name ''' + cmd = ['get', resource] + if selector: + cmd.append('--selector=%s' % selector) + if self.all_namespaces: + cmd.extend(['--all-namespaces']) + elif self.namespace: + cmd.extend(['-n', self.namespace]) + + cmd.extend(['-o', 'json']) + + if rname: + cmd.append(rname) + + rval = self.openshift_cmd(cmd, output=True) + + # Ensure results are retuned in an array + if 'items' in rval: + rval['results'] = rval['items'] + elif not isinstance(rval['results'], list): + rval['results'] = [rval['results']] + + return rval + + def _schedulable(self, node=None, selector=None, schedulable=True): + ''' perform oadm manage-node scheduable ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + cmd.append('--schedulable=%s' % schedulable) + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') # noqa: E501 + + def _list_pods(self, node=None, selector=None, pod_selector=None): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) + + cmd.extend(['--list-pods', '-o', 'json']) + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + + # pylint: disable=too-many-arguments + def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) + + if dry_run: + cmd.append('--dry-run') + + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) + + if grace_period: + cmd.append('--grace-period=%s' % int(grace_period)) + + if force: + cmd.append('--force') + + cmd.append('--evacuate') + + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + + def _import_image(self, url=None, name=None, tag=None): + ''' perform image import ''' + cmd = ['import-image'] + + image = '{0}'.format(name) + if tag: + image += ':{0}'.format(tag) + + cmd.append(image) + + if url: + cmd.append('--from={0}/{1}'.format(url, image)) + + cmd.append('-n{0}'.format(self.namespace)) + + cmd.append('--confirm') + return self.openshift_cmd(cmd) + + # pylint: disable=too-many-arguments + def openshift_cmd(self, cmd, oadm=False, output=False, output_type='json', input_data=None): + '''Base command for oc ''' + cmds = [] + if oadm: + cmds = ['/usr/bin/oadm'] + else: + cmds = ['/usr/bin/oc'] + + cmds.extend(cmd) + + rval = {} + results = '' + err = None + + if self.verbose: + print(' '.join(cmds)) + + proc = subprocess.Popen(cmds, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env={'KUBECONFIG': self.kubeconfig}) + + stdout, stderr = proc.communicate(input_data) + rval = {"returncode": proc.returncode, + "results": results, + "cmd": ' '.join(cmds)} + + if proc.returncode == 0: + if output: + if output_type == 'json': + try: + rval['results'] = json.loads(stdout) + except ValueError as err: + if "No JSON object could be decoded" in str(err): + err = str(err) + elif output_type == 'raw': + rval['results'] = stdout + + if self.verbose: + print(stdout) + print(stderr) + + if err: + rval.update({"err": err, + "stderr": stderr, + "stdout": stdout, + "cmd": cmds}) + + else: + rval.update({"stderr": stderr, + "stdout": stdout, + "results": {}}) + + return rval + + +class Utils(object): + ''' utilities for openshiftcli modules ''' + @staticmethod + def create_file(rname, data, ftype='yaml'): + ''' create a file in tmp with name and contents''' + path = os.path.join('/tmp', rname) + with open(path, 'w') as fds: + if ftype == 'yaml': + fds.write(yaml.dump(data, Dumper=yaml.RoundTripDumper)) + + elif ftype == 'json': + fds.write(json.dumps(data)) + else: + fds.write(data) + + # Register cleanup when module is done + atexit.register(Utils.cleanup, [path]) + return path + + @staticmethod + def create_files_from_contents(content, content_type=None): + '''Turn an array of dict: filename, content into a files array''' + if not isinstance(content, list): + content = [content] + files = [] + for item in content: + path = Utils.create_file(item['path'], item['data'], ftype=content_type) + files.append({'name': os.path.basename(path), 'path': path}) + return files + + @staticmethod + def cleanup(files): + '''Clean up on exit ''' + for sfile in files: + if os.path.exists(sfile): + if os.path.isdir(sfile): + shutil.rmtree(sfile) + elif os.path.isfile(sfile): + os.remove(sfile) + + @staticmethod + def exists(results, _name): + ''' Check to see if the results include the name ''' + if not results: + return False + + if Utils.find_result(results, _name): + return True + + return False + + @staticmethod + def find_result(results, _name): + ''' Find the specified result by name''' + rval = None + for result in results: + if 'metadata' in result and result['metadata']['name'] == _name: + rval = result + break + + return rval + + @staticmethod + def get_resource_file(sfile, sfile_type='yaml'): + ''' return the service file ''' + contents = None + with open(sfile) as sfd: + contents = sfd.read() + + if sfile_type == 'yaml': + contents = yaml.load(contents, yaml.RoundTripLoader) + elif sfile_type == 'json': + contents = json.loads(contents) + + return contents + + # Disabling too-many-branches. This is a yaml dictionary comparison function + # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements + @staticmethod + def check_def_equal(user_def, result_def, skip_keys=None, debug=False): + ''' Given a user defined definition, compare it with the results given back by our query. ''' + + # Currently these values are autogenerated and we do not need to check them + skip = ['metadata', 'status'] + if skip_keys: + skip.extend(skip_keys) + + for key, value in result_def.items(): + if key in skip: + continue + + # Both are lists + if isinstance(value, list): + if key not in user_def: + if debug: + print('User data does not have key [%s]' % key) + print('User data: %s' % user_def) + return False + + if not isinstance(user_def[key], list): + if debug: + print('user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key])) + return False + + if len(user_def[key]) != len(value): + if debug: + print("List lengths are not equal.") + print("key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value))) + print("user_def: %s" % user_def[key]) + print("value: %s" % value) + return False + + for values in zip(user_def[key], value): + if isinstance(values[0], dict) and isinstance(values[1], dict): + if debug: + print('sending list - list') + print(type(values[0])) + print(type(values[1])) + result = Utils.check_def_equal(values[0], values[1], skip_keys=skip_keys, debug=debug) + if not result: + print('list compare returned false') + return False + + elif value != user_def[key]: + if debug: + print('value should be identical') + print(value) + print(user_def[key]) + return False + + # recurse on a dictionary + elif isinstance(value, dict): + if key not in user_def: + if debug: + print("user_def does not have key [%s]" % key) + return False + if not isinstance(user_def[key], dict): + if debug: + print("dict returned false: not instance of dict") + return False + + # before passing ensure keys match + api_values = set(value.keys()) - set(skip) + user_values = set(user_def[key].keys()) - set(skip) + if api_values != user_values: + if debug: + print("keys are not equal in dict") + print(api_values) + print(user_values) + return False + + result = Utils.check_def_equal(user_def[key], value, skip_keys=skip_keys, debug=debug) + if not result: + if debug: + print("dict returned false") + print(result) + return False + + # Verify each key, value pair is the same + else: + if key not in user_def or value != user_def[key]: + if debug: + print("value not equal; user_def does not have key") + print(key) + print(value) + if key in user_def: + print(user_def[key]) + return False + + if debug: + print('returning true') + return True + + +class OpenShiftCLIConfig(object): + '''Generic Config''' + def __init__(self, rname, namespace, kubeconfig, options): + self.kubeconfig = kubeconfig + self.name = rname + self.namespace = namespace + self._options = options + + @property + def config_options(self): + ''' return config options ''' + return self._options + + def to_option_list(self): + '''return all options as a string''' + return self.stringify() + + def stringify(self): + ''' return the options hash as cli params in a string ''' + rval = [] + for key, data in self.config_options.items(): + if data['include'] \ + and (data['value'] or isinstance(data['value'], int)): + rval.append('--%s=%s' % (key.replace('_', '-'), data['value'])) + + return rval + + +class Edit(OpenShiftCLI): + ''' Class to wrap the oc command line tools + ''' + # pylint: disable=too-many-arguments + def __init__(self, + kind, + namespace, + resource_name=None, + kubeconfig='/etc/origin/master/admin.kubeconfig', + separator='.', + verbose=False): + ''' Constructor for OpenshiftOC ''' + super(Edit, self).__init__(namespace, kubeconfig) + self.namespace = namespace + self.kind = kind + self.name = resource_name + self.kubeconfig = kubeconfig + self.separator = separator + self.verbose = verbose + + def get(self): + '''return a secret by name ''' + return self._get(self.kind, self.name) + + def update(self, file_name, content, force=False, content_type='yaml'): + '''run update ''' + if file_name: + if content_type == 'yaml': + data = yaml.load(open(file_name)) + elif content_type == 'json': + data = json.loads(open(file_name).read()) + + changes = [] + yed = Yedit(filename=file_name, content=data, separator=self.separator) + for key, value in content.items(): + changes.append(yed.put(key, value)) + + if any([not change[0] for change in changes]): + return {'returncode': 0, 'updated': False} + + yed.write() + + atexit.register(Utils.cleanup, [file_name]) + + return self._replace(file_name, force=force) + + return self._replace_content(self.kind, self.name, content, force=force, sep=self.separator) + + @staticmethod + def run_ansible(params, check_mode): + '''run the ansible idempotent code''' + + ocedit = Edit(params['kind'], + params['namespace'], + params['name'], + kubeconfig=params['kubeconfig'], + separator=params['separator'], + verbose=params['debug']) + + api_rval = ocedit.get() + + ######## + # Create + ######## + if not Utils.exists(api_rval['results'], params['name']): + return {"failed": True, 'msg': api_rval} + + ######## + # Update + ######## + if check_mode: + return {'changed': True, 'msg': 'CHECK_MODE: Would have performed edit'} + + api_rval = ocedit.update(params['file_name'], + params['content'], + params['force'], + params['file_format']) + + if api_rval['returncode'] != 0: + return {"failed": True, 'msg': api_rval} + + if 'updated' in api_rval and not api_rval['updated']: + return {"changed": False, 'results': api_rval, 'state': 'present'} + + # return the created object + api_rval = ocedit.get() + + if api_rval['returncode'] != 0: + return {"failed": True, 'msg': api_rval} + + return {"changed": True, 'results': api_rval, 'state': 'present'} + + +def main(): + ''' + ansible oc module for editing objects + ''' + + module = AnsibleModule( + argument_spec=dict( + kubeconfig=dict(default='/etc/origin/master/admin.kubeconfig', type='str'), + state=dict(default='present', type='str', + choices=['present']), + debug=dict(default=False, type='bool'), + namespace=dict(default='default', type='str'), + name=dict(default=None, required=True, type='str'), + kind=dict(required=True, + type='str', + choices=['dc', 'deploymentconfig', + 'rc', 'replicationcontroller', + 'svc', 'service', + 'scc', 'securitycontextconstraints', + 'ns', 'namespace', 'project', 'projects', + 'is', 'imagestream', + 'istag', 'imagestreamtag', + 'bc', 'buildconfig', + 'routes', + 'node', + 'secret', + 'pv', 'persistentvolume']), + file_name=dict(default=None, type='str'), + file_format=dict(default='yaml', type='str'), + content=dict(default=None, required=True, type='dict'), + force=dict(default=False, type='bool'), + separator=dict(default='.', type='str'), + ), + supports_check_mode=True, + ) + + rval = Edit.run_ansible(module.params, module.check_mode) + if 'failed' in rval: + module.fail_json(**rval) + + module.exit_json(**rval) + +if __name__ == '__main__': + main() diff --git a/roles/lib_openshift/library/oc_route.py b/roles/lib_openshift/library/oc_route.py index 9efa6d0c7..de186ded7 100644 --- a/roles/lib_openshift/library/oc_route.py +++ b/roles/lib_openshift/library/oc_route.py @@ -1,5 +1,6 @@ #!/usr/bin/env python # pylint: disable=missing-docstring +# flake8: noqa: T001 # ___ ___ _ _ ___ ___ _ _____ ___ ___ # / __| __| \| | __| _ \ /_\_ _| __| \ # | (_ | _|| .` | _|| / / _ \| | | _|| |) | @@ -28,22 +29,23 @@ ''' # pylint: disable=too-many-lines - +from __future__ import print_function import atexit import json import os import re -import ruamel.yaml as yaml import shutil import subprocess +# pylint: disable=import-error +import ruamel.yaml as yaml from ansible.module_utils.basic import AnsibleModule DOCUMENTATION = ''' --- -module: yedit -short_description: Create, modify, and idempotently manage yaml files. +module: oc_route +short_description: Create, modify, and idempotently manage openshift routes. description: - - Modify yaml files programmatically. + - Manage openshift route objects programmatically. options: state: description: @@ -155,1023 +157,1025 @@ EXAMPLES = ''' tls_termination: reencrypt run_once: true ''' -''' - OpenShiftCLI class that wraps the oc commands in a subprocess -''' -# pylint: disable=too-many-lines +# noqa: E301,E302 -class OpenShiftCLIError(Exception): - '''Exception class for openshiftcli''' +class YeditException(Exception): + ''' Exception class for Yedit ''' pass -# pylint: disable=too-few-public-methods -class OpenShiftCLI(object): - ''' Class to wrap the command line tools ''' - def __init__(self, - namespace, - kubeconfig='/etc/origin/master/admin.kubeconfig', - verbose=False, - all_namespaces=False): - ''' Constructor for OpenshiftCLI ''' - self.namespace = namespace - self.verbose = verbose - self.kubeconfig = kubeconfig - self.all_namespaces = all_namespaces +# pylint: disable=too-many-public-methods +class Yedit(object): + ''' Class to modify yaml files ''' + re_valid_key = r"(((\[-?\d+\])|([0-9a-zA-Z%s/_-]+)).?)+$" + re_key = r"(?:\[(-?\d+)\])|([0-9a-zA-Z%s/_-]+)" + com_sep = set(['.', '#', '|', ':']) - # Pylint allows only 5 arguments to be passed. # pylint: disable=too-many-arguments - def _replace_content(self, resource, rname, content, force=False, sep='.'): - ''' replace the current object with the content ''' - res = self._get(resource, rname) - if not res['results']: - return res - - fname = '/tmp/%s' % rname - yed = Yedit(fname, res['results'][0], separator=sep) - changes = [] - for key, value in content.items(): - changes.append(yed.put(key, value)) + def __init__(self, + filename=None, + content=None, + content_type='yaml', + separator='.', + backup=False): + self.content = content + self._separator = separator + self.filename = filename + self.__yaml_dict = content + self.content_type = content_type + self.backup = backup + self.load(content_type=self.content_type) + if self.__yaml_dict is None: + self.__yaml_dict = {} - if any([change[0] for change in changes]): - yed.write() + @property + def separator(self): + ''' getter method for yaml_dict ''' + return self._separator - atexit.register(Utils.cleanup, [fname]) + @separator.setter + def separator(self): + ''' getter method for yaml_dict ''' + return self._separator - return self._replace(fname, force) + @property + def yaml_dict(self): + ''' getter method for yaml_dict ''' + return self.__yaml_dict - return {'returncode': 0, 'updated': False} + @yaml_dict.setter + def yaml_dict(self, value): + ''' setter method for yaml_dict ''' + self.__yaml_dict = value - def _replace(self, fname, force=False): - '''return all pods ''' - cmd = ['-n', self.namespace, 'replace', '-f', fname] - if force: - cmd.append('--force') - return self.openshift_cmd(cmd) + @staticmethod + def parse_key(key, sep='.'): + '''parse the key allowing the appropriate separator''' + common_separators = list(Yedit.com_sep - set([sep])) + return re.findall(Yedit.re_key % ''.join(common_separators), key) - def _create_from_content(self, rname, content): - '''return all pods ''' - fname = '/tmp/%s' % rname - yed = Yedit(fname, content=content) - yed.write() + @staticmethod + def valid_key(key, sep='.'): + '''validate the incoming key''' + common_separators = list(Yedit.com_sep - set([sep])) + if not re.match(Yedit.re_valid_key % ''.join(common_separators), key): + return False - atexit.register(Utils.cleanup, [fname]) + return True - return self._create(fname) + @staticmethod + def remove_entry(data, key, sep='.'): + ''' remove data at location key ''' + if key == '' and isinstance(data, dict): + data.clear() + return True + elif key == '' and isinstance(data, list): + del data[:] + return True - def _create(self, fname): - '''return all pods ''' - return self.openshift_cmd(['create', '-f', fname, '-n', self.namespace]) + if not (key and Yedit.valid_key(key, sep)) and \ + isinstance(data, (list, dict)): + return None - def _delete(self, resource, rname, selector=None): - '''return all pods ''' - cmd = ['delete', resource, rname, '-n', self.namespace] - if selector: - cmd.append('--selector=%s' % selector) + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes[:-1]: + if dict_key and isinstance(data, dict): + data = data.get(dict_key, None) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None - return self.openshift_cmd(cmd) + # process last index for remove + # expected list entry + if key_indexes[-1][0]: + if isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 + del data[int(key_indexes[-1][0])] + return True - def _process(self, template_name, create=False, params=None, template_data=None): # noqa: E501 - '''return all pods ''' - cmd = ['process', '-n', self.namespace] - if template_data: - cmd.extend(['-f', '-']) - else: - cmd.append(template_name) - if params: - param_str = ["%s=%s" % (key, value) for key, value in params.items()] - cmd.append('-v') - cmd.extend(param_str) + # expected dict entry + elif key_indexes[-1][1]: + if isinstance(data, dict): + del data[key_indexes[-1][1]] + return True - results = self.openshift_cmd(cmd, output=True, input_data=template_data) + @staticmethod + def add_entry(data, key, item=None, sep='.'): + ''' Get an item from a dictionary with key notation a.b.c + d = {'a': {'b': 'c'}}} + key = a#b + return c + ''' + if key == '': + pass + elif (not (key and Yedit.valid_key(key, sep)) and + isinstance(data, (list, dict))): + return None - if results['returncode'] != 0 or not create: - return results + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes[:-1]: + if dict_key: + if isinstance(data, dict) and dict_key in data and data[dict_key]: # noqa: E501 + data = data[dict_key] + continue - fname = '/tmp/%s' % template_name - yed = Yedit(fname, results['results']) - yed.write() + elif data and not isinstance(data, dict): + return None - atexit.register(Utils.cleanup, [fname]) + data[dict_key] = {} + data = data[dict_key] - return self.openshift_cmd(['-n', self.namespace, 'create', '-f', fname]) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None - def _get(self, resource, rname=None, selector=None): - '''return a resource by name ''' - cmd = ['get', resource] - if selector: - cmd.append('--selector=%s' % selector) - if self.all_namespaces: - cmd.extend(['--all-namespaces']) - elif self.namespace: - cmd.extend(['-n', self.namespace]) + if key == '': + data = item - cmd.extend(['-o', 'json']) + # process last index for add + # expected list entry + elif key_indexes[-1][0] and isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 + data[int(key_indexes[-1][0])] = item - if rname: - cmd.append(rname) + # expected dict entry + elif key_indexes[-1][1] and isinstance(data, dict): + data[key_indexes[-1][1]] = item - rval = self.openshift_cmd(cmd, output=True) + return data - # Ensure results are retuned in an array - if 'items' in rval: - rval['results'] = rval['items'] - elif not isinstance(rval['results'], list): - rval['results'] = [rval['results']] + @staticmethod + def get_entry(data, key, sep='.'): + ''' Get an item from a dictionary with key notation a.b.c + d = {'a': {'b': 'c'}}} + key = a.b + return c + ''' + if key == '': + pass + elif (not (key and Yedit.valid_key(key, sep)) and + isinstance(data, (list, dict))): + return None - return rval + key_indexes = Yedit.parse_key(key, sep) + for arr_ind, dict_key in key_indexes: + if dict_key and isinstance(data, dict): + data = data.get(dict_key, None) + elif (arr_ind and isinstance(data, list) and + int(arr_ind) <= len(data) - 1): + data = data[int(arr_ind)] + else: + return None - def _schedulable(self, node=None, selector=None, schedulable=True): - ''' perform oadm manage-node scheduable ''' - cmd = ['manage-node'] - if node: - cmd.extend(node) - else: - cmd.append('--selector=%s' % selector) + return data - cmd.append('--schedulable=%s' % schedulable) + def write(self): + ''' write to file ''' + if not self.filename: + raise YeditException('Please specify a filename.') - return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') # noqa: E501 + if self.backup and self.file_exists(): + shutil.copy(self.filename, self.filename + '.orig') - def _list_pods(self, node=None, selector=None, pod_selector=None): - ''' perform oadm manage-node evacuate ''' - cmd = ['manage-node'] - if node: - cmd.extend(node) - else: - cmd.append('--selector=%s' % selector) - - if pod_selector: - cmd.append('--pod-selector=%s' % pod_selector) + tmp_filename = self.filename + '.yedit' + with open(tmp_filename, 'w') as yfd: + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + self.yaml_dict.fa.set_block_style() - cmd.extend(['--list-pods', '-o', 'json']) + yfd.write(yaml.dump(self.yaml_dict, Dumper=yaml.RoundTripDumper)) - return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + os.rename(tmp_filename, self.filename) - # pylint: disable=too-many-arguments - def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False): - ''' perform oadm manage-node evacuate ''' - cmd = ['manage-node'] - if node: - cmd.extend(node) - else: - cmd.append('--selector=%s' % selector) + return (True, self.yaml_dict) - if dry_run: - cmd.append('--dry-run') + def read(self): + ''' read from file ''' + # check if it exists + if self.filename is None or not self.file_exists(): + return None - if pod_selector: - cmd.append('--pod-selector=%s' % pod_selector) + contents = None + with open(self.filename) as yfd: + contents = yfd.read() - if grace_period: - cmd.append('--grace-period=%s' % int(grace_period)) + return contents - if force: - cmd.append('--force') + def file_exists(self): + ''' return whether file exists ''' + if os.path.exists(self.filename): + return True - cmd.append('--evacuate') + return False - return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') + def load(self, content_type='yaml'): + ''' return yaml file ''' + contents = self.read() - def _import_image(self, url=None, name=None, tag=None): - ''' perform image import ''' - cmd = ['import-image'] + if not contents and not self.content: + return None - image = '{0}'.format(name) - if tag: - image += ':{0}'.format(tag) + if self.content: + if isinstance(self.content, dict): + self.yaml_dict = self.content + return self.yaml_dict + elif isinstance(self.content, str): + contents = self.content - cmd.append(image) + # check if it is yaml + try: + if content_type == 'yaml' and contents: + self.yaml_dict = yaml.load(contents, yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + self.yaml_dict.fa.set_block_style() + elif content_type == 'json' and contents: + self.yaml_dict = json.loads(contents) + except yaml.YAMLError as err: + # Error loading yaml or json + raise YeditException('Problem with loading yaml file. %s' % err) - if url: - cmd.append('--from={0}/{1}'.format(url, image)) + return self.yaml_dict - cmd.append('-n{0}'.format(self.namespace)) + def get(self, key): + ''' get a specified key''' + try: + entry = Yedit.get_entry(self.yaml_dict, key, self.separator) + except KeyError: + entry = None - cmd.append('--confirm') - return self.openshift_cmd(cmd) + return entry - # pylint: disable=too-many-arguments - def openshift_cmd(self, cmd, oadm=False, output=False, output_type='json', input_data=None): - '''Base command for oc ''' - cmds = [] - if oadm: - cmds = ['/usr/bin/oadm'] - else: - cmds = ['/usr/bin/oc'] + def pop(self, path, key_or_item): + ''' remove a key, value pair from a dict or an item for a list''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None - cmds.extend(cmd) + if entry is None: + return (False, self.yaml_dict) - rval = {} - results = '' - err = None + if isinstance(entry, dict): + # pylint: disable=no-member,maybe-no-member + if key_or_item in entry: + entry.pop(key_or_item) + return (True, self.yaml_dict) + return (False, self.yaml_dict) - if self.verbose: - print ' '.join(cmds) + elif isinstance(entry, list): + # pylint: disable=no-member,maybe-no-member + ind = None + try: + ind = entry.index(key_or_item) + except ValueError: + return (False, self.yaml_dict) - proc = subprocess.Popen(cmds, - stdin=subprocess.PIPE, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - env={'KUBECONFIG': self.kubeconfig}) + entry.pop(ind) + return (True, self.yaml_dict) - stdout, stderr = proc.communicate(input_data) - rval = {"returncode": proc.returncode, - "results": results, - "cmd": ' '.join(cmds)} + return (False, self.yaml_dict) - if proc.returncode == 0: - if output: - if output_type == 'json': - try: - rval['results'] = json.loads(stdout) - except ValueError as err: - if "No JSON object could be decoded" in err.message: - err = err.message - elif output_type == 'raw': - rval['results'] = stdout + def delete(self, path): + ''' remove path from a dict''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None - if self.verbose: - print stdout - print stderr + if entry is None: + return (False, self.yaml_dict) - if err: - rval.update({"err": err, - "stderr": stderr, - "stdout": stdout, - "cmd": cmds}) + result = Yedit.remove_entry(self.yaml_dict, path, self.separator) + if not result: + return (False, self.yaml_dict) - else: - rval.update({"stderr": stderr, - "stdout": stdout, - "results": {}}) + return (True, self.yaml_dict) - return rval + def exists(self, path, value): + ''' check if value exists at path''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None + if isinstance(entry, list): + if value in entry: + return True + return False -class Utils(object): - ''' utilities for openshiftcli modules ''' - @staticmethod - def create_file(rname, data, ftype='yaml'): - ''' create a file in tmp with name and contents''' - path = os.path.join('/tmp', rname) - with open(path, 'w') as fds: - if ftype == 'yaml': - fds.write(yaml.dump(data, Dumper=yaml.RoundTripDumper)) + elif isinstance(entry, dict): + if isinstance(value, dict): + rval = False + for key, val in value.items(): + if entry[key] != val: + rval = False + break + else: + rval = True + return rval - elif ftype == 'json': - fds.write(json.dumps(data)) - else: - fds.write(data) + return value in entry - # Register cleanup when module is done - atexit.register(Utils.cleanup, [path]) - return path + return entry == value - @staticmethod - def create_files_from_contents(content, content_type=None): - '''Turn an array of dict: filename, content into a files array''' - if not isinstance(content, list): - content = [content] - files = [] - for item in content: - path = Utils.create_file(item['path'], item['data'], ftype=content_type) - files.append({'name': os.path.basename(path), 'path': path}) - return files + def append(self, path, value): + '''append value to a list''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None - @staticmethod - def cleanup(files): - '''Clean up on exit ''' - for sfile in files: - if os.path.exists(sfile): - if os.path.isdir(sfile): - shutil.rmtree(sfile) - elif os.path.isfile(sfile): - os.remove(sfile) + if entry is None: + self.put(path, []) + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + if not isinstance(entry, list): + return (False, self.yaml_dict) - @staticmethod - def exists(results, _name): - ''' Check to see if the results include the name ''' - if not results: - return False + # pylint: disable=no-member,maybe-no-member + entry.append(value) + return (True, self.yaml_dict) - if Utils.find_result(results, _name): - return True + # pylint: disable=too-many-arguments + def update(self, path, value, index=None, curr_value=None): + ''' put path, value into a dict ''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None - return False - - @staticmethod - def find_result(results, _name): - ''' Find the specified result by name''' - rval = None - for result in results: - if 'metadata' in result and result['metadata']['name'] == _name: - rval = result - break + if isinstance(entry, dict): + # pylint: disable=no-member,maybe-no-member + if not isinstance(value, dict): + raise YeditException('Cannot replace key, value entry in ' + + 'dict with non-dict type. value=[%s] [%s]' % (value, type(value))) # noqa: E501 - return rval + entry.update(value) + return (True, self.yaml_dict) - @staticmethod - def get_resource_file(sfile, sfile_type='yaml'): - ''' return the service file ''' - contents = None - with open(sfile) as sfd: - contents = sfd.read() + elif isinstance(entry, list): + # pylint: disable=no-member,maybe-no-member + ind = None + if curr_value: + try: + ind = entry.index(curr_value) + except ValueError: + return (False, self.yaml_dict) - if sfile_type == 'yaml': - contents = yaml.load(contents, yaml.RoundTripLoader) - elif sfile_type == 'json': - contents = json.loads(contents) + elif index is not None: + ind = index - return contents + if ind is not None and entry[ind] != value: + entry[ind] = value + return (True, self.yaml_dict) - # Disabling too-many-branches. This is a yaml dictionary comparison function - # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements - @staticmethod - def check_def_equal(user_def, result_def, skip_keys=None, debug=False): - ''' Given a user defined definition, compare it with the results given back by our query. ''' + # see if it exists in the list + try: + ind = entry.index(value) + except ValueError: + # doesn't exist, append it + entry.append(value) + return (True, self.yaml_dict) - # Currently these values are autogenerated and we do not need to check them - skip = ['metadata', 'status'] - if skip_keys: - skip.extend(skip_keys) + # already exists, return + if ind is not None: + return (False, self.yaml_dict) + return (False, self.yaml_dict) - for key, value in result_def.items(): - if key in skip: - continue + def put(self, path, value): + ''' put path, value into a dict ''' + try: + entry = Yedit.get_entry(self.yaml_dict, path, self.separator) + except KeyError: + entry = None - # Both are lists - if isinstance(value, list): - if key not in user_def: - if debug: - print 'User data does not have key [%s]' % key - print 'User data: %s' % user_def - return False + if entry == value: + return (False, self.yaml_dict) - if not isinstance(user_def[key], list): - if debug: - print 'user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key]) - return False + # deepcopy didn't work + tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, + default_flow_style=False), + yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + tmp_copy.fa.set_block_style() + result = Yedit.add_entry(tmp_copy, path, value, self.separator) + if not result: + return (False, self.yaml_dict) - if len(user_def[key]) != len(value): - if debug: - print "List lengths are not equal." - print "key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value)) - print "user_def: %s" % user_def[key] - print "value: %s" % value - return False + self.yaml_dict = tmp_copy - for values in zip(user_def[key], value): - if isinstance(values[0], dict) and isinstance(values[1], dict): - if debug: - print 'sending list - list' - print type(values[0]) - print type(values[1]) - result = Utils.check_def_equal(values[0], values[1], skip_keys=skip_keys, debug=debug) - if not result: - print 'list compare returned false' - return False + return (True, self.yaml_dict) - elif value != user_def[key]: - if debug: - print 'value should be identical' - print value - print user_def[key] - return False + def create(self, path, value): + ''' create a yaml file ''' + if not self.file_exists(): + # deepcopy didn't work + tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, default_flow_style=False), # noqa: E501 + yaml.RoundTripLoader) + # pylint: disable=no-member + if hasattr(self.yaml_dict, 'fa'): + tmp_copy.fa.set_block_style() + result = Yedit.add_entry(tmp_copy, path, value, self.separator) + if result: + self.yaml_dict = tmp_copy + return (True, self.yaml_dict) - # recurse on a dictionary - elif isinstance(value, dict): - if key not in user_def: - if debug: - print "user_def does not have key [%s]" % key - return False - if not isinstance(user_def[key], dict): - if debug: - print "dict returned false: not instance of dict" - return False + return (False, self.yaml_dict) - # before passing ensure keys match - api_values = set(value.keys()) - set(skip) - user_values = set(user_def[key].keys()) - set(skip) - if api_values != user_values: - if debug: - print "keys are not equal in dict" - print api_values - print user_values - return False + @staticmethod + def get_curr_value(invalue, val_type): + '''return the current value''' + if invalue is None: + return None - result = Utils.check_def_equal(user_def[key], value, skip_keys=skip_keys, debug=debug) - if not result: - if debug: - print "dict returned false" - print result - return False + curr_value = invalue + if val_type == 'yaml': + curr_value = yaml.load(invalue) + elif val_type == 'json': + curr_value = json.loads(invalue) - # Verify each key, value pair is the same - else: - if key not in user_def or value != user_def[key]: - if debug: - print "value not equal; user_def does not have key" - print key - print value - if key in user_def: - print user_def[key] - return False + return curr_value - if debug: - print 'returning true' - return True + @staticmethod + def parse_value(inc_value, vtype=''): + '''determine value type passed''' + true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', + 'on', 'On', 'ON', ] + false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', + 'off', 'Off', 'OFF'] + # It came in as a string but you didn't specify value_type as string + # we will convert to bool if it matches any of the above cases + if isinstance(inc_value, str) and 'bool' in vtype: + if inc_value not in true_bools and inc_value not in false_bools: + raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' + % (inc_value, vtype)) + elif isinstance(inc_value, bool) and 'str' in vtype: + inc_value = str(inc_value) -class OpenShiftCLIConfig(object): - '''Generic Config''' - def __init__(self, rname, namespace, kubeconfig, options): - self.kubeconfig = kubeconfig - self.name = rname - self.namespace = namespace - self._options = options + # If vtype is not str then go ahead and attempt to yaml load it. + if isinstance(inc_value, str) and 'str' not in vtype: + try: + inc_value = yaml.load(inc_value) + except Exception: + raise YeditException('Could not determine type of incoming ' + + 'value. value=[%s] vtype=[%s]' + % (type(inc_value), vtype)) - @property - def config_options(self): - ''' return config options ''' - return self._options + return inc_value - def to_option_list(self): - '''return all options as a string''' - return self.stringify() + # pylint: disable=too-many-return-statements,too-many-branches + @staticmethod + def run_ansible(module): + '''perform the idempotent crud operations''' + yamlfile = Yedit(filename=module.params['src'], + backup=module.params['backup'], + separator=module.params['separator']) - def stringify(self): - ''' return the options hash as cli params in a string ''' - rval = [] - for key, data in self.config_options.items(): - if data['include'] \ - and (data['value'] or isinstance(data['value'], int)): - rval.append('--%s=%s' % (key.replace('_', '-'), data['value'])) + if module.params['src']: + rval = yamlfile.load() - return rval + if yamlfile.yaml_dict is None and \ + module.params['state'] != 'present': + return {'failed': True, + 'msg': 'Error opening file [%s]. Verify that the ' + + 'file exists, that it is has correct' + + ' permissions, and is valid yaml.'} + if module.params['state'] == 'list': + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + yamlfile.yaml_dict = content -class YeditException(Exception): - ''' Exception class for Yedit ''' - pass + if module.params['key']: + rval = yamlfile.get(module.params['key']) or {} + return {'changed': False, 'result': rval, 'state': "list"} -class Yedit(object): - ''' Class to modify yaml files ''' - re_valid_key = r"(((\[-?\d+\])|([0-9a-zA-Z%s/_-]+)).?)+$" - re_key = r"(?:\[(-?\d+)\])|([0-9a-zA-Z%s/_-]+)" - com_sep = set(['.', '#', '|', ':']) + elif module.params['state'] == 'absent': + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) + yamlfile.yaml_dict = content - # pylint: disable=too-many-arguments - def __init__(self, - filename=None, - content=None, - content_type='yaml', - separator='.', - backup=False): - self.content = content - self._separator = separator - self.filename = filename - self.__yaml_dict = content - self.content_type = content_type - self.backup = backup - self.load(content_type=self.content_type) - if self.__yaml_dict is None: - self.__yaml_dict = {} + if module.params['update']: + rval = yamlfile.pop(module.params['key'], + module.params['value']) + else: + rval = yamlfile.delete(module.params['key']) - @property - def separator(self): - ''' getter method for yaml_dict ''' - return self._separator + if rval[0] and module.params['src']: + yamlfile.write() - @separator.setter - def separator(self): - ''' getter method for yaml_dict ''' - return self._separator + return {'changed': rval[0], 'result': rval[1], 'state': "absent"} - @property - def yaml_dict(self): - ''' getter method for yaml_dict ''' - return self.__yaml_dict + elif module.params['state'] == 'present': + # check if content is different than what is in the file + if module.params['content']: + content = Yedit.parse_value(module.params['content'], + module.params['content_type']) - @yaml_dict.setter - def yaml_dict(self, value): - ''' setter method for yaml_dict ''' - self.__yaml_dict = value + # We had no edits to make and the contents are the same + if yamlfile.yaml_dict == content and \ + module.params['value'] is None: + return {'changed': False, + 'result': yamlfile.yaml_dict, + 'state': "present"} - @staticmethod - def parse_key(key, sep='.'): - '''parse the key allowing the appropriate separator''' - common_separators = list(Yedit.com_sep - set([sep])) - return re.findall(Yedit.re_key % ''.join(common_separators), key) + yamlfile.yaml_dict = content - @staticmethod - def valid_key(key, sep='.'): - '''validate the incoming key''' - common_separators = list(Yedit.com_sep - set([sep])) - if not re.match(Yedit.re_valid_key % ''.join(common_separators), key): - return False + # we were passed a value; parse it + if module.params['value']: + value = Yedit.parse_value(module.params['value'], + module.params['value_type']) + key = module.params['key'] + if module.params['update']: + # pylint: disable=line-too-long + curr_value = Yedit.get_curr_value(Yedit.parse_value(module.params['curr_value']), # noqa: E501 + module.params['curr_value_format']) # noqa: E501 - return True + rval = yamlfile.update(key, value, module.params['index'], curr_value) # noqa: E501 - @staticmethod - def remove_entry(data, key, sep='.'): - ''' remove data at location key ''' - if key == '' and isinstance(data, dict): - data.clear() - return True - elif key == '' and isinstance(data, list): - del data[:] - return True + elif module.params['append']: + rval = yamlfile.append(key, value) + else: + rval = yamlfile.put(key, value) - if not (key and Yedit.valid_key(key, sep)) and \ - isinstance(data, (list, dict)): - return None + if rval[0] and module.params['src']: + yamlfile.write() - key_indexes = Yedit.parse_key(key, sep) - for arr_ind, dict_key in key_indexes[:-1]: - if dict_key and isinstance(data, dict): - data = data.get(dict_key, None) - elif (arr_ind and isinstance(data, list) and - int(arr_ind) <= len(data) - 1): - data = data[int(arr_ind)] - else: - return None + return {'changed': rval[0], + 'result': rval[1], 'state': "present"} - # process last index for remove - # expected list entry - if key_indexes[-1][0]: - if isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 - del data[int(key_indexes[-1][0])] - return True + # no edits to make + if module.params['src']: + # pylint: disable=redefined-variable-type + rval = yamlfile.write() + return {'changed': rval[0], + 'result': rval[1], + 'state': "present"} - # expected dict entry - elif key_indexes[-1][1]: - if isinstance(data, dict): - del data[key_indexes[-1][1]] - return True + return {'failed': True, 'msg': 'Unkown state passed'} +# pylint: disable=too-many-lines +# noqa: E301,E302,E303,T001 - @staticmethod - def add_entry(data, key, item=None, sep='.'): - ''' Get an item from a dictionary with key notation a.b.c - d = {'a': {'b': 'c'}}} - key = a#b - return c - ''' - if key == '': - pass - elif (not (key and Yedit.valid_key(key, sep)) and - isinstance(data, (list, dict))): - return None - key_indexes = Yedit.parse_key(key, sep) - for arr_ind, dict_key in key_indexes[:-1]: - if dict_key: - if isinstance(data, dict) and dict_key in data and data[dict_key]: # noqa: E501 - data = data[dict_key] - continue +class OpenShiftCLIError(Exception): + '''Exception class for openshiftcli''' + pass - elif data and not isinstance(data, dict): - return None - data[dict_key] = {} - data = data[dict_key] +# pylint: disable=too-few-public-methods +class OpenShiftCLI(object): + ''' Class to wrap the command line tools ''' + def __init__(self, + namespace, + kubeconfig='/etc/origin/master/admin.kubeconfig', + verbose=False, + all_namespaces=False): + ''' Constructor for OpenshiftCLI ''' + self.namespace = namespace + self.verbose = verbose + self.kubeconfig = kubeconfig + self.all_namespaces = all_namespaces - elif (arr_ind and isinstance(data, list) and - int(arr_ind) <= len(data) - 1): - data = data[int(arr_ind)] - else: - return None + # Pylint allows only 5 arguments to be passed. + # pylint: disable=too-many-arguments + def _replace_content(self, resource, rname, content, force=False, sep='.'): + ''' replace the current object with the content ''' + res = self._get(resource, rname) + if not res['results']: + return res - if key == '': - data = item + fname = '/tmp/%s' % rname + yed = Yedit(fname, res['results'][0], separator=sep) + changes = [] + for key, value in content.items(): + changes.append(yed.put(key, value)) - # process last index for add - # expected list entry - elif key_indexes[-1][0] and isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501 - data[int(key_indexes[-1][0])] = item + if any([change[0] for change in changes]): + yed.write() - # expected dict entry - elif key_indexes[-1][1] and isinstance(data, dict): - data[key_indexes[-1][1]] = item + atexit.register(Utils.cleanup, [fname]) - return data + return self._replace(fname, force) - @staticmethod - def get_entry(data, key, sep='.'): - ''' Get an item from a dictionary with key notation a.b.c - d = {'a': {'b': 'c'}}} - key = a.b - return c - ''' - if key == '': - pass - elif (not (key and Yedit.valid_key(key, sep)) and - isinstance(data, (list, dict))): - return None + return {'returncode': 0, 'updated': False} - key_indexes = Yedit.parse_key(key, sep) - for arr_ind, dict_key in key_indexes: - if dict_key and isinstance(data, dict): - data = data.get(dict_key, None) - elif (arr_ind and isinstance(data, list) and - int(arr_ind) <= len(data) - 1): - data = data[int(arr_ind)] - else: - return None + def _replace(self, fname, force=False): + '''return all pods ''' + cmd = ['-n', self.namespace, 'replace', '-f', fname] + if force: + cmd.append('--force') + return self.openshift_cmd(cmd) - return data + def _create_from_content(self, rname, content): + '''return all pods ''' + fname = '/tmp/%s' % rname + yed = Yedit(fname, content=content) + yed.write() - def write(self): - ''' write to file ''' - if not self.filename: - raise YeditException('Please specify a filename.') + atexit.register(Utils.cleanup, [fname]) - if self.backup and self.file_exists(): - shutil.copy(self.filename, self.filename + '.orig') + return self._create(fname) - tmp_filename = self.filename + '.yedit' - with open(tmp_filename, 'w') as yfd: - # pylint: disable=no-member - if hasattr(self.yaml_dict, 'fa'): - self.yaml_dict.fa.set_block_style() + def _create(self, fname): + '''return all pods ''' + return self.openshift_cmd(['create', '-f', fname, '-n', self.namespace]) - yfd.write(yaml.dump(self.yaml_dict, Dumper=yaml.RoundTripDumper)) + def _delete(self, resource, rname, selector=None): + '''return all pods ''' + cmd = ['delete', resource, rname, '-n', self.namespace] + if selector: + cmd.append('--selector=%s' % selector) - os.rename(tmp_filename, self.filename) + return self.openshift_cmd(cmd) - return (True, self.yaml_dict) + def _process(self, template_name, create=False, params=None, template_data=None): # noqa: E501 + '''return all pods ''' + cmd = ['process', '-n', self.namespace] + if template_data: + cmd.extend(['-f', '-']) + else: + cmd.append(template_name) + if params: + param_str = ["%s=%s" % (key, value) for key, value in params.items()] + cmd.append('-v') + cmd.extend(param_str) - def read(self): - ''' read from file ''' - # check if it exists - if self.filename is None or not self.file_exists(): - return None + results = self.openshift_cmd(cmd, output=True, input_data=template_data) - contents = None - with open(self.filename) as yfd: - contents = yfd.read() + if results['returncode'] != 0 or not create: + return results - return contents + fname = '/tmp/%s' % template_name + yed = Yedit(fname, results['results']) + yed.write() - def file_exists(self): - ''' return whether file exists ''' - if os.path.exists(self.filename): - return True + atexit.register(Utils.cleanup, [fname]) - return False + return self.openshift_cmd(['-n', self.namespace, 'create', '-f', fname]) - def load(self, content_type='yaml'): - ''' return yaml file ''' - contents = self.read() + def _get(self, resource, rname=None, selector=None): + '''return a resource by name ''' + cmd = ['get', resource] + if selector: + cmd.append('--selector=%s' % selector) + if self.all_namespaces: + cmd.extend(['--all-namespaces']) + elif self.namespace: + cmd.extend(['-n', self.namespace]) - if not contents and not self.content: - return None + cmd.extend(['-o', 'json']) - if self.content: - if isinstance(self.content, dict): - self.yaml_dict = self.content - return self.yaml_dict - elif isinstance(self.content, str): - contents = self.content + if rname: + cmd.append(rname) - # check if it is yaml - try: - if content_type == 'yaml' and contents: - self.yaml_dict = yaml.load(contents, yaml.RoundTripLoader) - # pylint: disable=no-member - if hasattr(self.yaml_dict, 'fa'): - self.yaml_dict.fa.set_block_style() - elif content_type == 'json' and contents: - self.yaml_dict = json.loads(contents) - except yaml.YAMLError as err: - # Error loading yaml or json - raise YeditException('Problem with loading yaml file. %s' % err) + rval = self.openshift_cmd(cmd, output=True) - return self.yaml_dict + # Ensure results are retuned in an array + if 'items' in rval: + rval['results'] = rval['items'] + elif not isinstance(rval['results'], list): + rval['results'] = [rval['results']] - def get(self, key): - ''' get a specified key''' - try: - entry = Yedit.get_entry(self.yaml_dict, key, self.separator) - except KeyError: - entry = None + return rval - return entry + def _schedulable(self, node=None, selector=None, schedulable=True): + ''' perform oadm manage-node scheduable ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) - def pop(self, path, key_or_item): - ''' remove a key, value pair from a dict or an item for a list''' - try: - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - except KeyError: - entry = None + cmd.append('--schedulable=%s' % schedulable) - if entry is None: - return (False, self.yaml_dict) + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') # noqa: E501 - if isinstance(entry, dict): - # pylint: disable=no-member,maybe-no-member - if key_or_item in entry: - entry.pop(key_or_item) - return (True, self.yaml_dict) - return (False, self.yaml_dict) + def _list_pods(self, node=None, selector=None, pod_selector=None): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) - elif isinstance(entry, list): - # pylint: disable=no-member,maybe-no-member - ind = None - try: - ind = entry.index(key_or_item) - except ValueError: - return (False, self.yaml_dict) + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) - entry.pop(ind) - return (True, self.yaml_dict) + cmd.extend(['--list-pods', '-o', 'json']) - return (False, self.yaml_dict) + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') - def delete(self, path): - ''' remove path from a dict''' - try: - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - except KeyError: - entry = None + # pylint: disable=too-many-arguments + def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False): + ''' perform oadm manage-node evacuate ''' + cmd = ['manage-node'] + if node: + cmd.extend(node) + else: + cmd.append('--selector=%s' % selector) - if entry is None: - return (False, self.yaml_dict) + if dry_run: + cmd.append('--dry-run') - result = Yedit.remove_entry(self.yaml_dict, path, self.separator) - if not result: - return (False, self.yaml_dict) + if pod_selector: + cmd.append('--pod-selector=%s' % pod_selector) - return (True, self.yaml_dict) + if grace_period: + cmd.append('--grace-period=%s' % int(grace_period)) - def exists(self, path, value): - ''' check if value exists at path''' - try: - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - except KeyError: - entry = None + if force: + cmd.append('--force') - if isinstance(entry, list): - if value in entry: - return True - return False + cmd.append('--evacuate') - elif isinstance(entry, dict): - if isinstance(value, dict): - rval = False - for key, val in value.items(): - if entry[key] != val: - rval = False - break - else: - rval = True - return rval + return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw') - return value in entry + def _import_image(self, url=None, name=None, tag=None): + ''' perform image import ''' + cmd = ['import-image'] - return entry == value + image = '{0}'.format(name) + if tag: + image += ':{0}'.format(tag) - def append(self, path, value): - '''append value to a list''' - try: - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - except KeyError: - entry = None + cmd.append(image) - if entry is None: - self.put(path, []) - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - if not isinstance(entry, list): - return (False, self.yaml_dict) + if url: + cmd.append('--from={0}/{1}'.format(url, image)) - # pylint: disable=no-member,maybe-no-member - entry.append(value) - return (True, self.yaml_dict) + cmd.append('-n{0}'.format(self.namespace)) + + cmd.append('--confirm') + return self.openshift_cmd(cmd) # pylint: disable=too-many-arguments - def update(self, path, value, index=None, curr_value=None): - ''' put path, value into a dict ''' - try: - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - except KeyError: - entry = None + def openshift_cmd(self, cmd, oadm=False, output=False, output_type='json', input_data=None): + '''Base command for oc ''' + cmds = [] + if oadm: + cmds = ['/usr/bin/oadm'] + else: + cmds = ['/usr/bin/oc'] - if isinstance(entry, dict): - # pylint: disable=no-member,maybe-no-member - if not isinstance(value, dict): - raise YeditException('Cannot replace key, value entry in ' + - 'dict with non-dict type. value=[%s] [%s]' % (value, type(value))) # noqa: E501 + cmds.extend(cmd) - entry.update(value) - return (True, self.yaml_dict) + rval = {} + results = '' + err = None - elif isinstance(entry, list): - # pylint: disable=no-member,maybe-no-member - ind = None - if curr_value: - try: - ind = entry.index(curr_value) - except ValueError: - return (False, self.yaml_dict) + if self.verbose: + print(' '.join(cmds)) - elif index is not None: - ind = index + proc = subprocess.Popen(cmds, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env={'KUBECONFIG': self.kubeconfig}) - if ind is not None and entry[ind] != value: - entry[ind] = value - return (True, self.yaml_dict) + stdout, stderr = proc.communicate(input_data) + rval = {"returncode": proc.returncode, + "results": results, + "cmd": ' '.join(cmds)} - # see if it exists in the list - try: - ind = entry.index(value) - except ValueError: - # doesn't exist, append it - entry.append(value) - return (True, self.yaml_dict) + if proc.returncode == 0: + if output: + if output_type == 'json': + try: + rval['results'] = json.loads(stdout) + except ValueError as err: + if "No JSON object could be decoded" in str(err): + err = str(err) + elif output_type == 'raw': + rval['results'] = stdout - # already exists, return - if ind is not None: - return (False, self.yaml_dict) - return (False, self.yaml_dict) + if self.verbose: + print(stdout) + print(stderr) - def put(self, path, value): - ''' put path, value into a dict ''' - try: - entry = Yedit.get_entry(self.yaml_dict, path, self.separator) - except KeyError: - entry = None + if err: + rval.update({"err": err, + "stderr": stderr, + "stdout": stdout, + "cmd": cmds}) - if entry == value: - return (False, self.yaml_dict) + else: + rval.update({"stderr": stderr, + "stdout": stdout, + "results": {}}) - # deepcopy didn't work - tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, - default_flow_style=False), - yaml.RoundTripLoader) - # pylint: disable=no-member - if hasattr(self.yaml_dict, 'fa'): - tmp_copy.fa.set_block_style() - result = Yedit.add_entry(tmp_copy, path, value, self.separator) - if not result: - return (False, self.yaml_dict) + return rval + + +class Utils(object): + ''' utilities for openshiftcli modules ''' + @staticmethod + def create_file(rname, data, ftype='yaml'): + ''' create a file in tmp with name and contents''' + path = os.path.join('/tmp', rname) + with open(path, 'w') as fds: + if ftype == 'yaml': + fds.write(yaml.dump(data, Dumper=yaml.RoundTripDumper)) - self.yaml_dict = tmp_copy + elif ftype == 'json': + fds.write(json.dumps(data)) + else: + fds.write(data) - return (True, self.yaml_dict) + # Register cleanup when module is done + atexit.register(Utils.cleanup, [path]) + return path - def create(self, path, value): - ''' create a yaml file ''' - if not self.file_exists(): - # deepcopy didn't work - tmp_copy = yaml.load(yaml.round_trip_dump(self.yaml_dict, default_flow_style=False), # noqa: E501 - yaml.RoundTripLoader) - # pylint: disable=no-member - if hasattr(self.yaml_dict, 'fa'): - tmp_copy.fa.set_block_style() - result = Yedit.add_entry(tmp_copy, path, value, self.separator) - if result: - self.yaml_dict = tmp_copy - return (True, self.yaml_dict) + @staticmethod + def create_files_from_contents(content, content_type=None): + '''Turn an array of dict: filename, content into a files array''' + if not isinstance(content, list): + content = [content] + files = [] + for item in content: + path = Utils.create_file(item['path'], item['data'], ftype=content_type) + files.append({'name': os.path.basename(path), 'path': path}) + return files - return (False, self.yaml_dict) + @staticmethod + def cleanup(files): + '''Clean up on exit ''' + for sfile in files: + if os.path.exists(sfile): + if os.path.isdir(sfile): + shutil.rmtree(sfile) + elif os.path.isfile(sfile): + os.remove(sfile) @staticmethod - def get_curr_value(invalue, val_type): - '''return the current value''' - if invalue is None: - return None + def exists(results, _name): + ''' Check to see if the results include the name ''' + if not results: + return False - curr_value = invalue - if val_type == 'yaml': - curr_value = yaml.load(invalue) - elif val_type == 'json': - curr_value = json.loads(invalue) + if Utils.find_result(results, _name): + return True - return curr_value + return False @staticmethod - def parse_value(inc_value, vtype=''): - '''determine value type passed''' - true_bools = ['y', 'Y', 'yes', 'Yes', 'YES', 'true', 'True', 'TRUE', - 'on', 'On', 'ON', ] - false_bools = ['n', 'N', 'no', 'No', 'NO', 'false', 'False', 'FALSE', - 'off', 'Off', 'OFF'] + def find_result(results, _name): + ''' Find the specified result by name''' + rval = None + for result in results: + if 'metadata' in result and result['metadata']['name'] == _name: + rval = result + break - # It came in as a string but you didn't specify value_type as string - # we will convert to bool if it matches any of the above cases - if isinstance(inc_value, str) and 'bool' in vtype: - if inc_value not in true_bools and inc_value not in false_bools: - raise YeditException('Not a boolean type. str=[%s] vtype=[%s]' - % (inc_value, vtype)) - elif isinstance(inc_value, bool) and 'str' in vtype: - inc_value = str(inc_value) + return rval - # If vtype is not str then go ahead and attempt to yaml load it. - if isinstance(inc_value, str) and 'str' not in vtype: - try: - inc_value = yaml.load(inc_value) - except Exception: - raise YeditException('Could not determine type of incoming ' + - 'value. value=[%s] vtype=[%s]' - % (type(inc_value), vtype)) + @staticmethod + def get_resource_file(sfile, sfile_type='yaml'): + ''' return the service file ''' + contents = None + with open(sfile) as sfd: + contents = sfd.read() - return inc_value + if sfile_type == 'yaml': + contents = yaml.load(contents, yaml.RoundTripLoader) + elif sfile_type == 'json': + contents = json.loads(contents) - # pylint: disable=too-many-return-statements,too-many-branches + return contents + + # Disabling too-many-branches. This is a yaml dictionary comparison function + # pylint: disable=too-many-branches,too-many-return-statements,too-many-statements @staticmethod - def run_ansible(module): - '''perform the idempotent crud operations''' - yamlfile = Yedit(filename=module.params['src'], - backup=module.params['backup'], - separator=module.params['separator']) + def check_def_equal(user_def, result_def, skip_keys=None, debug=False): + ''' Given a user defined definition, compare it with the results given back by our query. ''' - if module.params['src']: - rval = yamlfile.load() + # Currently these values are autogenerated and we do not need to check them + skip = ['metadata', 'status'] + if skip_keys: + skip.extend(skip_keys) - if yamlfile.yaml_dict is None and \ - module.params['state'] != 'present': - return {'failed': True, - 'msg': 'Error opening file [%s]. Verify that the ' + - 'file exists, that it is has correct' + - ' permissions, and is valid yaml.'} + for key, value in result_def.items(): + if key in skip: + continue - if module.params['state'] == 'list': - if module.params['content']: - content = Yedit.parse_value(module.params['content'], - module.params['content_type']) - yamlfile.yaml_dict = content + # Both are lists + if isinstance(value, list): + if key not in user_def: + if debug: + print('User data does not have key [%s]' % key) + print('User data: %s' % user_def) + return False - if module.params['key']: - rval = yamlfile.get(module.params['key']) or {} + if not isinstance(user_def[key], list): + if debug: + print('user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key])) + return False - return {'changed': False, 'result': rval, 'state': "list"} + if len(user_def[key]) != len(value): + if debug: + print("List lengths are not equal.") + print("key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value))) + print("user_def: %s" % user_def[key]) + print("value: %s" % value) + return False - elif module.params['state'] == 'absent': - if module.params['content']: - content = Yedit.parse_value(module.params['content'], - module.params['content_type']) - yamlfile.yaml_dict = content + for values in zip(user_def[key], value): + if isinstance(values[0], dict) and isinstance(values[1], dict): + if debug: + print('sending list - list') + print(type(values[0])) + print(type(values[1])) + result = Utils.check_def_equal(values[0], values[1], skip_keys=skip_keys, debug=debug) + if not result: + print('list compare returned false') + return False - if module.params['update']: - rval = yamlfile.pop(module.params['key'], - module.params['value']) - else: - rval = yamlfile.delete(module.params['key']) + elif value != user_def[key]: + if debug: + print('value should be identical') + print(value) + print(user_def[key]) + return False - if rval[0] and module.params['src']: - yamlfile.write() + # recurse on a dictionary + elif isinstance(value, dict): + if key not in user_def: + if debug: + print("user_def does not have key [%s]" % key) + return False + if not isinstance(user_def[key], dict): + if debug: + print("dict returned false: not instance of dict") + return False - return {'changed': rval[0], 'result': rval[1], 'state': "absent"} + # before passing ensure keys match + api_values = set(value.keys()) - set(skip) + user_values = set(user_def[key].keys()) - set(skip) + if api_values != user_values: + if debug: + print("keys are not equal in dict") + print(api_values) + print(user_values) + return False - elif module.params['state'] == 'present': - # check if content is different than what is in the file - if module.params['content']: - content = Yedit.parse_value(module.params['content'], - module.params['content_type']) + result = Utils.check_def_equal(user_def[key], value, skip_keys=skip_keys, debug=debug) + if not result: + if debug: + print("dict returned false") + print(result) + return False - # We had no edits to make and the contents are the same - if yamlfile.yaml_dict == content and \ - module.params['value'] is None: - return {'changed': False, - 'result': yamlfile.yaml_dict, - 'state': "present"} + # Verify each key, value pair is the same + else: + if key not in user_def or value != user_def[key]: + if debug: + print("value not equal; user_def does not have key") + print(key) + print(value) + if key in user_def: + print(user_def[key]) + return False - yamlfile.yaml_dict = content + if debug: + print('returning true') + return True - # we were passed a value; parse it - if module.params['value']: - value = Yedit.parse_value(module.params['value'], - module.params['value_type']) - key = module.params['key'] - if module.params['update']: - # pylint: disable=line-too-long - curr_value = Yedit.get_curr_value(Yedit.parse_value(module.params['curr_value']), # noqa: E501 - module.params['curr_value_format']) # noqa: E501 - rval = yamlfile.update(key, value, module.params['index'], curr_value) # noqa: E501 +class OpenShiftCLIConfig(object): + '''Generic Config''' + def __init__(self, rname, namespace, kubeconfig, options): + self.kubeconfig = kubeconfig + self.name = rname + self.namespace = namespace + self._options = options - elif module.params['append']: - rval = yamlfile.append(key, value) - else: - rval = yamlfile.put(key, value) + @property + def config_options(self): + ''' return config options ''' + return self._options - if rval[0] and module.params['src']: - yamlfile.write() + def to_option_list(self): + '''return all options as a string''' + return self.stringify() - return {'changed': rval[0], - 'result': rval[1], 'state': "present"} + def stringify(self): + ''' return the options hash as cli params in a string ''' + rval = [] + for key, data in self.config_options.items(): + if data['include'] \ + and (data['value'] or isinstance(data['value'], int)): + rval.append('--%s=%s' % (key.replace('_', '-'), data['value'])) - # no edits to make - if module.params['src']: - # pylint: disable=redefined-variable-type - rval = yamlfile.write() - return {'changed': rval[0], - 'result': rval[1], - 'state': "present"} + return rval - return {'failed': True, 'msg': 'Unkown state passed'} +# noqa: E302,E301 # pylint: disable=too-many-instance-attributes @@ -1335,6 +1339,7 @@ class OCRoute(OpenShiftCLI): skip = [] return not Utils.check_def_equal(self.config.data, self.route.yaml_dict, skip_keys=skip, debug=True) + # pylint: disable=too-many-return-statements,too-many-branches @staticmethod def run_ansible(params, files, check_mode=False): ''' run the idempotent asnible code diff --git a/roles/lib_openshift/src/ansible/oc_edit.py b/roles/lib_openshift/src/ansible/oc_edit.py new file mode 100644 index 000000000..5c5954747 --- /dev/null +++ b/roles/lib_openshift/src/ansible/oc_edit.py @@ -0,0 +1,48 @@ +# pylint: skip-file +# flake8: noqa + + +def main(): + ''' + ansible oc module for editing objects + ''' + + module = AnsibleModule( + argument_spec=dict( + kubeconfig=dict(default='/etc/origin/master/admin.kubeconfig', type='str'), + state=dict(default='present', type='str', + choices=['present']), + debug=dict(default=False, type='bool'), + namespace=dict(default='default', type='str'), + name=dict(default=None, required=True, type='str'), + kind=dict(required=True, + type='str', + choices=['dc', 'deploymentconfig', + 'rc', 'replicationcontroller', + 'svc', 'service', + 'scc', 'securitycontextconstraints', + 'ns', 'namespace', 'project', 'projects', + 'is', 'imagestream', + 'istag', 'imagestreamtag', + 'bc', 'buildconfig', + 'routes', + 'node', + 'secret', + 'pv', 'persistentvolume']), + file_name=dict(default=None, type='str'), + file_format=dict(default='yaml', type='str'), + content=dict(default=None, required=True, type='dict'), + force=dict(default=False, type='bool'), + separator=dict(default='.', type='str'), + ), + supports_check_mode=True, + ) + + rval = Edit.run_ansible(module.params, module.check_mode) + if 'failed' in rval: + module.fail_json(**rval) + + module.exit_json(**rval) + +if __name__ == '__main__': + main() diff --git a/roles/lib_openshift/src/class/oc_edit.py b/roles/lib_openshift/src/class/oc_edit.py new file mode 100644 index 000000000..0734e2085 --- /dev/null +++ b/roles/lib_openshift/src/class/oc_edit.py @@ -0,0 +1,94 @@ +# pylint: skip-file +# flake8: noqa + +class Edit(OpenShiftCLI): + ''' Class to wrap the oc command line tools + ''' + # pylint: disable=too-many-arguments + def __init__(self, + kind, + namespace, + resource_name=None, + kubeconfig='/etc/origin/master/admin.kubeconfig', + separator='.', + verbose=False): + ''' Constructor for OpenshiftOC ''' + super(Edit, self).__init__(namespace, kubeconfig) + self.namespace = namespace + self.kind = kind + self.name = resource_name + self.kubeconfig = kubeconfig + self.separator = separator + self.verbose = verbose + + def get(self): + '''return a secret by name ''' + return self._get(self.kind, self.name) + + def update(self, file_name, content, force=False, content_type='yaml'): + '''run update ''' + if file_name: + if content_type == 'yaml': + data = yaml.load(open(file_name)) + elif content_type == 'json': + data = json.loads(open(file_name).read()) + + changes = [] + yed = Yedit(filename=file_name, content=data, separator=self.separator) + for key, value in content.items(): + changes.append(yed.put(key, value)) + + if any([not change[0] for change in changes]): + return {'returncode': 0, 'updated': False} + + yed.write() + + atexit.register(Utils.cleanup, [file_name]) + + return self._replace(file_name, force=force) + + return self._replace_content(self.kind, self.name, content, force=force, sep=self.separator) + + @staticmethod + def run_ansible(params, check_mode): + '''run the ansible idempotent code''' + + ocedit = Edit(params['kind'], + params['namespace'], + params['name'], + kubeconfig=params['kubeconfig'], + separator=params['separator'], + verbose=params['debug']) + + api_rval = ocedit.get() + + ######## + # Create + ######## + if not Utils.exists(api_rval['results'], params['name']): + return {"failed": True, 'msg': api_rval} + + ######## + # Update + ######## + if check_mode: + return {'changed': True, 'msg': 'CHECK_MODE: Would have performed edit'} + + api_rval = ocedit.update(params['file_name'], + params['content'], + params['force'], + params['file_format']) + + if api_rval['returncode'] != 0: + return {"failed": True, 'msg': api_rval} + + if 'updated' in api_rval and not api_rval['updated']: + return {"changed": False, 'results': api_rval, 'state': 'present'} + + # return the created object + api_rval = ocedit.get() + + if api_rval['returncode'] != 0: + return {"failed": True, 'msg': api_rval} + + return {"changed": True, 'results': api_rval, 'state': 'present'} diff --git a/roles/lib_openshift/src/class/oc_route.py b/roles/lib_openshift/src/class/oc_route.py index f0cfa5820..05b1be409 100644 --- a/roles/lib_openshift/src/class/oc_route.py +++ b/roles/lib_openshift/src/class/oc_route.py @@ -64,6 +64,7 @@ class OCRoute(OpenShiftCLI): skip = [] return not Utils.check_def_equal(self.config.data, self.route.yaml_dict, skip_keys=skip, debug=True) + # pylint: disable=too-many-return-statements,too-many-branches @staticmethod def run_ansible(params, files, check_mode=False): ''' run the idempotent asnible code diff --git a/roles/lib_openshift/src/doc/edit b/roles/lib_openshift/src/doc/edit new file mode 100644 index 000000000..212d88f65 --- /dev/null +++ b/roles/lib_openshift/src/doc/edit @@ -0,0 +1,116 @@ +# flake8: noqa +# pylint: skip-file + +DOCUMENTATION = ''' +--- +module: oc_edit +short_description: Modify, and idempotently manage openshift objects. +description: + - Modify openshift objects programmatically. +options: + state: + description: + - Currently present is only supported state. + required: true + default: present + choices: ["present"] + aliases: [] + kubeconfig: + description: + - The path for the kubeconfig file to use for authentication + required: false + default: /etc/origin/master/admin.kubeconfig + aliases: [] + debug: + description: + - Turn on debug output. + required: false + default: False + aliases: [] + name: + description: + - Name of the object that is being queried. + required: false + default: None + aliases: [] + namespace: + description: + - The namespace where the object lives. + required: false + default: str + aliases: [] + kind: + description: + - The kind attribute of the object. + required: True + default: None + choices: + - bc + - buildconfig + - configmaps + - dc + - deploymentconfig + - imagestream + - imagestreamtag + - is + - istag + - namespace + - project + - projects + - node + - ns + - persistentvolume + - pv + - rc + - replicationcontroller + - routes + - scc + - secret + - securitycontextconstraints + - service + - svc + aliases: [] + file_name: + description: + - The file name in which to edit + required: false + default: None + aliases: [] + file_format: + description: + - The format of the file being edited. + required: false + default: yaml + aliases: [] + content: + description: + - Content of the file + required: false + default: None + aliases: [] + force: + description: + - Whether or not to force the operation + required: false + default: None + aliases: [] + separator: + description: + - The separator format for the edit. + required: false + default: '.' + aliases: [] +author: +- "Kenny Woodson " +extends_documentation_fragment: [] +''' + +EXAMPLES = ''' +oc_edit: + kind: rc + name: hawkular-cassandra-rc + namespace: openshift-infra + content: + spec.template.spec.containers[0].resources.limits.memory: 512 + spec.template.spec.containers[0].resources.requests.memory: 256 +''' diff --git a/roles/lib_openshift/src/doc/route b/roles/lib_openshift/src/doc/route index 256f6b8f3..1797d4d33 100644 --- a/roles/lib_openshift/src/doc/route +++ b/roles/lib_openshift/src/doc/route @@ -3,10 +3,10 @@ DOCUMENTATION = ''' --- -module: yedit -short_description: Create, modify, and idempotently manage yaml files. +module: oc_route +short_description: Create, modify, and idempotently manage openshift routes. description: - - Modify yaml files programmatically. + - Manage openshift route objects programmatically. options: state: description: diff --git a/roles/lib_openshift/src/generate.py b/roles/lib_openshift/src/generate.py index f4b46aa91..003136833 100755 --- a/roles/lib_openshift/src/generate.py +++ b/roles/lib_openshift/src/generate.py @@ -9,6 +9,7 @@ import yaml # pylint: disable=anomalous-backslash-in-string GEN_STR = "#!/usr/bin/env python\n" + \ "# pylint: disable=missing-docstring\n" + \ + "# flake8: noqa: T001\n" + \ "# ___ ___ _ _ ___ ___ _ _____ ___ ___\n" + \ "# / __| __| \| | __| _ \ /_\_ _| __| \\\n" + \ "# | (_ | _|| .` | _|| / / _ \| | | _|| |) |\n" + \ @@ -18,7 +19,7 @@ GEN_STR = "#!/usr/bin/env python\n" + \ "# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_|\n" OPENSHIFT_ANSIBLE_PATH = os.path.dirname(os.path.realpath(__file__)) -OPENSHIFT_ANSIBLE_SOURCES_PATH = os.path.join(OPENSHIFT_ANSIBLE_PATH, 'generate_sources.yml') # noqa: E501 +OPENSHIFT_ANSIBLE_SOURCES_PATH = os.path.join(OPENSHIFT_ANSIBLE_PATH, 'sources.yml') # noqa: E501 def main(): diff --git a/roles/lib_openshift/src/generate_sources.yml b/roles/lib_openshift/src/generate_sources.yml deleted file mode 100644 index d8fcc6141..000000000 --- a/roles/lib_openshift/src/generate_sources.yml +++ /dev/null @@ -1,10 +0,0 @@ ---- -oc_route.py: -- doc/license -- lib/import.py -- doc/route -- lib/base.py -- ../../lib_utils/src/class/yedit.py -- lib/route.py -- class/oc_route.py -- ansible/oc_route.py diff --git a/roles/lib_openshift/src/lib/base.py b/roles/lib_openshift/src/lib/base.py index 9830150be..4e9aa4461 100644 --- a/roles/lib_openshift/src/lib/base.py +++ b/roles/lib_openshift/src/lib/base.py @@ -1,9 +1,7 @@ # pylint: skip-file # flake8: noqa -''' - OpenShiftCLI class that wraps the oc commands in a subprocess -''' # pylint: disable=too-many-lines +# noqa: E301,E302,E303,T001 class OpenShiftCLIError(Exception): @@ -213,7 +211,7 @@ class OpenShiftCLI(object): err = None if self.verbose: - print ' '.join(cmds) + print(' '.join(cmds)) proc = subprocess.Popen(cmds, stdin=subprocess.PIPE, @@ -232,14 +230,14 @@ class OpenShiftCLI(object): try: rval['results'] = json.loads(stdout) except ValueError as err: - if "No JSON object could be decoded" in err.message: - err = err.message + if "No JSON object could be decoded" in str(err): + err = str(err) elif output_type == 'raw': rval['results'] = stdout if self.verbose: - print stdout - print stderr + print(stdout) + print(stderr) if err: rval.update({"err": err, @@ -350,50 +348,50 @@ class Utils(object): if isinstance(value, list): if key not in user_def: if debug: - print 'User data does not have key [%s]' % key - print 'User data: %s' % user_def + print('User data does not have key [%s]' % key) + print('User data: %s' % user_def) return False if not isinstance(user_def[key], list): if debug: - print 'user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key]) + print('user_def[key] is not a list key=[%s] user_def[key]=%s' % (key, user_def[key])) return False if len(user_def[key]) != len(value): if debug: - print "List lengths are not equal." - print "key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value)) - print "user_def: %s" % user_def[key] - print "value: %s" % value + print("List lengths are not equal.") + print("key=[%s]: user_def[%s] != value[%s]" % (key, len(user_def[key]), len(value))) + print("user_def: %s" % user_def[key]) + print("value: %s" % value) return False for values in zip(user_def[key], value): if isinstance(values[0], dict) and isinstance(values[1], dict): if debug: - print 'sending list - list' - print type(values[0]) - print type(values[1]) + print('sending list - list') + print(type(values[0])) + print(type(values[1])) result = Utils.check_def_equal(values[0], values[1], skip_keys=skip_keys, debug=debug) if not result: - print 'list compare returned false' + print('list compare returned false') return False elif value != user_def[key]: if debug: - print 'value should be identical' - print value - print user_def[key] + print('value should be identical') + print(value) + print(user_def[key]) return False # recurse on a dictionary elif isinstance(value, dict): if key not in user_def: if debug: - print "user_def does not have key [%s]" % key + print("user_def does not have key [%s]" % key) return False if not isinstance(user_def[key], dict): if debug: - print "dict returned false: not instance of dict" + print("dict returned false: not instance of dict") return False # before passing ensure keys match @@ -401,31 +399,31 @@ class Utils(object): user_values = set(user_def[key].keys()) - set(skip) if api_values != user_values: if debug: - print "keys are not equal in dict" - print api_values - print user_values + print("keys are not equal in dict") + print(api_values) + print(user_values) return False result = Utils.check_def_equal(user_def[key], value, skip_keys=skip_keys, debug=debug) if not result: if debug: - print "dict returned false" - print result + print("dict returned false") + print(result) return False # Verify each key, value pair is the same else: if key not in user_def or value != user_def[key]: if debug: - print "value not equal; user_def does not have key" - print key - print value + print("value not equal; user_def does not have key") + print(key) + print(value) if key in user_def: - print user_def[key] + print(user_def[key]) return False if debug: - print 'returning true' + print('returning true') return True diff --git a/roles/lib_openshift/src/lib/import.py b/roles/lib_openshift/src/lib/import.py index 1fc75f466..c2b30e019 100644 --- a/roles/lib_openshift/src/lib/import.py +++ b/roles/lib_openshift/src/lib/import.py @@ -5,12 +5,13 @@ ''' # pylint: disable=too-many-lines - +from __future__ import print_function import atexit import json import os import re -import ruamel.yaml as yaml import shutil import subprocess +# pylint: disable=import-error +import ruamel.yaml as yaml from ansible.module_utils.basic import AnsibleModule diff --git a/roles/lib_openshift/src/lib/route.py b/roles/lib_openshift/src/lib/route.py index 11dc1dfbf..df062b0dd 100644 --- a/roles/lib_openshift/src/lib/route.py +++ b/roles/lib_openshift/src/lib/route.py @@ -1,5 +1,6 @@ # pylint: skip-file # flake8: noqa +# noqa: E302,E301 # pylint: disable=too-many-instance-attributes diff --git a/roles/lib_openshift/src/sources.yml b/roles/lib_openshift/src/sources.yml new file mode 100644 index 000000000..945d4d13f --- /dev/null +++ b/roles/lib_openshift/src/sources.yml @@ -0,0 +1,18 @@ +--- +oc_route.py: +- doc/license +- lib/import.py +- doc/route +- ../../lib_utils/src/class/yedit.py +- lib/base.py +- lib/route.py +- class/oc_route.py +- ansible/oc_route.py +oc_edit.py: +- doc/license +- lib/import.py +- doc/edit +- ../../lib_utils/src/class/yedit.py +- lib/base.py +- class/oc_edit.py +- ansible/oc_edit.py diff --git a/roles/lib_openshift/src/test/integration/route.yml b/roles/lib_openshift/src/test/integration/route.yml new file mode 100644 index 000000000..6a96b334f --- /dev/null +++ b/roles/lib_openshift/src/test/integration/route.yml @@ -0,0 +1,58 @@ +#!/usr/bin/ansible-playbook +# ./route.yml -M ../../../library -e "cli_master_test=$OPENSHIFT_MASTER +--- +- hosts: "{{ cli_master_test }}" + gather_facts: no + user: root + tasks: + - name: create route + oc_route: + name: test + namespace: test + tls_termination: edge + cert_content: testing cert + cacert_content: testing cacert + service_name: test + host: test.example + register: routeout + - debug: var=routeout + + - name: get route + oc_route: + state: list + name: test + namespace: default + register: routeout + - debug: var=routeout + + - name: delete route + oc_route: + state: absent + name: test + namespace: default + register: routeout + - debug: var=routeout + + - name: create route + oc_route: + name: test + namespace: test + tls_termination: edge + cert_content: testing cert + cacert_content: testing cacert + service_name: test + host: test.example + register: routeout + - debug: var=routeout + + - name: create route noop + oc_route: + name: test + namespace: test + tls_termination: edge + cert_content: testing cert + cacert_content: testing cacert + service_name: test + host: test.example + register: routeout + - debug: var=routeout diff --git a/roles/lib_utils/library/yedit.py b/roles/lib_utils/library/yedit.py index 90c7fd4d7..d882c983e 100644 --- a/roles/lib_utils/library/yedit.py +++ b/roles/lib_utils/library/yedit.py @@ -162,12 +162,15 @@ EXAMPLES = ''' # b: # c: d ''' +# noqa: E301,E302 + class YeditException(Exception): ''' Exception class for Yedit ''' pass +# pylint: disable=too-many-public-methods class Yedit(object): ''' Class to modify yaml files ''' re_valid_key = r"(((\[-?\d+\])|([0-9a-zA-Z%s/_-]+)).?)+$" @@ -724,6 +727,7 @@ class Yedit(object): return {'failed': True, 'msg': 'Unkown state passed'} + # pylint: disable=too-many-branches def main(): ''' ansible oc module for secrets ''' diff --git a/roles/lib_utils/src/ansible/yedit.py b/roles/lib_utils/src/ansible/yedit.py index efe034abf..8a1a7c2dc 100644 --- a/roles/lib_utils/src/ansible/yedit.py +++ b/roles/lib_utils/src/ansible/yedit.py @@ -1,6 +1,7 @@ # flake8: noqa # pylint: skip-file + # pylint: disable=too-many-branches def main(): ''' ansible oc module for secrets ''' diff --git a/roles/lib_utils/src/class/yedit.py b/roles/lib_utils/src/class/yedit.py index 4521009ab..b1644f9b2 100644 --- a/roles/lib_utils/src/class/yedit.py +++ b/roles/lib_utils/src/class/yedit.py @@ -1,5 +1,6 @@ # flake8: noqa # pylint: skip-file +# noqa: E301,E302 class YeditException(Exception): @@ -7,6 +8,7 @@ class YeditException(Exception): pass +# pylint: disable=too-many-public-methods class Yedit(object): ''' Class to modify yaml files ''' re_valid_key = r"(((\[-?\d+\])|([0-9a-zA-Z%s/_-]+)).?)+$" diff --git a/roles/lib_utils/src/test/integration/kube-manager-test.yaml b/roles/lib_utils/src/test/integration/kube-manager-test.yaml deleted file mode 100644 index aea8e668f..000000000 --- a/roles/lib_utils/src/test/integration/kube-manager-test.yaml +++ /dev/null @@ -1,58 +0,0 @@ -apiVersion: v1 -kind: Pod -metadata: - name: kube-controller-manager - namespace: kube-system -spec: - hostNetwork: true - containers: - - name: kube-controller-manager - image: openshift/kube:v1.0.0 - command: - - /hyperkube - - controller-manager - - --master=http://127.0.0.1:8080 - - --leader-elect=true - - --service-account-private-key-file=/etc/kubernetes/ssl/apiserver-key.pem - - --root-ca-file=/etc/k8s/ssl/my.pem - - --my-new-parameter=openshift - livenessProbe: - httpGet: - host: 127.0.0.1 - path: /healthz - port: 10252 - initialDelaySeconds: 15 - timeoutSeconds: 1 - volumeMounts: - - mountPath: /etc/kubernetes/ssl - name: ssl-certs-kubernetes - readOnly: true - - mountPath: /etc/ssl/certs - name: ssl-certs-host - readOnly: 'true' - volumes: - - hostPath: - path: /etc/kubernetes/ssl - name: ssl-certs-kubernetes - - hostPath: - path: /usr/share/ca-certificates - name: ssl-certs-host -yedittest: yedittest -metadata-namespace: openshift-is-awesome -nonexistingkey: -- --my-new-parameter=openshift -a: - b: - c: d -e: - f: - g: - h: - i: - j: k -z: - x: - y: - - 1 - - 2 - - 3 -- cgit v1.2.3 From 24a504f03a3d5edfe8957dcfaa4bde98ae0e60ec Mon Sep 17 00:00:00 2001 From: Kenny Woodson Date: Tue, 17 Jan 2017 15:31:42 -0500 Subject: Adding --verfiy to generate script. --- roles/lib_openshift/src/doc/generated | 10 +++++ roles/lib_openshift/src/generate.py | 67 ++++++++++++++++++++----------- roles/lib_openshift/src/sources.yml | 2 + roles/lib_utils/src/doc/generated | 9 +++++ roles/lib_utils/src/generate.py | 68 +++++++++++++++++++++----------- roles/lib_utils/src/generate_sources.yml | 7 ---- roles/lib_utils/src/sources.yml | 8 ++++ 7 files changed, 118 insertions(+), 53 deletions(-) create mode 100644 roles/lib_openshift/src/doc/generated create mode 100644 roles/lib_utils/src/doc/generated delete mode 100644 roles/lib_utils/src/generate_sources.yml create mode 100644 roles/lib_utils/src/sources.yml diff --git a/roles/lib_openshift/src/doc/generated b/roles/lib_openshift/src/doc/generated new file mode 100644 index 000000000..b55d18cff --- /dev/null +++ b/roles/lib_openshift/src/doc/generated @@ -0,0 +1,10 @@ +#!/usr/bin/env python +# pylint: disable=missing-docstring +# flake8: noqa: T001 +# ___ ___ _ _ ___ ___ _ _____ ___ ___ +# / __| __| \| | __| _ \ /_\_ _| __| \ +# | (_ | _|| .` | _|| / / _ \| | | _|| |) | +# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____ +# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _| +# | |) | (_) | | .` | (_) || | | _|| |) | | | | +# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_| diff --git a/roles/lib_openshift/src/generate.py b/roles/lib_openshift/src/generate.py index 003136833..8451d99ab 100755 --- a/roles/lib_openshift/src/generate.py +++ b/roles/lib_openshift/src/generate.py @@ -3,43 +3,64 @@ Generate the openshift-ansible/roles/lib_openshift_cli/library/ modules. ''' +import argparse import os import yaml - -# pylint: disable=anomalous-backslash-in-string -GEN_STR = "#!/usr/bin/env python\n" + \ - "# pylint: disable=missing-docstring\n" + \ - "# flake8: noqa: T001\n" + \ - "# ___ ___ _ _ ___ ___ _ _____ ___ ___\n" + \ - "# / __| __| \| | __| _ \ /_\_ _| __| \\\n" + \ - "# | (_ | _|| .` | _|| / / _ \| | | _|| |) |\n" + \ - "# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____\n" + \ - "# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _|\n" + \ - "# | |) | (_) | | .` | (_) || | | _|| |) | | | |\n" + \ - "# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_|\n" +import six OPENSHIFT_ANSIBLE_PATH = os.path.dirname(os.path.realpath(__file__)) OPENSHIFT_ANSIBLE_SOURCES_PATH = os.path.join(OPENSHIFT_ANSIBLE_PATH, 'sources.yml') # noqa: E501 +class GenerateAnsibleException(Exception): + '''General Exception for generate function''' + pass + + +def parse_args(): + '''parse arguments to generate''' + parser = argparse.ArgumentParser(description="Generate ansible modules.") + parser.add_argument('--verify', action='store_true', default=False, + help='Verify library code matches the generated code.') + + return parser.parse_args() + + +def generate(parts): + '''generate the source code for the ansible modules''' + + data = six.StringIO() + for fpart in parts: + # first line is pylint disable so skip it + with open(os.path.join(OPENSHIFT_ANSIBLE_PATH, fpart)) as pfd: + for idx, line in enumerate(pfd): + if idx in [0, 1] and 'flake8: noqa' in line or 'pylint: skip-file' in line: # noqa: E501 + continue + + data.write(line) + + return data + + def main(): ''' combine the necessary files to create the ansible module ''' + args = parse_args() library = os.path.join(OPENSHIFT_ANSIBLE_PATH, '..', 'library/') sources = yaml.load(open(OPENSHIFT_ANSIBLE_SOURCES_PATH).read()) + for fname, parts in sources.items(): - with open(os.path.join(library, fname), 'w') as afd: + data = generate(parts) + fname = os.path.join(library, fname) + if args.verify: + if not open(fname).read() == data.getvalue(): + raise GenerateAnsibleException('Generated content does not match for %s' % fname) + + continue + + with open(fname, 'w') as afd: afd.seek(0) - afd.write(GEN_STR) - for fpart in parts: - with open(os.path.join(OPENSHIFT_ANSIBLE_PATH, fpart)) as pfd: - # first line is pylint disable so skip it - for idx, line in enumerate(pfd): - if idx in [0, 1] and 'flake8: noqa' in line \ - or 'pylint: skip-file' in line: - continue - - afd.write(line) + afd.write(data.getvalue()) if __name__ == '__main__': diff --git a/roles/lib_openshift/src/sources.yml b/roles/lib_openshift/src/sources.yml index 945d4d13f..08fbbc201 100644 --- a/roles/lib_openshift/src/sources.yml +++ b/roles/lib_openshift/src/sources.yml @@ -1,5 +1,6 @@ --- oc_route.py: +- doc/generated - doc/license - lib/import.py - doc/route @@ -9,6 +10,7 @@ oc_route.py: - class/oc_route.py - ansible/oc_route.py oc_edit.py: +- doc/generated - doc/license - lib/import.py - doc/edit diff --git a/roles/lib_utils/src/doc/generated b/roles/lib_utils/src/doc/generated new file mode 100644 index 000000000..054780313 --- /dev/null +++ b/roles/lib_utils/src/doc/generated @@ -0,0 +1,9 @@ +#!/usr/bin/env python +# pylint: disable=missing-docstring +# ___ ___ _ _ ___ ___ _ _____ ___ ___ +# / __| __| \| | __| _ \ /_\_ _| __| \ +# | (_ | _|| .` | _|| / / _ \| | | _|| |) | +# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____ +# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _| +# | |) | (_) | | .` | (_) || | | _|| |) | | | | +# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_| diff --git a/roles/lib_utils/src/generate.py b/roles/lib_utils/src/generate.py index f4b46aa91..cece68fb4 100755 --- a/roles/lib_utils/src/generate.py +++ b/roles/lib_utils/src/generate.py @@ -3,42 +3,64 @@ Generate the openshift-ansible/roles/lib_openshift_cli/library/ modules. ''' +import argparse import os +import six import yaml -# pylint: disable=anomalous-backslash-in-string -GEN_STR = "#!/usr/bin/env python\n" + \ - "# pylint: disable=missing-docstring\n" + \ - "# ___ ___ _ _ ___ ___ _ _____ ___ ___\n" + \ - "# / __| __| \| | __| _ \ /_\_ _| __| \\\n" + \ - "# | (_ | _|| .` | _|| / / _ \| | | _|| |) |\n" + \ - "# \___|___|_|\_|___|_|_\/_/_\_\_|_|___|___/_ _____\n" + \ - "# | \ / _ \ | \| |/ _ \_ _| | __| \_ _|_ _|\n" + \ - "# | |) | (_) | | .` | (_) || | | _|| |) | | | |\n" + \ - "# |___/ \___/ |_|\_|\___/ |_| |___|___/___| |_|\n" - OPENSHIFT_ANSIBLE_PATH = os.path.dirname(os.path.realpath(__file__)) -OPENSHIFT_ANSIBLE_SOURCES_PATH = os.path.join(OPENSHIFT_ANSIBLE_PATH, 'generate_sources.yml') # noqa: E501 +OPENSHIFT_ANSIBLE_SOURCES_PATH = os.path.join(OPENSHIFT_ANSIBLE_PATH, 'sources.yml') # noqa: E501 + + +class GenerateAnsibleException(Exception): + '''General Exception for generate function''' + pass + + +def parse_args(): + '''parse arguments to generate''' + parser = argparse.ArgumentParser(description="Generate ansible modules.") + parser.add_argument('--verify', action='store_true', default=False, + help='Verify library code matches the generated code.') + + return parser.parse_args() + + +def generate(parts): + '''generate the source code for the ansible modules''' + + data = six.StringIO() + for fpart in parts: + # first line is pylint disable so skip it + with open(os.path.join(OPENSHIFT_ANSIBLE_PATH, fpart)) as pfd: + for idx, line in enumerate(pfd): + if idx in [0, 1] and 'flake8: noqa' in line or 'pylint: skip-file' in line: # noqa: E501 + continue + + data.write(line) + + return data def main(): ''' combine the necessary files to create the ansible module ''' + args = parse_args() library = os.path.join(OPENSHIFT_ANSIBLE_PATH, '..', 'library/') sources = yaml.load(open(OPENSHIFT_ANSIBLE_SOURCES_PATH).read()) + for fname, parts in sources.items(): - with open(os.path.join(library, fname), 'w') as afd: + data = generate(parts) + fname = os.path.join(library, fname) + if args.verify: + if not open(fname).read() == data.getvalue(): + raise GenerateAnsibleException('Generated content does not match for %s' % fname) + + continue + + with open(fname, 'w') as afd: afd.seek(0) - afd.write(GEN_STR) - for fpart in parts: - with open(os.path.join(OPENSHIFT_ANSIBLE_PATH, fpart)) as pfd: - # first line is pylint disable so skip it - for idx, line in enumerate(pfd): - if idx in [0, 1] and 'flake8: noqa' in line \ - or 'pylint: skip-file' in line: - continue - - afd.write(line) + afd.write(data.getvalue()) if __name__ == '__main__': diff --git a/roles/lib_utils/src/generate_sources.yml b/roles/lib_utils/src/generate_sources.yml deleted file mode 100644 index 83b21de1b..000000000 --- a/roles/lib_utils/src/generate_sources.yml +++ /dev/null @@ -1,7 +0,0 @@ ---- -yedit.py: -- doc/license -- class/import.py -- doc/yedit -- class/yedit.py -- ansible/yedit.py diff --git a/roles/lib_utils/src/sources.yml b/roles/lib_utils/src/sources.yml new file mode 100644 index 000000000..9cf3a0981 --- /dev/null +++ b/roles/lib_utils/src/sources.yml @@ -0,0 +1,8 @@ +--- +yedit.py: +- doc/generated +- doc/license +- class/import.py +- doc/yedit +- class/yedit.py +- ansible/yedit.py -- cgit v1.2.3 From 3fd3cd3a07d9f000c8cb8bd1b7a49ac2af675696 Mon Sep 17 00:00:00 2001 From: Kenny Woodson Date: Wed, 18 Jan 2017 12:06:49 -0500 Subject: Adding a few updates for python27,35 compatibility --- roles/lib_openshift/library/oc_edit.py | 8 ++++---- roles/lib_openshift/library/oc_route.py | 8 ++++---- roles/lib_openshift/src/lib/base.py | 8 ++++---- roles/lib_utils/src/doc/yedit | 6 ++++++ 4 files changed, 18 insertions(+), 12 deletions(-) diff --git a/roles/lib_openshift/library/oc_edit.py b/roles/lib_openshift/library/oc_edit.py index f78cbf2b3..d44f0da88 100644 --- a/roles/lib_openshift/library/oc_edit.py +++ b/roles/lib_openshift/library/oc_edit.py @@ -947,14 +947,14 @@ class OpenShiftCLI(object): try: rval['results'] = json.loads(stdout) except ValueError as err: - if "No JSON object could be decoded" in str(err): - err = str(err) + if "No JSON object could be decoded" in err.args: + err = err.args elif output_type == 'raw': rval['results'] = stdout if self.verbose: - print(stdout) - print(stderr) + print("STDOUT: {0}".format(stdout)) + print("STDERR: {0}".format(stderr)) if err: rval.update({"err": err, diff --git a/roles/lib_openshift/library/oc_route.py b/roles/lib_openshift/library/oc_route.py index de186ded7..04301a177 100644 --- a/roles/lib_openshift/library/oc_route.py +++ b/roles/lib_openshift/library/oc_route.py @@ -951,14 +951,14 @@ class OpenShiftCLI(object): try: rval['results'] = json.loads(stdout) except ValueError as err: - if "No JSON object could be decoded" in str(err): - err = str(err) + if "No JSON object could be decoded" in err.args: + err = err.args elif output_type == 'raw': rval['results'] = stdout if self.verbose: - print(stdout) - print(stderr) + print("STDOUT: {0}".format(stdout)) + print("STDERR: {0}".format(stderr)) if err: rval.update({"err": err, diff --git a/roles/lib_openshift/src/lib/base.py b/roles/lib_openshift/src/lib/base.py index 4e9aa4461..915a7caca 100644 --- a/roles/lib_openshift/src/lib/base.py +++ b/roles/lib_openshift/src/lib/base.py @@ -230,14 +230,14 @@ class OpenShiftCLI(object): try: rval['results'] = json.loads(stdout) except ValueError as err: - if "No JSON object could be decoded" in str(err): - err = str(err) + if "No JSON object could be decoded" in err.args: + err = err.args elif output_type == 'raw': rval['results'] = stdout if self.verbose: - print(stdout) - print(stderr) + print("STDOUT: {0}".format(stdout)) + print("STDERR: {0}".format(stderr)) if err: rval.update({"err": err, diff --git a/roles/lib_utils/src/doc/yedit b/roles/lib_utils/src/doc/yedit index e367a389e..16b44943e 100644 --- a/roles/lib_utils/src/doc/yedit +++ b/roles/lib_utils/src/doc/yedit @@ -102,6 +102,12 @@ options: required: false default: true aliases: [] + separator: + description: + - The separator being used when parsing strings. + required: false + default: '.' + aliases: [] author: - "Kenny Woodson " extends_documentation_fragment: [] -- cgit v1.2.3