desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'return replicas setting'
| def get_replicas(self):
| return self.get(DeploymentConfig.replicas_path)
|
'return volume mount information'
| def get_volume_mounts(self):
| return self.get_volumes(mounts=True)
|
'return volume mount information'
| def get_volumes(self, mounts=False):
| if mounts:
return (self.get(DeploymentConfig.volume_mounts_path) or [])
return (self.get(DeploymentConfig.volumes_path) or [])
|
'delete a volume'
| def delete_volume_by_name(self, volume):
| modified = False
exist_volume_mounts = self.get_volume_mounts()
exist_volumes = self.get_volumes()
del_idx = None
for (idx, exist_volume) in enumerate(exist_volumes):
if (('name' in exist_volume) and (exist_volume['name'] == volume['name'])):
del_idx = idx
break
i... |
'add a volume or volume mount to the proper location'
| def add_volume_mount(self, volume_mount):
| exist_volume_mounts = self.get_volume_mounts()
if ((not exist_volume_mounts) and volume_mount):
self.put(DeploymentConfig.volume_mounts_path, [volume_mount])
else:
exist_volume_mounts.append(volume_mount)
|
'add a volume or volume mount to the proper location'
| def add_volume(self, volume):
| exist_volumes = self.get_volumes()
if (not volume):
return
if (not exist_volumes):
self.put(DeploymentConfig.volumes_path, [volume])
else:
exist_volumes.append(volume)
|
'update replicas value'
| def update_replicas(self, replicas):
| self.put(DeploymentConfig.replicas_path, replicas)
|
'place an env in the env var list'
| def update_volume(self, volume):
| exist_volumes = self.get_volumes()
if (not volume):
return False
update_idx = None
for (idx, exist_vol) in enumerate(exist_volumes):
if (exist_vol['name'] == volume['name']):
update_idx = idx
break
if (update_idx != None):
exist_volumes[update_idx] = v... |
'place an env in the env var list'
| def update_volume_mount(self, volume_mount):
| modified = False
exist_volume_mounts = self.get_volume_mounts()
if (not volume_mount):
return False
for exist_vol_mount in exist_volume_mounts:
if (exist_vol_mount['name'] == volume_mount['name']):
if (('mountPath' in exist_vol_mount) and (str(exist_vol_mount['mountPath']) !=... |
'verify a volume update is needed'
| def needs_update_volume(self, volume, volume_mount):
| exist_volume = self.find_volume_by_name(volume)
exist_volume_mount = self.find_volume_by_name(volume, mounts=True)
results = []
results.append((exist_volume['name'] == volume['name']))
if ('secret' in volume):
results.append(('secret' in exist_volume))
results.append((exist_volume['s... |
'verify whether a replica update is needed'
| def needs_update_replicas(self, replicas):
| current_reps = self.get(DeploymentConfig.replicas_path)
return (not (current_reps == replicas))
|
'instantiate a properly structured volume'
| def create_dict(self):
| self.data['apiVersion'] = 'v1'
self.data['kind'] = 'ServiceAccount'
self.data['metadata'] = {}
self.data['metadata']['name'] = self.name
self.data['metadata']['namespace'] = self.namespace
self.data['secrets'] = []
if self.secrets:
for sec in self.secrets:
self.data['secr... |
'ServiceAccount constructor'
| def __init__(self, content):
| super(ServiceAccount, self).__init__(content=content)
self._secrets = None
self._image_pull_secrets = None
|
'property for image_pull_secrets'
| @property
def image_pull_secrets(self):
| if (self._image_pull_secrets is None):
self._image_pull_secrets = (self.get(ServiceAccount.image_pull_secrets_path) or [])
return self._image_pull_secrets
|
'property for secrets'
| @image_pull_secrets.setter
def image_pull_secrets(self, secrets):
| self._image_pull_secrets = secrets
|
'property for secrets'
| @property
def secrets(self):
| if (not self._secrets):
self._secrets = (self.get(ServiceAccount.secrets_path) or [])
return self._secrets
|
'property for secrets'
| @secrets.setter
def secrets(self, secrets):
| self._secrets = secrets
|
'remove a secret'
| def delete_secret(self, inc_secret):
| remove_idx = None
for (idx, sec) in enumerate(self.secrets):
if (sec['name'] == inc_secret):
remove_idx = idx
break
if remove_idx:
del self.secrets[remove_idx]
return True
return False
|
'remove a image_pull_secret'
| def delete_image_pull_secret(self, inc_secret):
| remove_idx = None
for (idx, sec) in enumerate(self.image_pull_secrets):
if (sec['name'] == inc_secret):
remove_idx = idx
break
if remove_idx:
del self.image_pull_secrets[remove_idx]
return True
return False
|
'find secret'
| def find_secret(self, inc_secret):
| for secret in self.secrets:
if (secret['name'] == inc_secret):
return secret
return None
|
'find secret'
| def find_image_pull_secret(self, inc_secret):
| for secret in self.image_pull_secrets:
if (secret['name'] == inc_secret):
return secret
return None
|
'add secret'
| def add_secret(self, inc_secret):
| if self.secrets:
self.secrets.append({'name': inc_secret})
else:
self.put(ServiceAccount.secrets_path, [{'name': inc_secret}])
|
'add image_pull_secret'
| def add_image_pull_secret(self, inc_secret):
| if self.image_pull_secrets:
self.image_pull_secrets.append({'name': inc_secret})
else:
self.put(ServiceAccount.image_pull_secrets_path, [{'name': inc_secret}])
|
'constructor for handling secret options'
| def __init__(self, sname, namespace, kubeconfig, secrets=None, stype=None):
| self.kubeconfig = kubeconfig
self.name = sname
self.type = stype
self.namespace = namespace
self.secrets = secrets
self.data = {}
self.create_dict()
|
'assign the correct properties for a secret dict'
| def create_dict(self):
| self.data['apiVersion'] = 'v1'
self.data['kind'] = 'Secret'
self.data['type'] = self.type
self.data['metadata'] = {}
self.data['metadata']['name'] = self.name
self.data['metadata']['namespace'] = self.namespace
self.data['data'] = {}
if self.secrets:
for (key, value) in self.secr... |
'secret constructor'
| def __init__(self, content):
| super(Secret, self).__init__(content=content)
self._secrets = None
|
'secret property getter'
| @property
def secrets(self):
| if (self._secrets is None):
self._secrets = self.get_secrets()
return self._secrets
|
'secret property setter'
| @secrets.setter
def secrets(self):
| if (self._secrets is None):
self._secrets = self.get_secrets()
return self._secrets
|
'returns all of the defined secrets'
| def get_secrets(self):
| return (self.get(Secret.secret_path) or {})
|
'add a secret'
| def add_secret(self, key, value):
| if self.secrets:
self.secrets[key] = value
else:
self.put(Secret.secret_path, {key: value})
return True
|
'delete secret'
| def delete_secret(self, key):
| try:
del self.secrets[key]
except KeyError as _:
return False
return True
|
'find secret'
| def find_secret(self, key):
| rval = None
try:
rval = self.secrets[key]
except KeyError as _:
return None
return {'key': key, 'value': rval}
|
'update a secret'
| def update_secret(self, key, value):
| if (key in self.secrets):
self.secrets[key] = value
else:
self.add_secret(key, value)
return True
|
'constructor for handling rolebinding options'
| def __init__(self, name, namespace, kubeconfig, group_names=None, role_ref=None, subjects=None, usernames=None):
| self.kubeconfig = kubeconfig
self.name = name
self.namespace = namespace
self.group_names = group_names
self.role_ref = role_ref
self.subjects = subjects
self.usernames = usernames
self.data = {}
self.create_dict()
|
'create a default rolebinding as a dict'
| def create_dict(self):
| self.data['apiVersion'] = 'v1'
self.data['kind'] = 'RoleBinding'
self.data['groupNames'] = self.group_names
self.data['metadata']['name'] = self.name
self.data['metadata']['namespace'] = self.namespace
self.data['roleRef'] = self.role_ref
self.data['subjects'] = self.subjects
self.data['... |
'RoleBinding constructor'
| def __init__(self, content):
| super(RoleBinding, self).__init__(content=content)
self._subjects = None
self._role_ref = None
self._group_names = None
self._user_names = None
|
'subjects property'
| @property
def subjects(self):
| if (self._subjects is None):
self._subjects = self.get_subjects()
return self._subjects
|
'subjects property setter'
| @subjects.setter
def subjects(self, data):
| self._subjects = data
|
'role_ref property'
| @property
def role_ref(self):
| if (self._role_ref is None):
self._role_ref = self.get_role_ref()
return self._role_ref
|
'role_ref property setter'
| @role_ref.setter
def role_ref(self, data):
| self._role_ref = data
|
'group_names property'
| @property
def group_names(self):
| if (self._group_names is None):
self._group_names = self.get_group_names()
return self._group_names
|
'group_names property setter'
| @group_names.setter
def group_names(self, data):
| self._group_names = data
|
'user_names property'
| @property
def user_names(self):
| if (self._user_names is None):
self._user_names = self.get_user_names()
return self._user_names
|
'user_names property setter'
| @user_names.setter
def user_names(self, data):
| self._user_names = data
|
'return groupNames'
| def get_group_names(self):
| return (self.get(RoleBinding.group_names_path) or [])
|
'return usernames'
| def get_user_names(self):
| return (self.get(RoleBinding.user_names_path) or [])
|
'return role_ref'
| def get_role_ref(self):
| return (self.get(RoleBinding.role_ref_path) or {})
|
'return subjects'
| def get_subjects(self):
| return (self.get(RoleBinding.subjects_path) or [])
|
'add a subject'
| def add_subject(self, inc_subject):
| if self.subjects:
self.subjects.append(inc_subject)
else:
self.put(RoleBinding.subjects_path, [inc_subject])
return True
|
'add a role_ref'
| def add_role_ref(self, inc_role_ref):
| if (not self.role_ref):
self.put(RoleBinding.role_ref_path, {'name': inc_role_ref})
return True
return False
|
'add a group_names'
| def add_group_names(self, inc_group_names):
| if self.group_names:
self.group_names.append(inc_group_names)
else:
self.put(RoleBinding.group_names_path, [inc_group_names])
return True
|
'add a username'
| def add_user_name(self, inc_user_name):
| if self.user_names:
self.user_names.append(inc_user_name)
else:
self.put(RoleBinding.user_names_path, [inc_user_name])
return True
|
'remove a subject'
| def remove_subject(self, inc_subject):
| try:
self.subjects.remove(inc_subject)
except ValueError as _:
return False
return True
|
'remove a role_ref'
| def remove_role_ref(self, inc_role_ref):
| if (self.role_ref and (self.role_ref['name'] == inc_role_ref)):
del self.role_ref['name']
return True
return False
|
'remove a groupname'
| def remove_group_name(self, inc_group_name):
| try:
self.group_names.remove(inc_group_name)
except ValueError as _:
return False
return True
|
'remove a username'
| def remove_user_name(self, inc_user_name):
| try:
self.user_names.remove(inc_user_name)
except ValueError as _:
return False
return True
|
'update a subject'
| def update_subject(self, inc_subject):
| try:
index = self.subjects.index(inc_subject)
except ValueError as _:
return self.add_subject(inc_subject)
self.subjects[index] = inc_subject
return True
|
'update a groupname'
| def update_group_name(self, inc_group_name):
| try:
index = self.group_names.index(inc_group_name)
except ValueError as _:
return self.add_group_names(inc_group_name)
self.group_names[index] = inc_group_name
return True
|
'update a username'
| def update_user_name(self, inc_user_name):
| try:
index = self.user_names.index(inc_user_name)
except ValueError as _:
return self.add_user_name(inc_user_name)
self.user_names[index] = inc_user_name
return True
|
'update a role_ref'
| def update_role_ref(self, inc_role_ref):
| self.role_ref['name'] = inc_role_ref
return True
|
'find a subject'
| def find_subject(self, inc_subject):
| index = None
try:
index = self.subjects.index(inc_subject)
except ValueError as _:
return index
return index
|
'find a group_name'
| def find_group_name(self, inc_group_name):
| index = None
try:
index = self.group_names.index(inc_group_name)
except ValueError as _:
return index
return index
|
'find a user_name'
| def find_user_name(self, inc_user_name):
| index = None
try:
index = self.user_names.index(inc_user_name)
except ValueError as _:
return index
return index
|
'find a user_name'
| def find_role_ref(self, inc_role_ref):
| if (self.role_ref and (self.role_ref['name'] == inc_role_ref['name'])):
return self.role_ref
return None
|
'Constructor for OpenshiftOC
a router consists of 3 or more parts
- dc/router
- svc/router
- sa/router
- secret/router-certs
- clusterrolebinding/router-router-role'
| def __init__(self, router_config, verbose=False):
| super(Router, self).__init__('default', router_config.kubeconfig, verbose)
self.config = router_config
self.verbose = verbose
self.router_parts = [{'kind': 'dc', 'name': self.config.name}, {'kind': 'svc', 'name': self.config.name}, {'kind': 'sa', 'name': self.config.config_options['service_account']['va... |
'property for the prepared router'
| @property
def prepared_router(self):
| if (self.__prepared_router is None):
results = self._prepare_router()
if ((not results) or (('returncode' in results) and (results['returncode'] != 0))):
if ('stderr' in results):
raise RouterException(('Could not perform router preparation: %s' % results['... |
'setter for the prepared_router'
| @prepared_router.setter
def prepared_router(self, obj):
| self.__prepared_router = obj
|
'property deploymentconfig'
| @property
def deploymentconfig(self):
| return self.dconfig
|
'setter for property deploymentconfig'
| @deploymentconfig.setter
def deploymentconfig(self, config):
| self.dconfig = config
|
'property for service'
| @property
def service(self):
| return self.svc
|
'setter for property service'
| @service.setter
def service(self, config):
| self.svc = config
|
'property secret'
| @property
def secret(self):
| return self._secret
|
'setter for property secret'
| @secret.setter
def secret(self, config):
| self._secret = config
|
'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... |
'getter method for separator'
| @property
def separator(self):
| return self._separator
|
'setter method for separator'
| @separator.setter
def separator(self, inc_sep):
| self._separator = inc_sep
|
'getter method for yaml_dict'
| @property
def yaml_dict(self):
| return self.__yaml_dict
|
'setter method for yaml_dict'
| @yaml_dict.setter
def yaml_dict(self, value):
| self.__yaml_dict = value
|
'parse the key allowing the appropriate separator'
| @staticmethod
def parse_key(key, sep='.'):
| common_separators = list((Yedit.com_sep - set([sep])))
return re.findall(Yedit.re_key.format(''.join(common_separators)), key)
|
'validate the incoming key'
| @staticmethod
def valid_key(key, sep='.'):
| common_separators = list((Yedit.com_sep - set([sep])))
if (not re.match(Yedit.re_valid_key.format(''.join(common_separators)), key)):
return False
return True
|
'remove data at location key'
| @staticmethod
def remove_entry(data, key, sep='.'):
| 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_ke... |
'Get an item from a dictionary with key notation a.b.c
d = {\'a\': {\'b\': \'c\'}}}
key = a#b
return c'
| @staticmethod
def add_entry(data, key, item=None, sep='.'):
| 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) ... |
'Get an item from a dictionary with key notation a.b.c
d = {\'a\': {\'b\': \'c\'}}}
key = a.b
return c'
| @staticmethod
def get_entry(data, key, sep='.'):
| 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)
... |
'Actually write the file contents to disk. This helps with mocking.'
| @staticmethod
def _write(filename, contents):
| tmp_filename = (filename + '.yedit')
with open(tmp_filename, 'w') as yfd:
yfd.write(contents)
os.rename(tmp_filename, filename)
|
'write to file'
| def write(self):
| if (not self.filename):
raise YeditException('Please specify a filename.')
if (self.backup and self.file_exists()):
shutil.copy(self.filename, (self.filename + '.orig'))
try:
self.yaml_dict.fa.set_block_style()
except AttributeError:
pass
try:
Yedit._... |
'read from file'
| def read(self):
| 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
|
'return whether file exists'
| def file_exists(self):
| if os.path.exists(self.filename):
return True
return False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.