Example #1
0
    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()
Example #2
0
    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()
Example #3
0
 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
Example #4
0
 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
Example #5
0
 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())
Example #6
0
    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)
Example #7
0
 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()
Example #8
0
 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()
Example #9
0
 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()
Example #10
0
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)
Example #11
0
    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)
Example #12
0
    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)
Example #13
0
File: cli.py Project: vaeth/layman
 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'),
     ]
Example #14
0
 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())
Example #15
0
    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)
Example #16
0
 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'),]
Example #17
0
    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
Example #18
0
    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)
Example #19
0
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}))
Example #20
0
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}))
Example #21
0
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}))
Example #22
0
File: cli.py Project: gentoo/layman
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 != {}
Example #23
0
File: cli.py Project: vaeth/layman
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 != {}