Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
@type file_prefix: str
@param cert_dir: absolute path to the location in which the cert bundle should
be written; cannot be None
@type cert_dir: str
@param bundle: cert bundle (see module docs for more information on format)
@type bundle: dict {str, str}
@raises ValueError: if bundle is invalid (see validate_cert_bundle)
@return: mapping of cert bundle item (see module docs) to the absolute path
to where it is stored on disk
'''
file_prefix = encode_unicode(file_prefix)
cert_dir = encode_unicode(cert_dir)
WRITE_LOCK.acquire()
try:
# Create the cert directory if it doesn't exist
if not os.path.exists(cert_dir):
os.makedirs(cert_dir)
# For each item in the cert bundle, save it to disk using the given prefix
# to identify the type of bundle it belongs to. If the value is None, the
# item is being deleted.
cert_files = {}
for key, value in bundle.items():
filename = os.path.join(cert_dir, '%s.%s' % (file_prefix, key))
try:
"""
Recursively traverse any input structures and ensure any strings are
encoded as utf-8.
:param input: input data
:return: input data with strings encoded as utf-8
"""
if isinstance(input, (list, set, tuple)):
return [_ensure_input_encoding(i) for i in input]
if isinstance(input, dict):
return dict((_ensure_input_encoding(k), _ensure_input_encoding(v))
for k, v in input.items())
try:
return encode_unicode(decode_unicode(input))
except (UnicodeDecodeError, UnicodeEncodeError):
raise InputEncodingError(input), None, sys.exc_info()[2]
@type file_prefix: str
@param cert_dir: absolute path to the location in which the cert bundle should
be written; cannot be None
@type cert_dir: str
@param bundle: cert bundle (see module docs for more information on format)
@type bundle: dict {str, str}
@raises ValueError: if bundle is invalid (see validate_cert_bundle)
@return: mapping of cert bundle item (see module docs) to the absolute path
to where it is stored on disk
'''
file_prefix = encode_unicode(file_prefix)
cert_dir = encode_unicode(cert_dir)
WRITE_LOCK.acquire()
try:
# Create the cert directory if it doesn't exist
if not os.path.exists(cert_dir):
os.makedirs(cert_dir)
# For each item in the cert bundle, save it to disk using the given prefix
# to identify the type of bundle it belongs to. If the value is None, the
# item is being deleted.
cert_files = {}
for key, value in bundle.items():
filename = os.path.join(cert_dir, '%s.%s' % (file_prefix, key))
try:
def add_packages_from_dir(self, dir, repo_id, skip=None):
repo = self.repo_api._get_existing_repo(repo_id)
added_packages = {}
if "yum" not in repo['content_types']:
return added_packages
if not skip:
skip = {}
if not skip.has_key('packages') or skip['packages'] != 1:
startTime = time.time()
log.debug("Begin to add packages from %s into %s" % (encode_unicode(dir), encode_unicode(repo['id'])))
unfiltered_pkglist = pulp.server.util.get_repo_packages(dir)
# Process repo filters if any
if repo['filters']:
log.info("Repo filters : %s" % repo['filters'])
whitelist_packages = self.repo_api.find_combined_whitelist_packages(repo['filters'])
blacklist_packages = self.repo_api.find_combined_blacklist_packages(repo['filters'])
log.info("combined whitelist packages = %s" % whitelist_packages)
log.info("combined blacklist packages = %s" % blacklist_packages)
else:
whitelist_packages = []
blacklist_packages = []
package_list = self._find_filtered_package_list(unfiltered_pkglist, whitelist_packages, blacklist_packages, dst_repo_dir=self.repo_dir)
log.debug("Processing %s potential packages" % (len(package_list)))
for package in package_list:
pkg_path = "%s/%s/%s/%s/%s/%s/%s" % (pulp.server.util.top_package_location(), package.name, package.version, \
# Add a note to indicate this is a Puppet repository
notes[constants.REPO_NOTE_KEY] = constants.REPO_NOTE_RPM
try:
importer_config = args_to_importer_config(kwargs)
yum_distributor_config = args_to_yum_distributor_config(kwargs)
iso_distributor_config = args_to_iso_distributor_config(kwargs)
except InvalidConfig, e:
self.prompt.render_failure_message(str(e))
return
# During create (but not update), if the relative path isn't specified
# it is derived from the feed_url
if 'relative_url' not in yum_distributor_config:
if 'feed_url' in importer_config:
url_parse = urlparse(encode_unicode(importer_config['feed_url']))
if url_parse[2] in ('', '/'):
relative_path = '/' + repo_id
else:
relative_path = url_parse[2]
yum_distributor_config['relative_url'] = relative_path
else:
yum_distributor_config['relative_url'] = repo_id
# Both http and https must be specified in the distributor config, so
# make sure they are initially set here (default to only https)
if 'http' not in yum_distributor_config and 'https' not in yum_distributor_config:
yum_distributor_config['https'] = True
yum_distributor_config['http'] = False
# Make sure both are referenced
def find_scheduled_task(id, method_name):
"""
Look up a schedule task in the task sub-system for a given method
@type id: str
@param id: argument to the task
@rtype: None or L{pulp.server.tasking.task.Task}
@return: the sync task, None if no task is found
"""
# NOTE this is very inefficient in the worst case: DO NOT CALL OFTEN!!
# the number of sync tasks * (mean # arguments + mean # keyword arguments)
for task in async.find_async(method_name=method_name):
if task.args and encode_unicode(id) in task.args or \
task.kwargs and encode_unicode(id) in task.kwargs.values():
return task
return None
@type file_prefix: str
@param cert_dir: absolute path to the location in which the cert bundle should
be written; cannot be None
@type cert_dir: str
@param bundle: cert bundle (see module docs for more information on format)
@type bundle: dict {str, str}
@raises ValueError: if bundle is invalid (see validate_cert_bundle)
@return: mapping of cert bundle item (see module docs) to the absolute path
to where it is stored on disk
'''
file_prefix = encode_unicode(file_prefix)
cert_dir = encode_unicode(cert_dir)
WRITE_LOCK.acquire()
try:
# Create the cert directory if it doesn't exist
if not os.path.exists(cert_dir):
os.makedirs(cert_dir)
# For each item in the cert bundle, save it to disk using the given prefix
# to identify the type of bundle it belongs to. If the value is None, the
# item is being deleted.
cert_files = {}
for key, value in bundle.items():
filename = os.path.join(cert_dir, '%s.%s' % (file_prefix, key))
try:
def _ensure_input_encoding(self, input):
"""
Recursively traverse any input structures and ensure any strings are
encoded as utf-8
@param input: input data
@return: input data with strings encoded as utf-8
"""
if isinstance(input, (list, set, tuple)):
return [self._ensure_input_encoding(i) for i in input]
if isinstance(input, dict):
return dict((self._ensure_input_encoding(k), self._ensure_input_encoding(v)) for k, v in input.items())
try:
return encode_unicode(decode_unicode(input))
except (UnicodeDecodeError, UnicodeEncodeError):
raise InputEncodingError(input), None, sys.exc_info()[2]
for pkg in pkgobjs:
if pkg['id'] not in repo['packages']:
log.debug("Attempted to remove a package<%s> that isn't part of repo[%s]" % (pkg["filename"], repoid))
errors.append(pkg)
continue
repo['packages'].remove(pkg['id'])
repo['package_count'] = repo['package_count'] - 1
if repoid in pkg['repoids']:
del pkg['repoids'][pkg['repoids'].index(repoid)]
pkg_collection.save(pkg, safe=True)
# Remove package from repo location on file system
pkg_repo_path = pulp.server.util.get_repo_package_path(
repo['relative_path'], pkg["filename"])
if os.path.exists(encode_unicode(pkg_repo_path)):
log.debug("Delete package %s at %s" % (pkg["filename"], pkg_repo_path))
os.remove(encode_unicode(pkg_repo_path))
self.collection.save(repo, safe=True)
repo_path = os.path.join(
pulp.server.util.top_repos_location(), repo['relative_path'])
if not os.path.exists(encode_unicode(repo_path)):
pulp.server.util.makedirs(encode_unicode(repo_path))
return errors