desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'set a provider item based on the list of item names provided.'
| def set_provider_item(self, items, required=False):
| for item in items:
provider_key = items[0]
if (item in self._idp):
self.provider[provider_key] = self._idp.pop(item)
break
else:
default = self.get_default(provider_key)
if (default is not None):
self.provider[provider_key] = default
el... |
'set the provider items for this idp'
| def set_provider_items(self):
| for items in self._required:
self.set_provider_item(items, True)
for items in self._optional:
self.set_provider_item(items)
if self._allow_additional:
for key in self._idp.keys():
self.set_provider_item([key])
elif (len(self._idp) > 0):
raise errors.AnsibleFil... |
'translate this idp to a dictionary'
| def to_dict(self):
| return dict(name=self.name, challenge=self.challenge, login=self.login, mappingMethod=self.mapping_method, provider=self.provider)
|
'validate this idp instance'
| def validate(self):
| if (not isinstance(self.provider['attributes'], dict)):
raise errors.AnsibleFilterError('|failed attributes for provider {0} must be a dictionary'.format(self.__class__.__name__))
attrs = ['id', 'email', 'name', 'preferredUsername']
for attr in attrs:
if ((attr in sel... |
'validate this idp instance'
| def validate(self):
| if (not isinstance(self.provider['headers'], list)):
raise errors.AnsibleFilterError('|failed headers for provider {0} must be a list'.format(self.__class__.__name__))
|
'validate this idp instance'
| def validate(self):
| if self.challenge:
raise errors.AnsibleFilterError('|failed provider {0} does not allow challenge authentication'.format(self.__class__.__name__))
|
'validate this idp instance'
| def validate(self):
| IdentityProviderOauthBase.validate(self)
if (not isinstance(self.provider['claims'], dict)):
raise errors.AnsibleFilterError('|failed claims for provider {0} must be a dictionary'.format(self.__class__.__name__))
for (var, var_type) in (('extraScopes', list), ('extraAuthorize... |
'Translates a list of dictionaries into a valid identityProviders config'
| @staticmethod
def translate_idps(idps, api_version, openshift_version, deployment_type):
| idp_list = []
if (not isinstance(idps, list)):
raise errors.AnsibleFilterError('|failed expects to filter on a list of identity providers')
for idp in idps:
if (not isinstance(idp, dict)):
raise errors.AnsibleFilterError('|failed identity provider... |
'Validates output from "pcs status", ensuring that each master
provided is online.
Ex: data = (\'...\',
\'PCSD Status:\',
\'master1.example.com: Online\',
\'master2.example.com: Online\',
\'master3.example.com: Online\',
masters = [\'master1.example.com\',
\'master2.example.com\',
\'master3.example.com\']
returns True'... | @staticmethod
def validate_pcs_cluster(data, masters=None):
| if (not issubclass(type(data), string_types)):
raise errors.AnsibleFilterError('|failed expects data is a string or unicode')
if (not issubclass(type(masters), list)):
raise errors.AnsibleFilterError('|failed expects masters is a list')
valid = True
fo... |
'Return certificates to synchronize based on facts.'
| @staticmethod
def certificates_to_synchronize(hostvars, include_keys=True, include_ca=True):
| if (not issubclass(type(hostvars), dict)):
raise errors.AnsibleFilterError('|failed expects hostvars is a dict')
certs = ['admin.crt', 'admin.key', 'admin.kubeconfig', 'master.kubelet-client.crt', 'master.kubelet-client.key']
if bool(include_ca):
certs += ['ca.crt', 'ca.key', ... |
'return a dictionary of htpasswd users from htpasswd file contents'
| @staticmethod
def oo_htpasswd_users_from_file(file_contents):
| htpasswd_entries = {}
if (not isinstance(file_contents, string_types)):
raise errors.AnsibleFilterError('failed, expects to filter on a string')
for line in file_contents.splitlines():
user = None
passwd = None
if (len(line) == 0):
continue
... |
'returns a mapping of filters to methods'
| def filters(self):
| return {'translate_idps': self.translate_idps, 'validate_pcs_cluster': self.validate_pcs_cluster, 'certificates_to_synchronize': self.certificates_to_synchronize, 'oo_htpasswd_users_from_file': self.oo_htpasswd_users_from_file}
|
'constructor for handling group options'
| def __init__(self, sname, namespace, kubeconfig):
| self.kubeconfig = kubeconfig
self.name = sname
self.namespace = namespace
self.data = {}
self.create_dict()
|
'return a service as a dict'
| def create_dict(self):
| self.data['apiVersion'] = 'v1'
self.data['kind'] = 'Group'
self.data['metadata'] = {}
self.data['metadata']['name'] = self.name
self.data['users'] = None
|
'Group constructor'
| def __init__(self, content):
| super(Group, self).__init__(content=content)
|
'Constructor for clusterrole'
| def __init__(self, name=None, content=None):
| if (content is None):
content = ClusterRole.builder(name).yaml_dict
super(ClusterRole, self).__init__(content=content)
self.__rules = (Rule.parse_rules(self.get(ClusterRole.rules_path)) or [])
|
'attempt to find the inc_rule in the rules list'
| def rule_exists(self, inc_rule):
| for rule in self.rules:
if (rule == inc_rule):
return True
return False
|
'compare function for clusterrole'
| def compare(self, other, verbose=False):
| for rule in other.rules:
if (rule not in self.rules):
if verbose:
print 'Rule in other not found in self. [{}]'.format(rule)
return False
for rule in self.rules:
if (rule not in other.rules):
if verbose:
pri... |
'return a clusterrole with name and/or rules'
| @staticmethod
def builder(name='default_clusterrole', rules=None):
| if (rules is None):
rules = [{'apiGroups': [''], 'attributeRestrictions': None, 'verbs': [], 'resources': []}]
content = {'apiVersion': 'v1', 'kind': 'ClusterRole', 'metadata': {'name': '{}'.format(name)}, 'rules': rules}
return ClusterRole(content=content)
|
'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 OpenshiftCLI'
| def __init__(self, namespace, kubeconfig='/etc/origin/master/admin.kubeconfig', verbose=False, all_namespaces=False):
| self.namespace = namespace
self.verbose = verbose
self.kubeconfig = Utils.create_tmpfile_copy(kubeconfig)
self.all_namespaces = all_namespaces
self.oc_binary = locate_oc_binary()
|
'replace the current object with the content'
| def _replace_content(self, resource, rname, content, force=False, sep='.'):
| res = self._get(resource, rname)
if (not res['results']):
return res
fname = Utils.create_tmpfile((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 ch... |
'replace the current object with oc replace'
| def _replace(self, fname, force=False):
| yed = Yedit(fname)
results = yed.delete('metadata.resourceVersion')
if results[0]:
yed.write()
cmd = ['replace', '-f', fname]
if force:
cmd.append('--force')
return self.openshift_cmd(cmd)
|
'create a temporary file and then call oc create on it'
| def _create_from_content(self, rname, content):
| fname = Utils.create_tmpfile((rname + '-'))
yed = Yedit(fname, content=content)
yed.write()
atexit.register(Utils.cleanup, [fname])
return self._create(fname)
|
'call oc create on a filename'
| def _create(self, fname):
| return self.openshift_cmd(['create', '-f', fname])
|
'call oc delete on a resource'
| def _delete(self, resource, name=None, selector=None):
| cmd = ['delete', resource]
if (selector is not None):
cmd.append('--selector={}'.format(selector))
elif (name is not None):
cmd.append(name)
else:
raise OpenShiftCLIError('Either name or selector is required when calling delete.')
return self.openshift... |
'process a template
template_name: the name of the template to process
create: whether to send to oc create after processing
params: the parameters for the template
template_data: the incoming template\'s data; instead of a file'
| def _process(self, template_name, create=False, params=None, template_data=None):
| cmd = ['process']
if template_data:
cmd.extend(['-f', '-'])
else:
cmd.append(template_name)
if params:
param_str = ['{}={}'.format(key, str(value).replace("'", '"')) for (key, value) in params.items()]
cmd.append('-v')
cmd.extend(param_str)
results = self.open... |
'return a resource by name'
| def _get(self, resource, name=None, selector=None):
| cmd = ['get', resource]
if (selector is not None):
cmd.append('--selector={}'.format(selector))
elif (name is not None):
cmd.append(name)
cmd.extend(['-o', 'json'])
rval = self.openshift_cmd(cmd, output=True)
if ('items' in rval):
rval['results'] = rval['items']
elif ... |
'perform oadm manage-node scheduable'
| def _schedulable(self, node=None, selector=None, schedulable=True):
| cmd = ['manage-node']
if node:
cmd.extend(node)
else:
cmd.append('--selector={}'.format(selector))
cmd.append('--schedulable={}'.format(schedulable))
return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw')
|
'perform oadm list pods
node: the node in which to list pods
selector: the label selector filter if provided
pod_selector: the pod selector filter if provided'
| def _list_pods(self, node=None, selector=None, pod_selector=None):
| cmd = ['manage-node']
if node:
cmd.extend(node)
else:
cmd.append('--selector={}'.format(selector))
if pod_selector:
cmd.append('--pod-selector={}'.format(pod_selector))
cmd.extend(['--list-pods', '-o', 'json'])
return self.openshift_cmd(cmd, oadm=True, output=True, output... |
'perform oadm manage-node evacuate'
| def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False):
| cmd = ['manage-node']
if node:
cmd.extend(node)
else:
cmd.append('--selector={}'.format(selector))
if dry_run:
cmd.append('--dry-run')
if pod_selector:
cmd.append('--pod-selector={}'.format(pod_selector))
if grace_period:
cmd.append('--grace-period={}'.for... |
'return the openshift version'
| def _version(self):
| return self.openshift_cmd(['version'], output=True, output_type='raw')
|
'perform image import'
| def _import_image(self, url=None, name=None, tag=None):
| 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)
|
'Actually executes the command. This makes mocking easier.'
| def _run(self, cmds, input_data):
| curr_env = os.environ.copy()
curr_env.update({'KUBECONFIG': self.kubeconfig})
proc = subprocess.Popen(cmds, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=curr_env)
(stdout, stderr) = proc.communicate(input_data)
return (proc.returncode, stdout.decode('utf-8'), stderr.dec... |
'Base command for oc'
| def openshift_cmd(self, cmd, oadm=False, output=False, output_type='json', input_data=None):
| cmds = [self.oc_binary]
if oadm:
cmds.append('adm')
cmds.extend(cmd)
if self.all_namespaces:
cmds.extend(['--all-namespaces'])
elif ((self.namespace is not None) and (self.namespace.lower() not in ['none', 'emtpy'])):
cmds.extend(['-n', self.namespace])
if self.verbose:
... |
'Actually write the file contents to disk. This helps with mocking.'
| @staticmethod
def _write(filename, contents):
| with open(filename, 'w') as sfd:
sfd.write(contents)
|
'create a file in tmp with name and contents'
| @staticmethod
def create_tmp_file_from_contents(rname, data, ftype='yaml'):
| tmp = Utils.create_tmpfile(prefix=rname)
if (ftype == 'yaml'):
if hasattr(yaml, 'RoundTripDumper'):
Utils._write(tmp, yaml.dump(data, Dumper=yaml.RoundTripDumper))
else:
Utils._write(tmp, yaml.safe_dump(data, default_flow_style=False))
elif (ftype == 'json'):
... |
'create a temporary copy of a file'
| @staticmethod
def create_tmpfile_copy(inc_file):
| tmpfile = Utils.create_tmpfile('lib_openshift-')
Utils._write(tmpfile, open(inc_file).read())
atexit.register(Utils.cleanup, [tmpfile])
return tmpfile
|
'Generates and returns a temporary file name'
| @staticmethod
def create_tmpfile(prefix='tmp'):
| with tempfile.NamedTemporaryFile(prefix=prefix, delete=False) as tmp:
return tmp.name
|
'Turn an array of dict: filename, content into a files array'
| @staticmethod
def create_tmp_files_from_contents(content, content_type=None):
| if (not isinstance(content, list)):
content = [content]
files = []
for item in content:
path = Utils.create_tmp_file_from_contents((item['path'] + '-'), item['data'], ftype=content_type)
files.append({'name': os.path.basename(item['path']), 'path': path})
return files
|
'Clean up on exit'
| @staticmethod
def cleanup(files):
| 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)
|
'Check to see if the results include the name'
| @staticmethod
def exists(results, _name):
| if (not results):
return False
if Utils.find_result(results, _name):
return True
return False
|
'Find the specified result by name'
| @staticmethod
def find_result(results, _name):
| rval = None
for result in results:
if (('metadata' in result) and (result['metadata']['name'] == _name)):
rval = result
break
return rval
|
'return the service file'
| @staticmethod
def get_resource_file(sfile, sfile_type='yaml'):
| contents = None
with open(sfile) as sfd:
contents = sfd.read()
if (sfile_type == 'yaml'):
if hasattr(yaml, 'RoundTripLoader'):
contents = yaml.load(contents, yaml.RoundTripLoader)
else:
contents = yaml.safe_load(contents)
elif (sfile_type == 'json'):
... |
'filter the oc version output'
| @staticmethod
def filter_versions(stdout):
| version_dict = {}
version_search = ['oc', 'openshift', 'kubernetes']
for line in stdout.strip().split('\n'):
for term in version_search:
if (not line):
continue
if line.startswith(term):
version_dict[term] = line.split()[(-1)]
if ('openshif... |
'create custom versions strings'
| @staticmethod
def add_custom_versions(versions):
| versions_dict = {}
for (tech, version) in versions.items():
if ('-' in version):
version = version.split('-')[0]
if version.startswith('v'):
versions_dict[(tech + '_numeric')] = version[1:].split('+')[0]
versions_dict[(tech + '_short')] = version[1:4]
retu... |
'check if openshift is installed'
| @staticmethod
def openshift_installed():
| import yum
yum_base = yum.YumBase()
if yum_base.rpmdb.searchNevra(name='atomic-openshift'):
return True
return False
|
'Given a user defined definition, compare it with the results given back by our query.'
| @staticmethod
def check_def_equal(user_def, result_def, skip_keys=None, debug=False):
| skip = ['metadata', 'status']
if skip_keys:
skip.extend(skip_keys)
for (key, value) in result_def.items():
if (key in skip):
continue
if isinstance(value, list):
if (key not in user_def):
if debug:
print ('User data do... |
'return config options'
| @property
def config_options(self):
| return self._options
|
'return all options as a string
if ascommalist is set to the name of a key, and
the value of that key is a dict, format the dict
as a list of comma delimited key=value pairs'
| def to_option_list(self, ascommalist=''):
| return self.stringify(ascommalist)
|
'return the options hash as cli params in a string
if ascommalist is set to the name of a key, and
the value of that key is a dict, format the dict
as a list of comma delimited key=value pairs'
| def stringify(self, ascommalist=''):
| rval = []
for key in sorted(self.config_options.keys()):
data = self.config_options[key]
if (data['include'] and (data['value'] or isinstance(data['value'], int))):
if (key == ascommalist):
val = ','.join(['{}={}'.format(kk, vv) for (kk, vv) in sorted(data['value'].it... |
'Constructor for ReplicationController'
| def __init__(self, content):
| super(ReplicationController, self).__init__(content=content)
|
'constructor for handling pvc options'
| def __init__(self, sname, namespace, kubeconfig, access_modes=None, vol_capacity='1G', selector=None, storage_class_name=None):
| self.kubeconfig = kubeconfig
self.name = sname
self.namespace = namespace
self.access_modes = access_modes
self.vol_capacity = vol_capacity
self.data = {}
self.selector = selector
self.storage_class_name = storage_class_name
self.create_dict()
|
'return a service as a dict'
| def create_dict(self):
| self.data['apiVersion'] = 'v1'
self.data['kind'] = 'PersistentVolumeClaim'
self.data['metadata'] = {}
self.data['metadata']['name'] = self.name
self.data['spec'] = {}
self.data['spec']['accessModes'] = ['ReadWriteOnce']
if self.access_modes:
self.data['spec']['accessModes'] = self.ac... |
'PersistentVolumeClaim constructor'
| def __init__(self, content):
| super(PersistentVolumeClaim, self).__init__(content=content)
self._access_modes = None
self._volume_capacity = None
self._volume_name = None
self._selector = None
self._storage_class_name = None
|
'storage_class_name property'
| @property
def storage_class_name(self):
| if (self._storage_class_name is None):
self._storage_class_name = self.get_storage_class_name()
return self._storage_class_name
|
'storage_class_name property setter'
| @storage_class_name.setter
def storage_class_name(self, data):
| self._storage_class_name = data
|
'volume_name property'
| @property
def volume_name(self):
| if (self._volume_name is None):
self._volume_name = self.get_volume_name()
return self._volume_name
|
'volume_name property setter'
| @volume_name.setter
def volume_name(self, data):
| self._volume_name = data
|
'selector property'
| @property
def selector(self):
| if (self._selector is None):
self._selector = self.get_selector()
if (not isinstance(self._selector, dict)):
self._selector = dict(self._selector)
return self._selector
|
'selector property setter'
| @selector.setter
def selector(self, data):
| if (not isinstance(data, dict)):
data = dict(data)
self._selector = data
|
'access_modes property'
| @property
def access_modes(self):
| if (self._access_modes is None):
self._access_modes = self.get_access_modes()
if (not isinstance(self._access_modes, list)):
self._access_modes = list(self._access_modes)
return self._access_modes
|
'access_modes property setter'
| @access_modes.setter
def access_modes(self, data):
| if (not isinstance(data, list)):
data = list(data)
self._access_modes = data
|
'volume_capacity property'
| @property
def volume_capacity(self):
| if (self._volume_capacity is None):
self._volume_capacity = self.get_volume_capacity()
return self._volume_capacity
|
'volume_capacity property setter'
| @volume_capacity.setter
def volume_capacity(self, data):
| self._volume_capacity = data
|
'get storage_class_name'
| def get_storage_class_name(self):
| return (self.get(PersistentVolumeClaim.storage_class_name_path) or [])
|
'get selector'
| def get_selector(self):
| return (self.get(PersistentVolumeClaim.selector_path) or [])
|
'get access_modes'
| def get_access_modes(self):
| return (self.get(PersistentVolumeClaim.access_modes_path) or [])
|
'get volume_capacity'
| def get_volume_capacity(self):
| return (self.get(PersistentVolumeClaim.volume_capacity_path) or [])
|
'get volume_name'
| def get_volume_name(self):
| return (self.get(PersistentVolumeClaim.volume_name_path) or [])
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.