desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'property for serviceaccount'
| @property
def serviceaccount(self):
| return self._serviceaccount
|
'setter for property serviceaccount'
| @serviceaccount.setter
def serviceaccount(self, config):
| self._serviceaccount = config
|
'property rolebinding'
| @property
def rolebinding(self):
| return self._rolebinding
|
'setter for property rolebinding'
| @rolebinding.setter
def rolebinding(self, config):
| self._rolebinding = config
|
'return the current object kind by name'
| def get_object_by_kind(self, kind):
| if re.match('^(dc|deploymentconfig)$', kind, flags=re.IGNORECASE):
return self.deploymentconfig
elif re.match('^(svc|service)$', kind, flags=re.IGNORECASE):
return self.service
elif re.match('^(sa|serviceaccount)$', kind, flags=re.IGNORECASE):
return self.serviceaccount
elif re.m... |
'return the self.router_parts'
| def get(self):
| self.service = None
self.deploymentconfig = None
self.serviceaccount = None
self.secret = None
self.rolebinding = None
for part in self.router_parts:
result = self._get(part['kind'], name=part['name'])
if ((result['returncode'] == 0) and (part['kind'] == 'dc')):
self.... |
'return a whether svc or dc exists'
| def exists(self):
| if (self.deploymentconfig and self.service and self.secret and self.serviceaccount):
return True
return False
|
'return all pods'
| def delete(self):
| parts = []
for part in self.router_parts:
parts.append(self._delete(part['kind'], part['name']))
rval = 0
for part in parts:
if ((part['returncode'] != 0) and (not ('already exist' in part['stderr']))):
rval = part['returncode']
return {'returncode': rval, 'results': p... |
'modify the deployment config'
| def add_modifications(self, deploymentconfig):
| edit_results = []
for edit in self.config.config_options['edits'].get('value', []):
if (edit['action'] == 'put'):
edit_results.append(deploymentconfig.put(edit['key'], edit['value']))
if (edit['action'] == 'update'):
edit_results.append(deploymentconfig.update(edit['key']... |
'prepare router for instantiation'
| def _prepare_router(self):
| if (self.config.config_options['cacert_file']['value'] and self.config.config_options['cert_file']['value'] and self.config.config_options['key_file']['value']):
router_pem = '/tmp/router.pem'
with open(router_pem, 'w') as rfd:
rfd.write(open(self.config.config_options['cert_file']['valu... |
'Create a router
This includes the different parts:
- deploymentconfig
- service
- serviceaccount
- secrets
- clusterrolebinding'
| def create(self):
| results = []
self.needs_update()
import time
for (kind, oc_data) in self.prepared_router.items():
if (oc_data['obj'] is not None):
time.sleep(1)
if (self.get_object_by_kind(kind) is None):
results.append(self._create(oc_data['path']))
elif oc_d... |
'run update for the router. This performs a replace'
| def update(self):
| results = []
for (_, oc_data) in self.prepared_router.items():
if oc_data['update']:
results.append(self._replace(oc_data['path']))
rval = 0
for result in results:
if (result['returncode'] != 0):
rval = result['returncode']
return {'returncode': rval, 'results... |
'check to see if we need to update'
| def needs_update(self):
| skip = ['secrets', 'imagePullSecrets']
if ((self.serviceaccount is None) or (not Utils.check_def_equal(self.prepared_router['ServiceAccount']['obj'].yaml_dict, self.serviceaccount.yaml_dict, skip_keys=skip, debug=self.verbose))):
self.prepared_router['ServiceAccount']['update'] = True
if self.prepar... |
'run ansible idempotent code'
| @staticmethod
def run_ansible(params, check_mode):
| rconfig = RouterConfig(params['name'], params['namespace'], params['kubeconfig'], {'default_cert': {'value': params['default_cert'], 'include': True}, 'cert_file': {'value': params['cert_file'], 'include': False}, 'key_file': {'value': params['key_file'], 'include': False}, 'images': {'value': params['images'], 'in... |
'Constructor for oadm ca'
| def __init__(self, config, verbose=False):
| super(CAServerCert, self).__init__(None, config.kubeconfig, verbose)
self.config = config
self.verbose = verbose
|
'get the current cert file
If a file exists by the same name in the specified location then the cert exists'
| def get(self):
| cert = self.config.config_options['cert']['value']
if (cert and os.path.exists(cert)):
return open(cert).read()
return None
|
'run openshift oc adm ca create-server-cert cmd'
| def create(self):
| if self.config.config_options['backup']['value']:
import time
ext = time.strftime('%Y-%m-%d@%H:%M:%S', time.localtime(time.time()))
date_str = ('%s_' + ('%s' % ext))
if os.path.exists(self.config.config_options['key']['value']):
shutil.copy(self.config.config_options['key... |
'check whether the certificate exists and has the clusterIP'
| def exists(self):
| cert_path = self.config.config_options['cert']['value']
if (not os.path.exists(cert_path)):
return False
cert_names = []
hostnames = self.config.config_options['hostnames']['value'].split(',')
proc = subprocess.Popen(['openssl', 'x509', '-noout', '-text', '-in', cert_path], stdout=subprocess... |
'run the idempotent ansible code'
| @staticmethod
def run_ansible(params, check_mode):
| params['hostnames'] = [host for host in params['hostnames'] if isinstance(host, string_types)]
config = CAServerCertConfig(params['kubeconfig'], params['debug'], {'cert': {'value': params['cert'], 'include': True}, 'hostnames': {'value': ','.join(params['hostnames']), 'include': True}, 'overwrite': {'value': Tr... |
'Constructor for OpenshiftOC'
| def __init__(self, namespace, kind, env_vars, resource_name=None, kubeconfig='/etc/origin/master/admin.kubeconfig', verbose=False):
| super(OCEnv, self).__init__(namespace, kubeconfig=kubeconfig, verbose=verbose)
self.kind = kind
self.name = resource_name
self.env_vars = env_vars
self._resource = None
|
'property function for resource var'
| @property
def resource(self):
| if (not self._resource):
self.get()
return self._resource
|
'setter function for resource var'
| @resource.setter
def resource(self, data):
| self._resource = data
|
'return whether a key, value pair exists'
| def key_value_exists(self, key, value):
| return self.resource.exists_env_value(key, value)
|
'return whether a key exists'
| def key_exists(self, key):
| return self.resource.exists_env_key(key)
|
'return environment variables'
| def get(self):
| result = self._get(self.kind, self.name)
if (result['returncode'] == 0):
if (self.kind == 'dc'):
self.resource = DeploymentConfig(content=result['results'][0])
result['results'] = (self.resource.get(OCEnv.container_path[self.kind]) or [])
return result
|
'delete environment variables'
| def delete(self):
| if self.resource.delete_env_var(self.env_vars.keys()):
return self._replace_content(self.kind, self.name, self.resource.yaml_dict)
return {'returncode': 0, 'changed': False}
|
'place env vars into dc'
| def put(self):
| for (update_key, update_value) in self.env_vars.items():
self.resource.update_env_var(update_key, update_value)
return self._replace_content(self.kind, self.name, self.resource.yaml_dict)
|
'run the idempotent ansible code'
| @staticmethod
def run_ansible(params, check_mode):
| ocenv = OCEnv(params['namespace'], params['kind'], params['env_vars'], resource_name=params['name'], kubeconfig=params['kubeconfig'], verbose=params['debug'])
state = params['state']
api_rval = ocenv.get()
if (state == 'list'):
return {'changed': False, 'results': api_rval['results'], 'state': '... |
'return the kind we are working with'
| def get_kind(self):
| if (self.config_options['resource_kind']['value'] == 'role'):
return 'rolebinding'
elif (self.config_options['resource_kind']['value'] == 'cluster-role'):
return 'clusterrolebinding'
elif (self.config_options['resource_kind']['value'] == 'scc'):
return 'scc'
return None
|
'Constructor for PolicyUser'
| def __init__(self, config, verbose=False):
| super(PolicyUser, self).__init__(config.namespace, config.kubeconfig, verbose)
self.config = config
self.verbose = verbose
self._rolebinding = None
self._scc = None
self._cluster_role_bindings = None
self._role_bindings = None
|
'role_binding property'
| @property
def role_binding(self):
| return self._rolebinding
|
'setter for role_binding property'
| @role_binding.setter
def role_binding(self, binding):
| self._rolebinding = binding
|
'security_context_constraint property'
| @property
def security_context_constraint(self):
| return self._scc
|
'setter for security_context_constraint property'
| @security_context_constraint.setter
def security_context_constraint(self, scc):
| self._scc = scc
|
'fetch the desired kind
This is only used for scc objects.
The {cluster}rolebindings happen in exists.'
| def get(self):
| resource_name = self.config.config_options['name']['value']
if (resource_name == 'cluster-reader'):
resource_name += 's'
return self._get(self.config.kind, resource_name)
|
'return whether role_binding exists'
| def exists_role_binding(self):
| bindings = None
if (self.config.config_options['resource_kind']['value'] == 'cluster-role'):
bindings = self.clusterrolebindings
else:
bindings = self.rolebindings
if (bindings is None):
return False
for binding in bindings:
if ((binding['roleRef']['name'] == self.con... |
'return whether scc exists'
| def exists_scc(self):
| results = self.get()
if (results['returncode'] == 0):
self.security_context_constraint = SecurityContextConstraints(results['results'][0])
if (self.security_context_constraint.find_user(self.config.config_options['user']['value']) != None):
return True
return False
return... |
'does the object exist?'
| def exists(self):
| if (self.config.config_options['resource_kind']['value'] == 'cluster-role'):
return self.exists_role_binding()
elif (self.config.config_options['resource_kind']['value'] == 'role'):
return self.exists_role_binding()
elif (self.config.config_options['resource_kind']['value'] == 'scc'):
... |
'perform action on resource'
| def perform(self):
| cmd = ['policy', self.config.config_options['action']['value'], self.config.config_options['name']['value'], self.config.config_options['user']['value']]
return self.openshift_cmd(cmd, oadm=True)
|
'run the idempotent ansible code'
| @staticmethod
def run_ansible(params, check_mode):
| state = params['state']
action = None
if (state == 'present'):
action = (('add-' + params['resource_kind']) + '-to-user')
else:
action = (('remove-' + params['resource_kind']) + '-from-user')
nconfig = PolicyUserConfig(params['namespace'], params['kubeconfig'], {'action': {'value': a... |
'Constructor for OpenshiftOC'
| def __init__(self, kind, namespace, resource_name=None, kubeconfig='/etc/origin/master/admin.kubeconfig', separator='.', verbose=False):
| super(Edit, self).__init__(namespace, kubeconfig=kubeconfig, verbose=verbose)
self.kind = kind
self.name = resource_name
self.separator = separator
|
'return a secret by name'
| def get(self):
| return self._get(self.kind, self.name)
|
'run update'
| def update(self, file_name, content, force=False, content_type='yaml'):
| 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) ... |
'run the ansible idempotent code'
| @staticmethod
def run_ansible(params, check_mode):
| ocedit = Edit(params['kind'], params['namespace'], params['name'], kubeconfig=params['kubeconfig'], separator=params['separator'], verbose=params['debug'])
api_rval = ocedit.get()
if (not Utils.exists(api_rval['results'], params['name'])):
return {'failed': True, 'msg': api_rval}
if check_mode:
... |
'Constructor for OpenshiftOC'
| def __init__(self, name, from_file, from_literal, state, namespace, kubeconfig='/etc/origin/master/admin.kubeconfig', verbose=False):
| super(OCConfigMap, self).__init__(namespace, kubeconfig=kubeconfig, verbose=verbose)
self.name = name
self.state = state
self._configmap = None
self._inc_configmap = None
self.from_file = (from_file if (from_file is not None) else {})
self.from_literal = (from_literal if (from_literal is not... |
'return from_files in a string ready for cli'
| def from_file_to_params(self):
| return ['--from-file={}={}'.format(key, value) for (key, value) in self.from_file.items()]
|
'return from_literal in a string ready for cli'
| def from_literal_to_params(self):
| return ['--from-literal={}={}'.format(key, value) for (key, value) in self.from_literal.items()]
|
'return a configmap by name'
| def get(self):
| results = self._get('configmap', self.name)
if ((results['returncode'] == 0) and results['results'][0]):
self.configmap = results['results'][0]
if ((results['returncode'] != 0) and ('"{}" not found'.format(self.name) in results['stderr'])):
results['returncode'] = 0
return results
|
'delete a configmap by name'
| def delete(self):
| return self._delete('configmap', self.name)
|
'Create a configmap
:dryrun: Product what you would have done. default: False
:output: Whether to parse output. default: False'
| def create(self, dryrun=False, output=False):
| cmd = ['create', 'configmap', self.name]
if (self.from_literal is not None):
cmd.extend(self.from_literal_to_params())
if (self.from_file is not None):
cmd.extend(self.from_file_to_params())
if dryrun:
cmd.extend(['--dry-run', '-ojson'])
results = self.openshift_cmd(cmd, outp... |
'run update configmap'
| def update(self):
| return self._replace_content('configmap', self.name, self.inc_configmap)
|
'compare the current configmap with the proposed and return if they are equal'
| def needs_update(self):
| return (not Utils.check_def_equal(self.inc_configmap, self.configmap, debug=self.verbose))
|
'run the ansible idempotent code'
| @staticmethod
def run_ansible(params, check_mode):
| oc_cm = OCConfigMap(params['name'], params['from_file'], params['from_literal'], params['state'], params['namespace'], kubeconfig=params['kubeconfig'], verbose=params['debug'])
state = params['state']
api_rval = oc_cm.get()
if ('failed' in api_rval):
return {'failed': True, 'msg': api_rval}
... |
'Constructor for OpenshiftOC'
| def __init__(self, config, verbose=False):
| super(OCServiceAccountSecret, self).__init__(config.namespace, kubeconfig=config.kubeconfig, verbose=verbose)
self.config = config
self.verbose = verbose
self._service_account = None
|
'Property for the service account'
| @property
def service_account(self):
| if (not self._service_account):
self.get()
return self._service_account
|
'setter for the service account'
| @service_account.setter
def service_account(self, data):
| self._service_account = data
|
'verifies if secret exists in the service account'
| def exists(self, in_secret):
| result = self.service_account.find_secret(in_secret)
if (not result):
return False
return True
|
'get the service account definition from the master'
| def get(self):
| sao = self._get(OCServiceAccountSecret.kind, self.config.name)
if (sao['returncode'] == 0):
self.service_account = ServiceAccount(content=sao['results'][0])
sao['results'] = self.service_account.get('secrets')
return sao
|
'delete secrets'
| def delete(self):
| modified = []
for rem_secret in self.config.secrets:
modified.append(self.service_account.delete_secret(rem_secret))
if any(modified):
return self._replace_content(OCServiceAccountSecret.kind, self.config.name, self.service_account.yaml_dict)
return {'returncode': 0, 'changed': False}
|
'place secrets into sa'
| def put(self):
| modified = False
for add_secret in self.config.secrets:
if (not self.service_account.find_secret(add_secret)):
self.service_account.add_secret(add_secret)
modified = True
if modified:
return self._replace_content(OCServiceAccountSecret.kind, self.config.name, self.ser... |
'run the ansible idempotent code'
| @staticmethod
def run_ansible(params, check_mode):
| sconfig = ServiceAccountConfig(params['service_account'], params['namespace'], params['kubeconfig'], [params['secret']], None)
oc_sa_sec = OCServiceAccountSecret(sconfig, verbose=params['debug'])
state = params['state']
api_rval = oc_sa_sec.get()
if (state == 'list'):
return {'changed': Fals... |
'Constructor for OCVolume'
| def __init__(self, config, verbose=False):
| super(OCRoute, self).__init__(config.namespace, kubeconfig=config.kubeconfig, verbose=verbose)
self.config = config
self._route = None
|
'property function for route'
| @property
def route(self):
| if (not self._route):
self.get()
return self._route
|
'setter function for route'
| @route.setter
def route(self, data):
| self._route = data
|
'return whether a route exists'
| def exists(self):
| if self.route:
return True
return False
|
'return route information'
| def get(self):
| 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
|
'delete the object'
| def delete(self):
| return self._delete(self.kind, self.config.name)
|
'create the object'
| def create(self):
| return self._create_from_content(self.config.name, self.config.data)
|
'update the object'
| def update(self):
| return self._replace_content(self.kind, self.config.name, self.config.data, force=(self.config.host != self.route.get_host()))
|
'verify an update is needed'
| def needs_update(self):
| skip = []
return (not Utils.check_def_equal(self.config.data, self.route.yaml_dict, skip_keys=skip, debug=self.verbose))
|
'get the data for a particular value'
| @staticmethod
def get_cert_data(path, content):
| 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
|
'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)'
| @staticmethod
def run_ansible(params, check_mode=False):
| files = {'destcacert': {'path': params['dest_cacert_path'], 'content': params['dest_cacert_content'], 'value': None}, 'cacert': {'path': params['cacert_path'], 'content': params['cacert_content'], 'value': None}, 'cert': {'path': params['cert_path'], 'content': params['cert_content'], 'value': None}, 'key': {'path'... |
'Constructor for OCClusterRole'
| def __init__(self, name, rules=None, kubeconfig=None, verbose=False):
| super(OCClusterRole, self).__init__(None, kubeconfig=kubeconfig, verbose=verbose)
self.verbose = verbose
self.name = name
self._clusterrole = None
self._inc_clusterrole = ClusterRole.builder(name, rules)
|
'property for clusterrole'
| @property
def clusterrole(self):
| if (self._clusterrole is None):
self.get()
return self._clusterrole
|
'setter function for clusterrole property'
| @clusterrole.setter
def clusterrole(self, data):
| self._clusterrole = data
|
'property for inc_clusterrole'
| @property
def inc_clusterrole(self):
| return self._inc_clusterrole
|
'setter function for inc_clusterrole property'
| @inc_clusterrole.setter
def inc_clusterrole(self, data):
| self._inc_clusterrole = data
|
'return whether a clusterrole exists'
| def exists(self):
| if self.clusterrole:
return True
return False
|
'return a clusterrole'
| def get(self):
| result = self._get(self.kind, self.name)
if (result['returncode'] == 0):
self.clusterrole = ClusterRole(content=result['results'][0])
result['results'] = self.clusterrole.yaml_dict
elif ('"{}" not found'.format(self.name) in result['stderr']):
result['returncode'] = 0
s... |
'delete the object'
| def delete(self):
| return self._delete(self.kind, self.name)
|
'create a clusterrole from the proposed incoming clusterrole'
| def create(self):
| return self._create_from_content(self.name, self.inc_clusterrole.yaml_dict)
|
'update a project'
| def update(self):
| return self._replace_content(self.kind, self.name, self.inc_clusterrole.yaml_dict)
|
'verify an update is needed'
| def needs_update(self):
| return (not self.clusterrole.compare(self.inc_clusterrole, self.verbose))
|
'run the idempotent ansible code'
| @staticmethod
def run_ansible(params, check_mode):
| oc_clusterrole = OCClusterRole(params['name'], params['rules'], params['kubeconfig'], params['debug'])
state = params['state']
api_rval = oc_clusterrole.get()
if (state == 'list'):
return {'changed': False, 'results': api_rval, 'state': state}
if (state == 'absent'):
if oc_clusterrol... |
'Constructor for OpenshiftOC'
| def __init__(self, namespace, secret_name=None, secret_type=None, decode=False, kubeconfig='/etc/origin/master/admin.kubeconfig', verbose=False):
| super(OCSecret, self).__init__(namespace, kubeconfig=kubeconfig, verbose=verbose)
self.name = secret_name
self.type = secret_type
self.decode = decode
|
'return a secret by name'
| def get(self):
| results = self._get('secrets', self.name)
results['decoded'] = {}
results['exists'] = False
if ((results['returncode'] == 0) and results['results'][0]):
results['exists'] = True
if self.decode:
if ('data' in results['results'][0]):
for (sname, value) in result... |
'delete a secret by name'
| def delete(self):
| return self._delete('secrets', self.name)
|
'Create a secret'
| def create(self, files=None, contents=None, force=False):
| if (not files):
files = Utils.create_tmp_files_from_contents(contents)
secrets = [('%s=%s' % (sfile['name'], sfile['path'])) for sfile in files]
cmd = ['secrets', 'new', self.name]
if (self.type is not None):
cmd.append(('--type=%s' % self.type))
if force:
cmd.append(... |
'run update secret
This receives a list of file names and converts it into a secret.
The secret is then written to disk and passed into the `oc replace` command.'
| def update(self, files, force=False):
| secret = self.prep_secret(files, force)
if (secret['returncode'] != 0):
return secret
sfile_path = ('/tmp/%s' % self.name)
with open(sfile_path, 'w') as sfd:
sfd.write(json.dumps(secret['results']))
atexit.register(Utils.cleanup, [sfile_path])
return self._replace(sfile_path, for... |
'return what the secret would look like if created
This is accomplished by passing -ojson. This will most likely change in the future'
| def prep_secret(self, files=None, contents=None, force=False):
| if (not files):
files = Utils.create_tmp_files_from_contents(contents)
secrets = [('%s=%s' % (sfile['name'], sfile['path'])) for sfile in files]
cmd = ['-ojson', 'secrets', 'new', self.name]
if (self.type is not None):
cmd.extend([('--type=%s' % self.type)])
if force:
... |
'run the ansible idempotent code'
| @staticmethod
def run_ansible(params, check_mode):
| ocsecret = OCSecret(params['namespace'], params['name'], params['type'], params['decode'], kubeconfig=params['kubeconfig'], verbose=params['debug'])
state = params['state']
api_rval = ocsecret.get()
if (state == 'list'):
return {'changed': False, 'results': api_rval, state: 'list'}
if (not p... |
'Constructor for OCProject'
| def __init__(self, config, verbose=False):
| super(OCProject, self).__init__(None, config.kubeconfig)
self.config = config
self._project = None
|
'property for project'
| @property
def project(self):
| if (not self._project):
self.get()
return self._project
|
'setter function for project propeorty'
| @project.setter
def project(self, data):
| self._project = data
|
'return whether a project exists'
| def exists(self):
| if self.project:
return True
return False
|
'return project'
| def get(self):
| result = self._get(self.kind, self.config.name)
if (result['returncode'] == 0):
self.project = Project(content=result['results'][0])
result['results'] = self.project.yaml_dict
elif (('namespaces "%s" not found' % self.config.name) in result['stderr']):
result = {'results': [... |
'delete the object'
| def delete(self):
| return self._delete(self.kind, self.config.name)
|
'create a project'
| def create(self):
| cmd = ['new-project', self.config.name]
cmd.extend(self.config.to_option_list())
return self.openshift_cmd(cmd, oadm=True)
|
'update a project'
| def update(self):
| if (self.config.config_options['display_name']['value'] is not None):
self.project.update_annotation('display-name', self.config.config_options['display_name']['value'])
if (self.config.config_options['description']['value'] is not None):
self.project.update_annotation('description', self.config... |
'verify an update is needed'
| def needs_update(self):
| if (self.config.config_options['display_name']['value'] is not None):
result = self.project.find_annotation('display-name')
if (result != self.config.config_options['display_name']['value']):
return True
if (self.config.config_options['description']['value'] is not None):
res... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.