def create_repos_conf(self):
self.output.info(" Creating layman's repos.conf file")
if os.path.isdir(self.config['repos_conf']):
msg = ' create_repos_conf() error: %s is a directory and will\n'\
' not be written to.' % self.config['repos_conf']
self.output.error(msg)
return None
conf_dir = os.path.dirname(self.config['repos_conf'])
if not os.path.isdir(conf_dir):
try:
os.mkdir(conf_dir)
except OSError as e:
self.output.error(' create_repos_conf() error creating %s: '\
% conf_dir)
self.output.error(' "%s"' % e)
return None
layman_inst = LaymanAPI(config=self.config)
overlays = {}
for ovl in layman_inst.get_installed():
overlays[ovl] = layman_inst._get_installed_db().select(ovl)
# create layman's %(repos_conf) so layman
# can write the overlays to it.
open(self.config['repos_conf'], 'w').close()
from layman.config_modules.reposconf.reposconf import ConfigHandler
repos_conf = ConfigHandler(self.config, overlays, rebuild=True)
repos_conf.write()
def create_repos_conf(self):
self.output.info(" Creating layman's repos.conf file")
if os.path.isdir(self.config['repos_conf']):
msg = ' create_repos_conf() error: %s is a directory and will\n'\
' not be written to.' % self.config['repos_conf']
self.output.error(msg)
return None
conf_dir = os.path.dirname(self.config['repos_conf'])
if not os.path.isdir(conf_dir):
try:
os.mkdir(conf_dir)
except OSError as e:
self.output.error(' create_repos_conf() error creating %s: '\
% conf_dir)
self.output.error(' "%s"' % e)
return None
layman_inst = LaymanAPI(config=self.config)
overlays = {}
for ovl in layman_inst.get_installed():
overlays[ovl] = layman_inst._get_installed_db().select(ovl)
# create layman's %(repos_conf) so layman
# can write the overlays to it.
open(self.config['repos_conf'], 'w').close()
from layman.config_modules.reposconf.reposconf import ConfigHandler
repos_conf = ConfigHandler(self.config, overlays)
repos_conf.write()
def __init__(self,
stdout=sys.stdout,
stdin=sys.stdin,
stderr=sys.stderr,
config=None,
read_configfile=True,
quiet=False,
quietness=4,
verbose=False,
nocolor=False,
width=0,
root=None):
"""Input parameters are optional to override the defaults.
sets up our LaymanAPI with defaults or passed in values
and returns an instance of it"""
self.message = Message(out=stdout, err=stderr)
self.config = BareConfig(output=self.message,
stdout=stdout,
stdin=stdin,
stderr=stderr,
config=config,
read_configfile=read_configfile,
quiet=quiet,
quietness=quietness,
verbose=verbose,
nocolor=nocolor,
width=width,
root=root)
LaymanAPI.__init__(self,
self.config,
report_errors=True,
output=self.config['output'])
return
def __init__(self, stdout=sys.stdout, stdin=sys.stdin, stderr=sys.stderr,
config=None, read_configfile=True, quiet=False, quietness=4,
verbose=False, nocolor=False, width=0, root=None
):
"""Input parameters are optional to override the defaults.
sets up our LaymanAPI with defaults or passed in values
and returns an instance of it"""
self.message = Message(out=stdout, err=stderr)
self.config = BareConfig(
output=self.message,
stdout=stdout,
stdin=stdin,
stderr=stderr,
config=config,
read_configfile=read_configfile,
quiet=quiet,
quietness=quietness,
verbose=verbose,
nocolor=nocolor,
width=width,
root=root
)
LaymanAPI.__init__(self, self.config,
report_errors=True,
output=self.config['output']
)
return
def __init__(self, config=None):
self.config = config
if self.config:
reload_config(self.config)
self.layman_inst = LaymanAPI(config=self.config)
self.output = self.config.get_option('output')
self.overlay = {}
self.overlays = []
self.overlays_available = self.layman_inst.get_available()
self.supported_types = list(self.layman_inst.supported_types())
def test(self):
tmpdir = tempfile.mkdtemp(prefix='laymantmp_')
cache = os.path.join(tmpdir, 'cache')
my_opts = {
'overlays': ['file://'\
+ HERE + '/testfiles/global-overlays.xml'],
'cache': cache,
'nocheck': 'yes',
'proxy': None,
'quietness': 3
}
config = OptionConfig(my_opts)
api = LaymanAPI(config)
self.assertTrue(api.fetch_remote_list())
filename = api._get_remote_db().filepath(config['overlays']) + '.xml'
with fileopen(filename, 'r') as b:
self.assertEqual(b.readlines()[19], ' A collection of ebuilds from Gunnar Wrobel [[email protected]].\n')
for line in b.readlines():
print(line, end='')
# Check if we get available overlays.
available = api.get_available()
self.assertEqual(available, ['wrobel', 'wrobel-stable'])
# Test the info of an overlay.
all_info = api.get_all_info('wrobel')
test_info = {'status': 'official', 'owner_name': None,
'description': ['Test'], 'src_uris':
['https://overlays.gentoo.org/svn/dev/wrobel'],
'owner_email': '*****@*****.**', 'sources':
[('https://overlays.gentoo.org/svn/dev/wrobel',
'Subversion', None)], 'quality': 'experimental', 'name':
'wrobel', 'supported': True, 'src_types': ['Subversion'],
'official': True, 'priority': 10, 'feeds': [],
'irc': None, 'homepage': None}
info = all_info['wrobel']
info['src_uris'] = [e for e in info['src_uris']]
info['src_types'] = [e for e in info['src_types']]
self.assertEqual(info, test_info)
self.assertEqual(info['status'], 'official')
self.assertEqual(info['description'], ['Test'])
sources = [('https://overlays.gentoo.org/svn/dev/wrobel', 'Subversion',
None)]
self.assertEqual(info['sources'], sources)
os.unlink(filename)
shutil.rmtree(tmpdir)
def create_make_conf(self):
self.output.info(" Creating layman's make.conf file")
layman_inst = LaymanAPI(config=self.config)
overlays = {}
for ovl in layman_inst.get_installed():
overlays[ovl] = layman_inst._get_installed_db().select(ovl)
# create layman's %(storage)s/make.conf
# so portage won't error
from layman.config_modules.makeconf.makeconf import ConfigHandler
maker = ConfigHandler(self.config, overlays)
maker.write()
def create_make_conf(self):
self.output.info(" Creating layman's make.conf file")
layman_inst = LaymanAPI(config=self.config)
overlays = {}
for ovl in layman_inst.get_installed():
overlays[ovl] = layman_inst._get_installed_db().select(ovl)
# create layman's %(storage)s/make.conf
# so portage won't error
from layman.config_modules.makeconf.makeconf import ConfigHandler
maker = ConfigHandler(self.config, overlays)
maker.write()
def create_repos_conf(self):
self.output.info(" Creating layman's repos.conf file")
layman_inst = LaymanAPI(config=self.config)
overlays = {}
for ovl in layman_inst.get_installed():
overlays[ovl] = layman_inst._get_installed_db().select(ovl)
# create layman's %(repos_conf) so layman
# can write the overlays to it.
open(self.config['repos_conf'], 'w').close()
from layman.config_modules.reposconf.reposconf import ConfigHandler
repos_conf = ConfigHandler(self.config, overlays)
repos_conf.write()
def init_layman(config=None):
'''Returns the initialized ``LaymanAPI``.
:param config: the layman's configuration to use (optional)
'''
if config is None: config = BareConfig(read_configfile=True, quietness=1)
return LaymanAPI(config)
def __call__(self):
self.args_parser()
options = None
if self.args.config:
options = {
'config': self.args.config,
}
self.config = OptionConfig(options=options, root=self.root)
# fix the config path
defaults = self.config.get_defaults()
defaults['config'] = defaults['config'] \
% {'configdir': defaults['configdir']}
self.config.update_defaults({'config': defaults['config']})
self.config.read_config(defaults)
layman_inst = LaymanAPI(config=self.config)
self.output = layman_inst.output
if self.args.setup_help:
self.print_instructions()
elif not self.check_is_new(self.args.rebuild):
self.rename_check()
if self.args.migrate_db:
self.migrate_database(self.args.migrate_db)
def test(self):
tmpdir = tempfile.mkdtemp(prefix='laymantmp_')
cache = os.path.join(tmpdir, 'cache')
my_opts = {
'overlays': ['file://'\
+ HERE + '/testfiles/global-overlays.xml'],
'db_type': 'xml',
'cache': cache,
'nocheck': 'yes',
'proxy': None,
'quietness': 3
}
config = OptionConfig(my_opts)
api = LaymanAPI(config)
self.assertTrue(api.fetch_remote_list())
filename = api._get_remote_db().filepath(config['overlays']) + '.xml'
with fileopen(filename, 'r') as b:
description = b.readlines()[19]
self.assertEqual(description, ' A collection of ebuilds from '\
'Gunnar Wrobel [[email protected]].\n')
for line in b.readlines():
print(line, end='')
# Check if we get available overlays.
available = api.get_available()
self.assertEqual(available, ['wrobel', 'wrobel-stable'])
# Test the info of an overlay.
info = api.get_info_str(['wrobel'], verbose=True, local=False)
test_info = 'wrobel\n~~~~~~\nSource : https://overlays.gentoo.org'\
'/svn/dev/wrobel\nContact : [email protected]\nType '\
': Subversion; Priority: 10\nQuality : experimental\n\n'\
'Description:\n Test\n'
info = info['wrobel'][0].decode('utf-8')
self.assertEqual(info, test_info)
os.unlink(filename)
shutil.rmtree(tmpdir)
def __init__(self, config):
self.config = config
self.output = config['output']
self.api = LaymanAPI(config, report_errors=False, output=config.output)
# Given in order of precedence
self.actions = [
('fetch', 'Fetch'),
('add', 'Add'),
('sync', 'Sync'),
('info', 'Info'),
('sync_all', 'Sync'),
('readd', 'Readd'),
('delete', 'Delete'),
('disable', 'Disable'),
('enable', 'Enable'),
('list', 'ListRemote'),
('list_local', 'ListLocal'),
]
def __init__(self, config=None):
self.config = config
if self.config:
reload_config(self.config)
self.layman_inst = LaymanAPI(config=self.config)
self.output = self.config.get_option('output')
self.overlay = {}
self.overlays = []
self.overlays_available = self.layman_inst.get_available()
self.supported_types = list(self.layman_inst.supported_types())
def test(self):
archives = []
try:
from layman.overlays.modules.tar.tar import TarOverlay
archives.append('tar')
from layman.overlays.modules.squashfs.squashfs import SquashfsOverlay
archives.append('squashfs')
except ImportError:
pass
for archive in archives:
xml_text, repo_name, temp_archive_path = getattr(
self, "_create_%(archive)s_overlay" % {'archive': archive})()
(fd, temp_collection_path) = tempfile.mkstemp()
with os.fdopen(fd, 'w') as f:
f.write(xml_text)
# Make playground directory
temp_dir_path = tempfile.mkdtemp()
# Make DB from it
config = BareConfig()
# Necessary for all mountable overlay types
layman_inst = LaymanAPI(config=config)
db = DbBase(config, [temp_collection_path])
specific_overlay_path = os.path.join(temp_dir_path, repo_name)
o = db.select(repo_name)
# Actual testcase
o.add(temp_dir_path)
self.assertTrue(os.path.exists(specific_overlay_path))
# (1/2) Sync with source available
o.sync(temp_dir_path)
self.assertTrue(os.path.exists(specific_overlay_path))
os.unlink(temp_archive_path)
try:
# (2/2) Sync with source _not_ available
o.sync(temp_dir_path)
except:
pass
self.assertTrue(os.path.exists(specific_overlay_path))
o.delete(temp_dir_path)
self.assertFalse(os.path.exists(specific_overlay_path))
# Cleanup
os.unlink(temp_collection_path)
os.rmdir(temp_dir_path)
def __init__(self, config):
self.config = config
self.output = config['output']
self.api = LaymanAPI(config,
report_errors=False,
output=config.output)
# Given in order of precedence
self.actions = [('fetch', 'Fetch'),
('add', 'Add'),
('sync', 'Sync'),
('info', 'Info'),
('sync_all', 'Sync'),
('readd', 'Readd'),
('delete', 'Delete'),
('list', 'ListRemote'),
('list_local', 'ListLocal'),]
def _get_layman_api(self):
'''
Initializes layman api.
@rtype layman.api.LaymanAPI instance
'''
# Make it so that we aren't initializing the
# LaymanAPI instance if it already exists and
# if the current storage location hasn't been
# changed for the new repository.
self.storage = self.repo.location.replace(self.repo.name, '')
if self._layman and self.storage in self.current_storage:
return self._layman
config = BareConfig()
configdir = {'configdir': config.get_option('configdir')}
self.message = Message(out=sys.stdout, err=sys.stderr)
self.current_storage = self.storage
options = {
'config': config.get_option('config') % (configdir),
'quiet': self.settings.get('PORTAGE_QUIET'),
'quietness': config.get_option('quietness'),
'overlay_defs': config.get_option('overlay_defs') % (configdir),
'output': self.message,
'nocolor': self.settings.get('NOCOLOR'),
'root': self.settings.get('EROOT'),
'storage': self.current_storage,
'verbose': self.settings.get('PORTAGE_VERBOSE'),
'width': self.settings.get('COLUMNWIDTH'),
}
self.config = OptionConfig(options=options, root=options['root'])
# Reloads config to read custom overlay
# xml files.
reload_config(self.config)
layman_api = LaymanAPI(self.config,
report_errors=True,
output=self.config['output'])
self._layman = layman_api
return layman_api
def test(self):
tmpdir = tempfile.mkdtemp(prefix='laymantmp_')
cache = os.path.join(tmpdir, 'cache')
my_opts = {
'overlays': ['file://'\
+ HERE + '/testfiles/global-overlays.xml'],
'db_type': 'xml',
'cache': cache,
'nocheck': 'yes',
'proxy': None,
'quietness': 3
}
config = OptionConfig(my_opts)
api = LaymanAPI(config)
self.assertTrue(api.fetch_remote_list())
filename = api._get_remote_db().filepath(config['overlays']) + '.xml'
with fileopen(filename, 'r') as b:
description = b.readlines()[19]
self.assertEqual(description, ' A collection of ebuilds from '\
'Gunnar Wrobel [[email protected]].\n')
for line in b.readlines():
print(line, end='')
# Check if we get available overlays.
available = api.get_available()
self.assertEqual(available, ['wrobel', 'wrobel-stable'])
# Test the info of an overlay.
info = api.get_info_str(['wrobel'], verbose=True, local=False)
test_info = 'wrobel\n~~~~~~\nSource : https://overlays.gentoo.org'\
'/svn/dev/wrobel\nContact : [email protected]\nType '\
': Subversion; Priority: 10\nQuality : experimental\n\n'\
'Description:\n Test\n'
info = info['wrobel'][0].decode('utf-8')
self.assertEqual(info, test_info)
os.unlink(filename)
shutil.rmtree(tmpdir)
class Interactive(object):
def __init__(self, config=None):
self.config = config
if self.config:
reload_config(self.config)
self.layman_inst = LaymanAPI(config=self.config)
self.output = self.config.get_option('output')
self.overlay = {}
self.overlays = []
self.overlays_available = self.layman_inst.get_available()
self.supported_types = list(self.layman_inst.supported_types())
def args_parser(self):
self.parser = argparse.ArgumentParser(prog='layman-overlay-maker',
description='Layman\'s utility script to create overlay'\
'definitions.')
self.parser.add_argument('-l',
'--list-autocomplete',
action='store_true',
help='Lists all available mirrors supported'\
' for information auto-completion'
)
self.parser.add_argument('-n',
'--no-extra',
action='store_true',
help='Don\'t add any extra overlay info,'\
' just the bare minimum requirements')
self.parser.add_argument('-s',
'--set-autocomplete',
nargs='+',
help='Enables auto-completion support for'\
' the selected mirror. Specify "ALL" to'\
' enable support for all available mirrors')
self.parser.add_argument('-S',
'--sudo',
action='store_true',
help='Bypass checks to see if an overlay'\
' name being inputted is already being used'\
' and choose the installation dir for the'\
' XML')
self.parser.add_argument('-V',
'--version',
action='version',
version='%(prog)s ' + VERSION)
self.args = self.parser.parse_args()
def __call__(self, overlay_package=None, path=None):
if not overlay_package:
self.args_parser()
options = {}
for key in vars(self.args):
options[key] = vars(self.args)[key]
self.config = OptionConfig(options=options)
reload_config(self.config)
self.auto_complete = False
self.list_info = self.config.get_option('list_autocomplete')
self.no_extra = self.config.get_option('no_extra')
self.sudo = self.config.get_option('sudo')
if self.list_info:
self.list_templates()
if self.args.set_autocomplete:
if 'ALL' in self.args.set_autocomplete:
self.templates = AUTOCOMPLETE_TEMPLATE.keys()
self.auto_complete = True
else:
self.templates = self.args.set_autocomplete
self.auto_complete = True
msg = 'How many overlays would you like to create?: '
for x in range(1, int(get_input(msg))+1):
self.output.notice('')
self.output.info('Overlay #%(x)s: ' % ({'x': str(x)}))
self.output.info('~~~~~~~~~~~~~')
self.required = copy.deepcopy(COMPONENT_DEFAULTS)
if not self.no_extra:
self.output.notice('')
self.update_required()
self.output.notice('')
self.get_overlay_components()
ovl = Overlay.Overlay(config=self.config, ovl_dict=self.overlay, ignore=1)
self.overlays.append((self.overlay['name'], ovl))
else:
ovl_name, ovl = overlay_package
self.overlays.append((ovl_name, ovl))
result = self.write(path)
return result
def check_overlay_type(self, ovl_type):
'''
Validates overlay type.
@params ovl_type: str of overlay type
@rtype None or str (if overlay type is valid).
'''
if ovl_type.lower() in self.supported_types:
return ovl_type.lower()
msg = '!!! Specified type "%(type)s" not valid.' % ({'type': ovl_type})
self.output.warn(msg)
msg = 'Supported types include: %(types)s.'\
% ({'types': ', '.join(self.supported_types)})
self.output.warn(msg)
return None
def guess_overlay_type(self, source_uri):
'''
Guesses the overlay type based on the source given.
@params source-uri: str of source.
@rtype None or str (if overlay type was guessed correctly).
'''
type_checks = copy.deepcopy(self.supported_types)
#Modify the type checks for special overlay types.
if 'tar' in type_checks:
type_checks.remove(type_checks[type_checks.index('tar')])
type_checks.insert(len(type_checks), '.tar')
if 'bzr' in type_checks:
type_checks.remove(self.supported_types[type_checks.index('bzr')])
type_checks.insert(len(type_checks), 'bazaar')
for guess in type_checks:
if guess in source_uri:
return guess
if 'bitbucket.org' in source_uri:
return 'mercurial'
return None
def update_required(self):
'''
Prompts user for optional components and updates
the required components accordingly.
'''
for possible in POSSIBLE_COMPONENTS:
if possible not in self.required:
msg = 'Include %(comp)s for this overlay? [y/n]: '\
% ({'comp': possible})
if ((possible in 'homepage' or possible in 'feed') and
self.auto_complete):
available = False
else:
available = get_ans(msg)
if available:
self.required.append(possible)
def get_description(self):
'''
Prompts user for an overlay's description(s)
and updates overlay dict with value(s).
'''
#TODO: Currently a "stub" function. Add multiple description
# field support later down the road.
descriptions = []
desc = get_input('Define overlay\'s description: ')
descriptions.append(desc)
self.overlay['description'] = descriptions
def get_feed(self):
'''
Prompts user for any overlay RSS feeds
and updates overlay dict with values.
'''
msg = 'How many RSS feeds exist for this overlay?: '
feed_amount = int(get_input(msg))
feeds = []
for i in range(1, feed_amount + 1):
extra = ''
if feed_amount > 1:
extra = '[%(i)s]' % {'i': str(i)}
feeds.append(get_input('Define overlay%(extra)s feed: '\
% {'extra': extra}))
self.overlay['feed'] = feeds
self.output.notice('')
def get_name(self):
'''
Prompts user for the overlay name
and updates the overlay dict.
'''
name = get_input('Define overlay name: ')
if not self.sudo:
while name in self.overlays_available:
msg = '!!! Overlay name already defined in list of installed'\
' overlays.'
self.output.warn(msg)
msg = 'Please specify a different overlay name: '
name = get_input(msg, color='yellow')
self.overlay['name'] = name
def get_source(self):
'''
Prompts user for possible overlay source
information such as type, url, and branch
and then appends the values to the overlay
being created.
'''
ovl_type = None
if self.auto_complete:
source_amount = 1
else:
msg = 'How many different sources, protocols, or mirrors exist '\
'for this overlay?: '
source_amount = int(get_input(msg))
self.overlay['source'] = []
for i in range(1, source_amount + 1):
sources = []
correct = False
extra = ''
if source_amount > 1:
extra = '[%(i)s]\'s' % {'i': str(i)}
msg = 'Define source%(extra)s URL: ' % {'extra': extra}
sources.append(get_input(msg))
ovl_type = self.guess_overlay_type(sources[0])
if ovl_type:
msg = 'Is "%(type)s" the correct overlay type?: '\
% ({'type': ovl_type})
correct = get_ans(msg)
while not ovl_type or not correct:
msg = 'Please provide overlay type: '
ovl_type = self.check_overlay_type(\
get_input(msg, color='yellow'))
correct = True
sources.append(ovl_type)
if 'branch' in self.required:
msg = 'Define source%(extra)s branch (if applicable): '\
% {'extra': extra}
sources.append(get_input(msg))
else:
sources.append('')
if self.auto_complete:
sources = self._set_additional_info(sources)
for source in sources:
self.overlay['source'].append(source)
else:
self.overlay['source'].append(sources)
self.output.notice('')
def get_owner(self):
'''
Prompts user for overlay owner info and
then appends the values to the overlay
being created.
'''
self.overlay['owner'] = []
self.output.notice('')
msg = 'How many people own this overlay?: '
owner_amount = int(get_input(msg))
for i in range(1, owner_amount + 1):
owner = {}
extra = ''
if owner_amount > 1:
extra = '[%(i)s]\'s' % {'i': str(i)}
owner['name'] = get_input('Define owner%(extra)s name: '\
% {'extra': extra})
owner['email'] = get_input('Define owner%(extra)s email: '\
% {'extra': extra})
self.overlay['owner'].append(owner)
self.output.notice('')
def get_component(self, component, msg):
'''
Sets overlay component value.
@params component: (str) component to be set
@params msg: (str) prompt message for component
'''
if component not in ('branch', 'type'):
if component in ('description', 'feed', 'name', 'owner', 'source'):
getattr(self, 'get_%(comp)s' % ({'comp': component}))()
else:
self.overlay[component] = get_input(msg)
def get_overlay_components(self):
'''
Acquires overlay components via user interface.
'''
self.overlay = {}
for component in self.required:
self.get_component(component, 'Define %(comp)s: '\
% ({'comp': component}))
def list_templates(self):
'''
Lists all available mirrors that support information auto-completion
and exits.
'''
self.output.info('Mirrors supported for information auto-completion: ')
self.output.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
for i in sorted(AUTOCOMPLETE_TEMPLATE):
self.output.info(i)
sys.exit()
def read(self, path):
'''
Reads overlay.xml files and appends the contents
to be sorted when writing to the file.
@params path: path to file to be read
'''
try:
document = ET.parse(path)
except ET.ParseError as error:
msg = 'Interactive.read(); encountered error: %(error)s'\
% ({'error': error})
raise Exception(msg)
overlays = document.findall('overlay') + document.findall('repo')
for overlay in overlays:
ovl_name = overlay.find('name')
ovl = Overlay.Overlay(config=self.config, xml=overlay, ignore=1)
self.overlays.append((ovl_name.text, ovl))
def _set_additional_info(self, source):
'''
Sets additional possible overlay information.
@params source: list of the source URL, type, and branch.
'''
feeds = []
sources = []
url = self._split_source_url(source[0])
attrs = {'branch': source[2], 'tail': '/'.join(url[3:])}
mirror = url[2].split('.')
for i in self.templates:
if i in mirror:
if i not in ('gentoo'):
attrs['info'] = attrs['tail'].replace('.git', '')
if attrs['branch']:
try:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i+'-branch']
except KeyError:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i]
else:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i]
self.overlay['homepage'] = TEMPLATE['homepage'] % attrs
if i in ('bitbucket') and 'git' in (source[1]):
return [source]
for s in TEMPLATE['source']:
source = (s[0] % attrs, s[1], s[2] % attrs)
sources.append(source)
for f in TEMPLATE['feed']:
feed = (f % attrs)
feeds.append(feed)
self.overlay['feed'] = feeds
if sources:
return sources
return [source]
def _split_source_url(self, source_url):
'''
Splits the given source URL based on
the source URL type.
@params source_url: str, represents the URL for the repo.
@rtype str: The newly split url components.
'''
url = None
if re.search("^(git://)|(http://)|(https://)|(ssh://)", source_url):
url = source_url.split('/')
if re.search('^git\+ssh://', source_url):
url = source_url.replace('+ssh', '')
url = url.replace('git@', '').split('/')
if re.search('^git@', source_url):
url = source_url.replace('@', '//')
url = url.replace(':', '/')
url = url.replace('//', '://').split('/')
if url:
return url
raise Exception('Interactive._split_source_url(); error: Unable '\
'to split URL.')
def _sort_to_tree(self):
'''
Sorts all Overlay objects by overlay name
and converts the sorted overlay objects to
XML that is then appended to the tree.
'''
self.overlays = sorted(self.overlays)
for overlay in self.overlays:
self.tree.append(overlay[1].to_xml())
def write(self, destination):
'''
Writes overlay file to desired location.
@params destination: path & file to write xml to.
@rtype bool: reflects success or failure to write xml.
'''
if not destination:
filepath = self.config.get_option('overlay_defs')
if self.sudo:
filepath = get_input('Desired file destination dir: ')
filename = get_input('Desired overlay file name: ')
if not filename.endswith('.xml'):
filename += ".xml"
if not filepath.endswith(os.path.sep):
filepath += os.path.sep
destination = filepath + filename
self.tree = ET.Element('repositories', version='1.1', encoding=_UNICODE)
if os.path.isfile(destination):
self.read(destination)
self._sort_to_tree()
indent(self.tree)
self.tree = ET.ElementTree(self.tree)
try:
with fileopen(destination, 'w') as xml:
self.tree.write(xml, encoding=_UNICODE)
msg = 'Successfully wrote repo(s) to: %(path)s'\
% ({'path': destination})
self.output.info(msg)
return True
except IOError as e:
raise Exception("Writing XML failed: %(error)s" % ({'error': e}))
class Interactive(object):
def __init__(self, config=None):
self.config = config
if self.config:
reload_config(self.config)
self.layman_inst = LaymanAPI(config=self.config)
self.output = self.config.get_option("output")
self.overlay = {}
self.overlays = []
self.overlays_available = self.layman_inst.get_available()
self.supported_types = list(self.layman_inst.supported_types())
def args_parser(self):
self.parser = argparse.ArgumentParser(
prog="layman-overlay-maker", description="Layman's utility script to create overlay" "definitions."
)
self.parser.add_argument(
"-l",
"--list-autocomplete",
action="store_true",
help="Lists all available mirrors supported" " for information auto-completion",
)
self.parser.add_argument(
"-n",
"--no-extra",
action="store_true",
help="Don't add any extra overlay info," " just the bare minimum requirements",
)
self.parser.add_argument(
"-s",
"--set-autocomplete",
nargs="+",
help="Enables auto-completion support for"
' the selected mirror. Specify "ALL" to'
" enable support for all available mirrors",
)
self.parser.add_argument(
"-S",
"--sudo",
action="store_true",
help="Bypass checks to see if an overlay"
" name being inputted is already being used"
" and choose the installation dir for the"
" XML",
)
self.parser.add_argument("-V", "--version", action="version", version="%(prog)s " + VERSION)
self.args = self.parser.parse_args()
def __call__(self, overlay_package=None, path=None):
if not overlay_package:
self.args_parser()
options = {}
for key in vars(self.args):
options[key] = vars(self.args)[key]
self.config = OptionConfig(options=options)
reload_config(self.config)
self.auto_complete = False
self.list_info = self.config.get_option("list_autocomplete")
self.no_extra = self.config.get_option("no_extra")
self.sudo = self.config.get_option("sudo")
if self.list_info:
self.list_templates()
if self.args.set_autocomplete:
if "ALL" in self.args.set_autocomplete:
self.templates = AUTOCOMPLETE_TEMPLATE.keys()
self.auto_complete = True
else:
self.templates = self.args.set_autocomplete
self.auto_complete = True
msg = "How many overlays would you like to create?: "
for x in range(1, int(get_input(msg)) + 1):
self.output.notice("")
self.output.info("Overlay #%(x)s: " % ({"x": str(x)}))
self.output.info("~~~~~~~~~~~~~")
self.required = copy.deepcopy(COMPONENT_DEFAULTS)
if not self.no_extra:
self.output.notice("")
self.update_required()
self.output.notice("")
self.get_overlay_components()
ovl = Overlay.Overlay(config=self.config, ovl_dict=self.overlay, ignore=1)
self.overlays.append((self.overlay["name"], ovl))
else:
ovl_name, ovl = overlay_package
self.overlays.append((ovl_name, ovl))
result = self.write(path)
return result
def check_overlay_type(self, ovl_type):
"""
Validates overlay type.
@params ovl_type: str of overlay type
@rtype None or str (if overlay type is valid).
"""
if ovl_type.lower() in self.supported_types:
return ovl_type.lower()
msg = '!!! Specified type "%(type)s" not valid.' % ({"type": ovl_type})
self.output.warn(msg)
msg = "Supported types include: %(types)s." % ({"types": ", ".join(self.supported_types)})
self.output.warn(msg)
return None
def guess_overlay_type(self, source_uri):
"""
Guesses the overlay type based on the source given.
@params source-uri: str of source.
@rtype None or str (if overlay type was guessed correctly).
"""
type_checks = copy.deepcopy(self.supported_types)
# Modify the type checks for special overlay types.
if "tar" in type_checks:
type_checks.remove(type_checks[type_checks.index("tar")])
type_checks.insert(len(type_checks), ".tar")
if "bzr" in type_checks:
type_checks.remove(self.supported_types[type_checks.index("bzr")])
type_checks.insert(len(type_checks), "bazaar")
for guess in type_checks:
if guess in source_uri:
return guess
if "bitbucket.org" in source_uri:
return "mercurial"
return None
def update_required(self):
"""
Prompts user for optional components and updates
the required components accordingly.
"""
for possible in POSSIBLE_COMPONENTS:
if possible not in self.required:
msg = "Include %(comp)s for this overlay? [y/n]: " % ({"comp": possible})
if (possible in "homepage" or possible in "feed") and self.auto_complete:
available = False
else:
available = get_ans(msg)
if available:
self.required.append(possible)
def get_description(self):
"""
Prompts user for an overlay's description(s)
and updates overlay dict with value(s).
"""
# TODO: Currently a "stub" function. Add multiple description
# field support later down the road.
descriptions = []
desc = get_input("Define overlay's description: ")
descriptions.append(desc)
self.overlay["description"] = descriptions
def get_feed(self):
"""
Prompts user for any overlay RSS feeds
and updates overlay dict with values.
"""
msg = "How many RSS feeds exist for this overlay?: "
feed_amount = int(get_input(msg))
feeds = []
for i in range(1, feed_amount + 1):
if feed_amount > 1:
msg = "Define overlay feed[%(i)s]: " % ({"i": str(i)})
feeds.append(get_input(msg))
else:
feeds.append(get_input("Define overlay feed: "))
self.overlay["feed"] = feeds
self.output.notice("")
def get_name(self):
"""
Prompts user for the overlay name
and updates the overlay dict.
"""
name = get_input("Define overlay name: ")
if not self.sudo:
while name in self.overlays_available:
msg = "!!! Overlay name already defined in list of installed" " overlays."
self.output.warn(msg)
msg = "Please specify a different overlay name: "
name = get_input(msg, color="yellow")
self.overlay["name"] = name
def get_source(self):
"""
Prompts user for possible overlay source
information such as type, url, and branch
and then appends the values to the overlay
being created.
"""
ovl_type = None
if self.auto_complete:
source_amount = 1
else:
msg = "How many different sources, protocols, or mirrors exist " "for this overlay?: "
source_amount = int(get_input(msg))
self.overlay["source"] = []
for i in range(1, source_amount + 1):
sources = []
correct = False
if source_amount > 1:
msg = "Define source[%(i)s]'s URL: " % ({"i": str(i)})
sources.append(get_input(msg))
ovl_type = self.guess_overlay_type(sources[0])
if ovl_type:
msg = 'Is "%(type)s" the correct overlay type?: ' % ({"type": ovl_type})
correct = get_ans(msg)
while not ovl_type or not correct:
msg = "Please provide overlay type: "
ovl_type = self.check_overlay_type(get_input(msg, color="yellow"))
correct = True
sources.append(ovl_type)
if "branch" in self.required:
msg = "Define source[%(i)s]'s branch (if applicable): " % ({"i": str(i)})
sources.append(get_input(msg))
else:
sources.append("")
else:
sources.append(get_input("Define source URL: "))
ovl_type = self.guess_overlay_type(sources[0])
if ovl_type:
msg = "Is %(type)s the correct overlay type?: " % ({"type": ovl_type})
correct = get_ans(msg)
while not ovl_type or not correct:
msg = "Please provide overlay type: "
ovl_type = self.check_overlay_type(get_input(msg, color="yellow"))
correct = True
sources.append(ovl_type)
if "branch" in self.required:
msg = "Define source branch (if applicable): "
sources.append(get_input(msg))
else:
sources.append("")
if self.auto_complete:
sources = self._set_additional_info(sources)
for source in sources:
self.overlay["source"].append(source)
else:
self.overlay["source"].append(sources)
self.output.notice("")
def get_owner(self):
"""
Prompts user for overlay owner info and
then appends the values to the overlay
being created.
"""
self.output.notice("")
self.overlay["owner_name"] = get_input("Define owner name: ")
self.overlay["owner_email"] = get_input("Define owner email: ")
self.output.notice("")
def get_component(self, component, msg):
"""
Sets overlay component value.
@params component: (str) component to be set
@params msg: (str) prompt message for component
"""
if component not in ("branch", "type"):
if component in ("description", "feed", "name", "owner", "source"):
getattr(self, "get_%(comp)s" % ({"comp": component}))()
else:
self.overlay[component] = get_input(msg)
def get_overlay_components(self):
"""
Acquires overlay components via user interface.
"""
self.overlay = {}
for component in self.required:
self.get_component(component, "Define %(comp)s: " % ({"comp": component}))
def list_templates(self):
"""
Lists all available mirrors that support information auto-completion
and exits.
"""
self.output.info("Mirrors supported for information auto-completion: ")
self.output.info("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
for i in sorted(AUTOCOMPLETE_TEMPLATE):
self.output.info(i)
sys.exit()
def read(self, path):
"""
Reads overlay.xml files and appends the contents
to be sorted when writing to the file.
@params path: path to file to be read
"""
try:
document = ET.parse(path)
except ET.ParseError as error:
msg = "Interactive.read(); encountered error: %(error)s" % ({"error": error})
raise Exception(msg)
overlays = document.findall("overlay") + document.findall("repo")
for overlay in overlays:
ovl_name = overlay.find("name")
ovl = Overlay.Overlay(config=self.config, xml=overlay, ignore=1)
self.overlays.append((ovl_name.text, ovl))
def _set_additional_info(self, source):
"""
Sets additional possible overlay information.
@params source: list of the source URL, type, and branch.
"""
feeds = []
sources = []
url = self._split_source_url(source[0])
attrs = {"branch": source[2], "tail": "/".join(url[3:])}
mirror = url[2].split(".")
for i in self.templates:
if i in mirror:
if i not in ("gentoo"):
attrs["info"] = attrs["tail"].replace(".git", "")
if attrs["branch"]:
try:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i + "-branch"]
except KeyError:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i]
else:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i]
self.overlay["homepage"] = TEMPLATE["homepage"] % attrs
if i in ("bitbucket") and "git" in (source[1]):
return [source]
for s in TEMPLATE["source"]:
source = (s[0] % attrs, s[1], s[2] % attrs)
sources.append(source)
for f in TEMPLATE["feed"]:
feed = f % attrs
feeds.append(feed)
self.overlay["feed"] = feeds
if sources:
return sources
return [source]
def _split_source_url(self, source_url):
"""
Splits the given source URL based on
the source URL type.
@params source_url: str, represents the URL for the repo.
@rtype str: The newly split url components.
"""
url = None
if re.search("^(git://)|(http://)|(https://)|(ssh://)", source_url):
url = source_url.split("/")
if re.search("^git\+ssh://", source_url):
url = source_url.replace("+ssh", "")
url = url.replace("git@", "").split("/")
if re.search("^git@", source_url):
url = source_url.replace("@", "//")
url = url.replace(":", "/")
url = url.replace("//", "://").split("/")
if url:
return url
raise Exception("Interactive._split_source_url(); error: Unable " "to split URL.")
def _sort_to_tree(self):
"""
Sorts all Overlay objects by overlay name
and converts the sorted overlay objects to
XML that is then appended to the tree.
"""
self.overlays = sorted(self.overlays)
for overlay in self.overlays:
self.tree.append(overlay[1].to_xml())
def write(self, destination):
"""
Writes overlay file to desired location.
@params destination: path & file to write xml to.
@rtype bool: reflects success or failure to write xml.
"""
if not destination:
filepath = self.config.get_option("overlay_defs")
if self.sudo:
filepath = get_input("Desired file destination dir: ")
filename = get_input("Desired overlay file name: ")
if not filename.endswith(".xml"):
filename += ".xml"
if not filepath.endswith(os.path.sep):
filepath += os.path.sep
destination = filepath + filename
self.tree = ET.Element("repositories", version="1.1", encoding=_UNICODE)
if os.path.isfile(destination):
self.read(destination)
self._sort_to_tree()
indent(self.tree)
self.tree = ET.ElementTree(self.tree)
try:
with fileopen(destination, "w") as xml:
self.tree.write(xml, encoding=_UNICODE)
msg = "Successfully wrote repo(s) to: %(path)s" % ({"path": destination})
self.output.info(msg)
return True
except IOError as e:
raise Exception("Writing XML failed: %(error)s" % ({"error": e}))
class Interactive(object):
def __init__(self, config=None):
self.config = config
if self.config:
reload_config(self.config)
self.layman_inst = LaymanAPI(config=self.config)
self.output = self.config.get_option('output')
self.overlay = {}
self.overlays = []
self.overlays_available = self.layman_inst.get_available()
self.supported_types = list(self.layman_inst.supported_types())
def args_parser(self):
self.parser = argparse.ArgumentParser(prog='layman-overlay-maker',
description='Layman\'s utility script to create overlay'\
'definitions.')
self.parser.add_argument('-l',
'--list-autocomplete',
action='store_true',
help='Lists all available mirrors supported'\
' for information auto-completion'
)
self.parser.add_argument('-n',
'--no-extra',
action='store_true',
help='Don\'t add any extra overlay info,'\
' just the bare minimum requirements')
self.parser.add_argument('-s',
'--set-autocomplete',
nargs='+',
help='Enables auto-completion support for'\
' the selected mirror. Specify "ALL" to'\
' enable support for all available mirrors')
self.parser.add_argument('-S',
'--sudo',
action='store_true',
help='Bypass checks to see if an overlay'\
' name being inputted is already being used'\
' and choose the installation dir for the'\
' XML')
self.parser.add_argument('-V',
'--version',
action='version',
version='%(prog)s ' + VERSION)
self.args = self.parser.parse_args()
def __call__(self, overlay_package=None, path=None):
if not overlay_package:
self.args_parser()
options = {}
for key in vars(self.args):
options[key] = vars(self.args)[key]
self.config = OptionConfig(options=options)
reload_config(self.config)
self.auto_complete = False
self.list_info = self.config.get_option('list_autocomplete')
self.no_extra = self.config.get_option('no_extra')
self.sudo = self.config.get_option('sudo')
if self.list_info:
self.list_templates()
if self.args.set_autocomplete:
if 'ALL' in self.args.set_autocomplete:
self.templates = AUTOCOMPLETE_TEMPLATE.keys()
self.auto_complete = True
else:
self.templates = self.args.set_autocomplete
self.auto_complete = True
msg = 'How many overlays would you like to create?: '
for x in range(1, int(get_input(msg)) + 1):
self.output.notice('')
self.output.info('Overlay #%(x)s: ' % ({'x': str(x)}))
self.output.info('~~~~~~~~~~~~~')
self.required = copy.deepcopy(COMPONENT_DEFAULTS)
if not self.no_extra:
self.output.notice('')
self.update_required()
self.output.notice('')
self.get_overlay_components()
ovl = Overlay.Overlay(config=self.config,
ovl_dict=self.overlay,
ignore=1)
self.overlays.append((self.overlay['name'], ovl))
else:
ovl_name, ovl = overlay_package
self.overlays.append((ovl_name, ovl))
result = self.write(path)
return result
def check_overlay_type(self, ovl_type):
'''
Validates overlay type.
@params ovl_type: str of overlay type
@rtype None or str (if overlay type is valid).
'''
if ovl_type.lower() in self.supported_types:
return ovl_type.lower()
msg = '!!! Specified type "%(type)s" not valid.' % ({'type': ovl_type})
self.output.warn(msg)
msg = 'Supported types include: %(types)s.'\
% ({'types': ', '.join(self.supported_types)})
self.output.warn(msg)
return None
def guess_overlay_type(self, source_uri):
'''
Guesses the overlay type based on the source given.
@params source-uri: str of source.
@rtype None or str (if overlay type was guessed correctly).
'''
type_checks = copy.deepcopy(self.supported_types)
#Modify the type checks for special overlay types.
if 'tar' in type_checks:
type_checks.remove(type_checks[type_checks.index('tar')])
type_checks.insert(len(type_checks), '.tar')
if 'bzr' in type_checks:
type_checks.remove(self.supported_types[type_checks.index('bzr')])
type_checks.insert(len(type_checks), 'bazaar')
for guess in type_checks:
if guess in source_uri:
return guess
if 'bitbucket.org' in source_uri:
return 'mercurial'
return None
def update_required(self):
'''
Prompts user for optional components and updates
the required components accordingly.
'''
for possible in POSSIBLE_COMPONENTS:
if possible not in self.required:
msg = 'Include %(comp)s for this overlay? [y/n]: '\
% ({'comp': possible})
if ((possible in 'homepage' or possible in 'feed')
and self.auto_complete):
available = False
else:
available = get_ans(msg)
if available:
self.required.append(possible)
def get_description(self):
'''
Prompts user for an overlay's description(s)
and updates overlay dict with value(s).
'''
#TODO: Currently a "stub" function. Add multiple description
# field support later down the road.
descriptions = []
desc = get_input('Define overlay\'s description: ')
descriptions.append(desc)
self.overlay['description'] = descriptions
def get_feed(self):
'''
Prompts user for any overlay RSS feeds
and updates overlay dict with values.
'''
msg = 'How many RSS feeds exist for this overlay?: '
feed_amount = int(get_input(msg))
feeds = []
for i in range(1, feed_amount + 1):
extra = ''
if feed_amount > 1:
extra = '[%(i)s]' % {'i': str(i)}
feeds.append(get_input('Define overlay%(extra)s feed: '\
% {'extra': extra}))
self.overlay['feed'] = feeds
self.output.notice('')
def get_name(self):
'''
Prompts user for the overlay name
and updates the overlay dict.
'''
name = get_input('Define overlay name: ')
if not self.sudo:
while name in self.overlays_available:
msg = '!!! Overlay name already defined in list of installed'\
' overlays.'
self.output.warn(msg)
msg = 'Please specify a different overlay name: '
name = get_input(msg, color='yellow')
self.overlay['name'] = name
def get_source(self):
'''
Prompts user for possible overlay source
information such as type, url, and branch
and then appends the values to the overlay
being created.
'''
ovl_type = None
if self.auto_complete:
source_amount = 1
else:
msg = 'How many different sources, protocols, or mirrors exist '\
'for this overlay?: '
source_amount = int(get_input(msg))
self.overlay['source'] = []
for i in range(1, source_amount + 1):
sources = []
correct = False
extra = ''
if source_amount > 1:
extra = '[%(i)s]\'s' % {'i': str(i)}
msg = 'Define source%(extra)s URL: ' % {'extra': extra}
sources.append(get_input(msg))
ovl_type = self.guess_overlay_type(sources[0])
if ovl_type:
msg = 'Is "%(type)s" the correct overlay type?: '\
% ({'type': ovl_type})
correct = get_ans(msg)
while not ovl_type or not correct:
msg = 'Please provide overlay type: '
ovl_type = self.check_overlay_type(\
get_input(msg, color='yellow'))
correct = True
sources.append(ovl_type)
if 'branch' in self.required:
msg = 'Define source%(extra)s branch (if applicable): '\
% {'extra': extra}
sources.append(get_input(msg))
else:
sources.append('')
if self.auto_complete:
sources = self._set_additional_info(sources)
for source in sources:
self.overlay['source'].append(source)
else:
self.overlay['source'].append(sources)
self.output.notice('')
def get_owner(self):
'''
Prompts user for overlay owner info and
then appends the values to the overlay
being created.
'''
self.overlay['owner'] = []
self.output.notice('')
msg = 'How many people own this overlay?: '
owner_amount = int(get_input(msg))
for i in range(1, owner_amount + 1):
owner = {}
extra = ''
if owner_amount > 1:
extra = '[%(i)s]\'s' % {'i': str(i)}
owner['name'] = get_input('Define owner%(extra)s name: '\
% {'extra': extra})
owner['email'] = get_input('Define owner%(extra)s email: '\
% {'extra': extra})
self.overlay['owner'].append(owner)
self.output.notice('')
def get_component(self, component, msg):
'''
Sets overlay component value.
@params component: (str) component to be set
@params msg: (str) prompt message for component
'''
if component not in ('branch', 'type'):
if component in ('description', 'feed', 'name', 'owner', 'source'):
getattr(self, 'get_%(comp)s' % ({'comp': component}))()
else:
self.overlay[component] = get_input(msg)
def get_overlay_components(self):
'''
Acquires overlay components via user interface.
'''
self.overlay = {}
for component in self.required:
self.get_component(component, 'Define %(comp)s: '\
% ({'comp': component}))
def list_templates(self):
'''
Lists all available mirrors that support information auto-completion
and exits.
'''
self.output.info('Mirrors supported for information auto-completion: ')
self.output.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
for i in sorted(AUTOCOMPLETE_TEMPLATE):
self.output.info(i)
sys.exit()
def read(self, path):
'''
Reads overlay.xml files and appends the contents
to be sorted when writing to the file.
@params path: path to file to be read
'''
try:
document = ET.parse(path)
except ET.ParseError as error:
msg = 'Interactive.read(); encountered error: %(error)s'\
% ({'error': error})
raise Exception(msg)
overlays = document.findall('overlay') + document.findall('repo')
for overlay in overlays:
ovl_name = overlay.find('name')
ovl = Overlay.Overlay(config=self.config, xml=overlay, ignore=1)
self.overlays.append((ovl_name.text, ovl))
def _set_additional_info(self, source):
'''
Sets additional possible overlay information.
@params source: list of the source URL, type, and branch.
'''
feeds = []
sources = []
url = self._split_source_url(source[0])
attrs = {'branch': source[2], 'tail': '/'.join(url[3:])}
mirror = url[2].split('.')
for i in self.templates:
if i in mirror:
if i not in ('gentoo'):
attrs['info'] = attrs['tail'].replace('.git', '')
if attrs['branch']:
try:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i + '-branch']
except KeyError:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i]
else:
TEMPLATE = AUTOCOMPLETE_TEMPLATE[i]
self.overlay['homepage'] = TEMPLATE['homepage'] % attrs
if i in ('bitbucket') and 'git' in (source[1]):
return [source]
for s in TEMPLATE['source']:
source = (s[0] % attrs, s[1], s[2] % attrs)
sources.append(source)
for f in TEMPLATE['feed']:
feed = (f % attrs)
feeds.append(feed)
self.overlay['feed'] = feeds
if sources:
return sources
return [source]
def _split_source_url(self, source_url):
'''
Splits the given source URL based on
the source URL type.
@params source_url: str, represents the URL for the repo.
@rtype str: The newly split url components.
'''
url = None
if re.search("^(git://)|(http://)|(https://)|(ssh://)", source_url):
url = source_url.split('/')
if re.search('^git\+ssh://', source_url):
url = source_url.replace('+ssh', '')
url = url.replace('git@', '').split('/')
if re.search('^git@', source_url):
url = source_url.replace('@', '//')
url = url.replace(':', '/')
url = url.replace('//', '://').split('/')
if url:
return url
raise Exception('Interactive._split_source_url(); error: Unable '\
'to split URL.')
def _sort_to_tree(self):
'''
Sorts all Overlay objects by overlay name
and converts the sorted overlay objects to
XML that is then appended to the tree.
'''
self.overlays = sorted(self.overlays)
for overlay in self.overlays:
self.tree.append(overlay[1].to_xml())
def write(self, destination):
'''
Writes overlay file to desired location.
@params destination: path & file to write xml to.
@rtype bool: reflects success or failure to write xml.
'''
if not destination:
filepath = self.config.get_option('overlay_defs')
if self.sudo:
filepath = get_input('Desired file destination dir: ')
filename = get_input('Desired overlay file name: ')
if not filename.endswith('.xml'):
filename += ".xml"
if not filepath.endswith(os.path.sep):
filepath += os.path.sep
destination = filepath + filename
self.tree = ET.Element('repositories',
version='1.1',
encoding=_UNICODE)
if os.path.isfile(destination):
self.read(destination)
self._sort_to_tree()
indent(self.tree)
self.tree = ET.ElementTree(self.tree)
try:
with fileopen(destination, 'w') as xml:
self.tree.write(xml, encoding=_UNICODE)
msg = 'Successfully wrote repo(s) to: %(path)s'\
% ({'path': destination})
self.output.info(msg)
return True
except IOError as e:
raise Exception("Writing XML failed: %(error)s" % ({'error': e}))
class Main(object):
'''Performs the actions the user selected.
'''
def __init__(self, config):
self.config = config
self.output = config['output']
self.api = LaymanAPI(config,
report_errors=False,
output=config.output)
# Given in order of precedence
self.actions = [('fetch', 'Fetch'),
('add', 'Add'),
('sync', 'Sync'),
('info', 'Info'),
('sync_all', 'Sync'),
('readd', 'Readd'),
('delete', 'Delete'),
('disable', 'Disable'),
('enable', 'Enable'),
('list', 'ListRemote'),
('list_local', 'ListLocal'),]
def __call__(self):
self.output.debug("CLI.__call__(): self.config.keys()"
" %s" % str(self.config.keys()), 6)
# blank newline -- no " *"
self.output.notice('')
# check for and handle setup-help option
if self.config.get_option('setup_help'):
from layman.updater import Main as Updater
updater = Updater(config=self.config, output=self.output)
updater.print_instructions()
# Make fetching the overlay list a default action
if not 'nofetch' in self.config.keys():
# Actions that implicitly call the fetch operation before
fetch_actions = ['sync', 'sync_all', 'list']
for i in fetch_actions:
if i in self.config.keys():
# Implicitely call fetch, break loop
self.Fetch()
break
result = 0
# Set the umask
umask = self.config['umask']
try:
new_umask = int(umask, 8)
old_umask = os.umask(new_umask)
except Exception as error:
self.output.die('Failed setting to umask "' + umask +
'"!\nError was: ' + str(error))
action_errors = []
results = []
act=set([x[0] for x in self.actions])
k=set([x for x in self.config.keys()])
a=act.intersection(k)
self.output.debug('Actions = %s' % str(a), 4)
for action in self.actions:
self.output.debug('Checking for action %s' % action[0], 4)
if action[0] in self.config.keys():
result += getattr(self, action[1])()
_errors = self.api.get_errors()
if _errors:
self.output.debug("CLI: found errors performing "
"action %s" % action[0], 2)
action_errors.append((action[0], _errors))
result = -1 # So it cannot remain 0, i.e. success
results.append(result)
self.output.debug('Completed action %s, result %s'
% (action[0], result==0), 4)
self.output.debug('Checking for action errors', 4)
if action_errors:
for action, _errors in action_errors:
self.output.warn("CLI: Errors occurred processing action"
" %s" % action)
for _error in _errors:
self.output.error(_error)
self.output.notice("")
# Reset umask
os.umask(old_umask)
if -1 in results:
sys.exit(FAILURE)
else:
sys.exit(SUCCEED)
def Fetch(self):
''' Fetches the overlay listing.
'''
self.output.info("Fetching remote list...", 2)
result = self.api.fetch_remote_list()
if result:
self.output.info('Fetch Ok', 2)
# blank newline -- no " *"
self.output.notice('')
return result
def Add(self):
''' Adds the selected overlay(s).
'''
self.output.info("Adding overlay...", 2)
selection = decode_selection(self.config['add'])
if ALL_KEYWORD in selection:
selection = self.api.get_available()
self.output.debug('Adding selected overlay(s)', 6)
result = self.api.add_repos(selection, update_news=True)
if result:
self.output.info('Successfully added overlay(s) ' +
', '.join((x.decode('UTF-8') if isinstance(x, bytes) else x) for x in selection) +
'.', 2)
# blank newline -- no " *"
self.output.notice('')
return result
def Readd(self):
'''Readds the selected overlay(s).
'''
self.output.info('Reinstalling overlay(s)...', 2)
selection = decode_selection(self.config['readd'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
self.output.debug('Reinstalling selected overlay(s)', 6)
result = self.api.readd_repos(selection, update_news=True)
if result:
self.output.info('Successfully reinstalled overlay(s) ' +
', '.join((x.decode('UTF-8') if isinstance(x, bytes) else x) for x in selection)
+ '.', 2)
self.output.notice('')
return result
def Sync(self):
''' Syncs the selected overlay(s).
'''
self.output.info("Syncing selected overlay(s)...", 2)
# Note api.sync() defaults to printing results
selection = decode_selection(self.config['sync'])
if self.config['sync_all'] or ALL_KEYWORD in selection:
selection = self.api.get_installed()
self.output.debug('Updating selected overlay(s)', 6)
result = self.api.sync(selection, update_news=True)
# blank newline -- no " *"
self.output.notice('')
return result
def Delete(self):
''' Deletes the selected overlay(s).
'''
self.output.info('Deleting selected overlay(s)...', 2)
selection = decode_selection(self.config['delete'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
result = self.api.delete_repos(selection)
if result:
self.output.info('Successfully deleted overlay(s) ' +
', '.join((x.decode('UTF-8') if isinstance(x, bytes) else x) for x in selection) +
'.', 2)
# blank newline -- no " *"
self.output.notice('')
return result
def Disable(self):
'''
Disable the selected overlay(s).
@rtype bool
'''
self.output.info('Disabling selected overlay(s),...', 2)
selection = decode_selection(self.config['disable'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
result = self.api.disable_repos(selection)
if result:
self.output.info('Successfully disabled overlay(s) ' +
', '.join((x.decode('UTF-8') if isinstance(x, bytes) else x) for x in selection) +
'.', 2)
self.output.notice('')
return result
def Enable(self):
'''
Enable the selected overlay(s).
@rtype bool
'''
self.output.info('Enabling the selected overlay(s),...', 2)
selection = decode_selection(self.config['enable'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
result = self.api.enable_repos(selection)
if result:
self.output.info('Successfully enable overlay(s) ' +
', '.join((x.decode('UTF-8') if isinstance(x, bytes) else x) for x in selection) +
'.', 2)
self.output.notice('')
return result
def Info(self):
''' Print information about the specified overlay(s).
'''
selection = decode_selection(self.config['info'])
if ALL_KEYWORD in selection:
selection = self.api.get_available()
list_printer = ListPrinter(self.config)
_complain = self.config['nocheck'] or self.config['verbose']
info = self.api.get_info_str(selection, local=False,
verbose=True, width=list_printer.width)
list_printer.print_shortdict(info, complain=_complain)
# blank newline -- no " *"
self.output.notice('')
return info != {}
def ListRemote(self):
''' Lists the available overlays.
'''
self.output.debug('Printing remote overlays.', 6)
list_printer = ListPrinter(self.config)
_complain = self.config['nocheck'] or self.config['verbose']
info = self.api.get_info_list(local=False,
verbose=self.config['verbose'], width=list_printer.width)
list_printer.print_shortlist(info, complain=_complain)
# blank newline -- no " *"
self.output.notice('')
return info != {}
def ListLocal(self):
''' Lists the local overlays.
'''
#print "ListLocal()"
self.output.debug('Printing installed overlays.', 6)
list_printer = ListPrinter(self.config)
info = self.api.get_info_list(verbose=self.config['verbose'],
width=list_printer.width)
#self.output.debug('CLI: ListLocal() info = %s' % len(info), 4)
#self.output.debug('\n'.join([ str(x) for x in info]), 4)
list_printer.print_shortlist(info, complain=True)
# blank newline -- no " *"
self.output.notice('')
return info != {}
class Main(object):
'''Performs the actions the user selected.
'''
def __init__(self, config):
self.config = config
self.output = config['output']
self.api = LaymanAPI(config, report_errors=False, output=config.output)
# Given in order of precedence
self.actions = [
('fetch', 'Fetch'),
('add', 'Add'),
('sync', 'Sync'),
('info', 'Info'),
('sync_all', 'Sync'),
('readd', 'Readd'),
('delete', 'Delete'),
('disable', 'Disable'),
('enable', 'Enable'),
('list', 'ListRemote'),
('list_local', 'ListLocal'),
]
def __call__(self):
self.output.debug(
"CLI.__call__(): self.config.keys()"
" %s" % str(self.config.keys()), 6)
# blank newline -- no " *"
self.output.notice('')
# check for and handle setup-help option
if self.config.get_option('setup_help'):
from layman.updater import Main as Updater
updater = Updater(config=self.config, output=self.output)
updater.print_instructions()
# Make fetching the overlay list a default action
if not 'nofetch' in self.config.keys():
# Actions that implicitly call the fetch operation before
fetch_actions = ['sync', 'sync_all', 'list']
for i in fetch_actions:
if i in self.config.keys():
# Implicitely call fetch, break loop
self.Fetch()
break
result = 0
# Set the umask
umask = self.config['umask']
try:
new_umask = int(umask, 8)
old_umask = os.umask(new_umask)
except Exception as error:
self.output.die('Failed setting to umask "' + umask +
'"!\nError was: ' + str(error))
action_errors = []
results = []
act = set([x[0] for x in self.actions])
k = set([x for x in self.config.keys()])
a = act.intersection(k)
self.output.debug('Actions = %s' % str(a), 4)
for action in self.actions:
self.output.debug('Checking for action %s' % action[0], 4)
if action[0] in self.config.keys():
result += getattr(self, action[1])()
_errors = self.api.get_errors()
if _errors:
self.output.debug(
"CLI: found errors performing "
"action %s" % action[0], 2)
action_errors.append((action[0], _errors))
result = -1 # So it cannot remain 0, i.e. success
results.append(result)
self.output.debug(
'Completed action %s, result %s' % (action[0], result == 0), 4)
self.output.debug('Checking for action errors', 4)
if action_errors:
for action, _errors in action_errors:
self.output.warn("CLI: Errors occurred processing action"
" %s" % action)
for _error in _errors:
self.output.error(_error)
self.output.notice("")
# Reset umask
os.umask(old_umask)
if -1 in results:
sys.exit(FAILURE)
else:
sys.exit(SUCCEED)
def Fetch(self):
''' Fetches the overlay listing.
'''
self.output.info("Fetching remote list...", 2)
result = self.api.fetch_remote_list()
if result:
self.output.info('Fetch Ok', 2)
# blank newline -- no " *"
self.output.notice('')
return result
def Add(self):
''' Adds the selected overlay(s).
'''
self.output.info("Adding overlay...", 2)
selection = decode_selection(self.config['add'])
if ALL_KEYWORD in selection:
selection = self.api.get_available()
self.output.debug('Adding selected overlay(s)', 6)
result = self.api.add_repos(selection, update_news=True)
if result:
self.output.info(
'Successfully added overlay(s) ' + ', '.join(
(x.decode('UTF-8') if isinstance(x, bytes) else x)
for x in selection) + '.', 2)
# blank newline -- no " *"
self.output.notice('')
return result
def Readd(self):
'''Readds the selected overlay(s).
'''
self.output.info('Reinstalling overlay(s)...', 2)
selection = decode_selection(self.config['readd'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
self.output.debug('Reinstalling selected overlay(s)', 6)
result = self.api.readd_repos(selection, update_news=True)
if result:
self.output.info(
'Successfully reinstalled overlay(s) ' + ', '.join(
(x.decode('UTF-8') if isinstance(x, bytes) else x)
for x in selection) + '.', 2)
self.output.notice('')
return result
def Sync(self):
''' Syncs the selected overlay(s).
'''
self.output.info("Syncing selected overlay(s)...", 2)
# Note api.sync() defaults to printing results
selection = decode_selection(self.config['sync'])
if self.config['sync_all'] or ALL_KEYWORD in selection:
selection = self.api.get_installed()
self.output.debug('Updating selected overlay(s)', 6)
result = self.api.sync(selection, update_news=True)
# blank newline -- no " *"
self.output.notice('')
return result
def Delete(self):
''' Deletes the selected overlay(s).
'''
self.output.info('Deleting selected overlay(s)...', 2)
selection = decode_selection(self.config['delete'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
result = self.api.delete_repos(selection)
if result:
self.output.info(
'Successfully deleted overlay(s) ' + ', '.join(
(x.decode('UTF-8') if isinstance(x, bytes) else x)
for x in selection) + '.', 2)
# blank newline -- no " *"
self.output.notice('')
return result
def Disable(self):
'''
Disable the selected overlay(s).
@rtype bool
'''
self.output.info('Disabling selected overlay(s),...', 2)
selection = decode_selection(self.config['disable'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
result = self.api.disable_repos(selection)
if result:
self.output.info(
'Successfully disabled overlay(s) ' + ', '.join(
(x.decode('UTF-8') if isinstance(x, bytes) else x)
for x in selection) + '.', 2)
self.output.notice('')
return result
def Enable(self):
'''
Enable the selected overlay(s).
@rtype bool
'''
self.output.info('Enabling the selected overlay(s),...', 2)
selection = decode_selection(self.config['enable'])
if ALL_KEYWORD in selection:
selection = self.api.get_installed()
result = self.api.enable_repos(selection)
if result:
self.output.info(
'Successfully enable overlay(s) ' + ', '.join(
(x.decode('UTF-8') if isinstance(x, bytes) else x)
for x in selection) + '.', 2)
self.output.notice('')
return result
def Info(self):
''' Print information about the specified overlay(s).
'''
selection = decode_selection(self.config['info'])
if ALL_KEYWORD in selection:
selection = self.api.get_available()
list_printer = ListPrinter(self.config)
_complain = self.config['nocheck'] or self.config['verbose']
info = self.api.get_info_str(selection,
local=False,
verbose=True,
width=list_printer.width)
list_printer.print_shortdict(info, complain=_complain)
# blank newline -- no " *"
self.output.notice('')
return info != {}
def ListRemote(self):
''' Lists the available overlays.
'''
self.output.debug('Printing remote overlays.', 6)
list_printer = ListPrinter(self.config)
_complain = self.config['nocheck'] or self.config['verbose']
info = self.api.get_info_list(local=False,
verbose=self.config['verbose'],
width=list_printer.width)
list_printer.print_shortlist(info, complain=_complain)
# blank newline -- no " *"
self.output.notice('')
return info != {}
def ListLocal(self):
''' Lists the local overlays.
'''
#print "ListLocal()"
self.output.debug('Printing installed overlays.', 6)
list_printer = ListPrinter(self.config)
info = self.api.get_info_list(verbose=self.config['verbose'],
width=list_printer.width)
#self.output.debug('CLI: ListLocal() info = %s' % len(info), 4)
#self.output.debug('\n'.join([ str(x) for x in info]), 4)
list_printer.print_shortlist(info, complain=True)
# blank newline -- no " *"
self.output.notice('')
return info != {}