def check_for_package(connection, reponame, package):
        '''
        list packages in a repository
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "p")
        RHUIManager.select_one(connection, reponame)
        Expect.expect(connection, "\(blank line for no filter\):")
        Expect.enter(connection, package)

        pattern = re.compile('.*only\.\r\n(.*)\r\n-+\r\nrhui\s* \(repo\)\s* =>',
                             re.DOTALL)
        ret = Expect.match(connection, pattern, grouplist=[1])[0]
        reslist = map(lambda x: x.strip(), ret.split("\r\n"))
        print reslist
        packagelist = []
        for line in reslist:
            if line == '':
                continue
            if line == 'Packages:':
                continue
            if line == 'No packages found that match the given filter.':
                continue
            if line == 'No packages in the repository.':
                continue
            packagelist.append(line)

        Expect.enter(connection, 'q')
        return packagelist
示例#2
0
    def check_for_package(connection, reponame, package):
        '''
        list packages in a repository
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "p")
        RHUIManager.select_one(connection, reponame)
        Expect.expect(connection, "\(blank line for no filter\):")
        Expect.enter(connection, package)

        pattern = re.compile(
            '.*only\.\r\n(.*)\r\n-+\r\nrhui\s* \(repo\)\s* =>', re.DOTALL)
        ret = Expect.match(connection, pattern, grouplist=[1])[0]
        reslist = map(lambda x: x.strip(), ret.split("\r\n"))
        print reslist
        packagelist = []
        for line in reslist:
            if line == '':
                continue
            if line == 'Packages:':
                continue
            if line == 'No packages found that match the given filter.':
                continue
            if line == 'No packages in the repository.':
                continue
            packagelist.append(line)

        Expect.enter(connection, 'q')
        return packagelist
    def list(connection):
        '''
        list repositories
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "l")
        # eating prompt!!
        pattern = re.compile('l\r\n(.*)\r\n-+\r\nrhui\s* \(repo\)\s* =>',
                re.DOTALL)
        ret = Expect.match(connection, pattern, grouplist=[1])[0]
        print ret
        reslist = map(lambda x: x.strip(), ret.split("\r\n"))
        print reslist
        repolist = []
        for line in reslist:
            # Readling lines and searching for repos
            if line == '':
                continue
            if "Custom Repositories" in line:
                continue
            if "Red Hat Repositories" in line:
                continue
            if "No repositories are currently managed by the RHUI" in line:
                continue
            repolist.append(line)

        Expect.enter(connection, 'q')
        return repolist
示例#4
0
    def list(connection):
        '''
        list repositories
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "l")
        # eating prompt!!
        pattern = re.compile('l\r\n(.*)\r\n-+\r\nrhui\s* \(repo\)\s* =>',
                             re.DOTALL)
        ret = Expect.match(connection, pattern, grouplist=[1])[0]
        print ret
        reslist = map(lambda x: x.strip(), ret.split("\r\n"))
        print reslist
        repolist = []
        for line in reslist:
            # Readling lines and searching for repos
            if line == '':
                continue
            if "Custom Repositories" in line:
                continue
            if "Red Hat Repositories" in line:
                continue
            if "No repositories are currently managed by the RHUI" in line:
                continue
            repolist.append(line)

        Expect.enter(connection, 'q')
        return repolist
 def associate_repo_cds(connection, clustername, repolist):
     '''
     associate a repository with a CDS cluster
     '''
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "s")
     RHUIManager.select_one(connection, clustername)
     RHUIManager.select(connection, repolist)
     RHUIManager.proceed_with_check(connection, "The following repositories will be associated with the " + clustername + " cluster:",
                                    repolist, ["Red Hat Repositories", "Custom Repositories"])
     RHUIManager.quit(connection)
示例#6
0
    def info(connection, repolist):
        '''
        detailed information about repositories

        Method returns list of items from rhui-manager info screen. Some of them are variable and these are replaced by "rh_repo" constant.
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "i")
        RHUIManager.select(connection, repolist)

        try:
            pattern = re.compile(
                '.*for more commands: \r\n\r\nName:\s(.*)\r\n-+\r\nrhui\s* \(repo\)\s* =>',
                re.DOTALL)
            ret = Expect.match(connection, pattern, grouplist=[1])[0]
            print ret
            res = map(lambda x: x.strip(), ret.split("\r\n"))
            reslist = ["Name:"]
            for line in res:
                reslist.extend(
                    map(lambda y: y.strip(), re.split("\s{3}", line)))
            print reslist
            repoinfo = []
            rh_repo = 0
            rh_repo_info = 0
            for line in reslist:
                # Readling lines
                if line == '':
                    continue
                if rh_repo_info == 1:
                    line = "rh_repo"
                    rh_repo_info = 0
                if line == "Red Hat":
                    rh_repo = 1
                if "Relative Path:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                if "Package Count:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                if "Last Sync:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                if "Next Sync:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                repoinfo.append(line)
            print repoinfo

        except:
            repoinfo = []

        Expect.enter(connection, 'q')
        return repoinfo
示例#7
0
 def list(connection):
     '''
     return the list of currently managed CDSes
     '''
     RHUIManager.screen(connection, "cds")
     # eating prompt!!
     lines = RHUIManager.list_lines(connection, prompt=RHUIManagerCds.prompt)
     ret = Cds.parse(lines)
     # custom quitting; have eaten the prompt
     Expect.enter(connection, 'q')
     return [cds for _, cds in ret]
 def _sync_cds(self, cdslist):
     """ Sync cds """
     if (not "RHUA" in self.rs.Instances.keys()) or len(self.rs.Instances["RHUA"]) < 1:
         raise nose.exc.SkipTest("can't test without RHUA!")
     try:
         RHUIManagerSync.sync_cds(self.rs.Instances["RHUA"][0], cdslist)
     except ExpectFailed:
         # The CDS is not available for syncing so most probably it's syncing right now
         # Trying to check the status
         Expect.enter(self.rs.Instances["RHUA"][0], "b")
         RHUIManager.quit(self.rs.Instances["RHUA"][0])
     self._sync_wait_cds(cdslist)
    def info(connection, repolist):
        '''
        detailed information about repositories

        Method returns list of items from rhui-manager info screen. Some of them are variable and these are replaced by "rh_repo" constant.
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "i")
        RHUIManager.select(connection, repolist)

        try:
            pattern = re.compile('.*for more commands: \r\n\r\nName:\s(.*)\r\n-+\r\nrhui\s* \(repo\)\s* =>',
                                 re.DOTALL)
            ret = Expect.match(connection, pattern, grouplist=[1])[0]
            print ret
            res = map(lambda x: x.strip(), ret.split("\r\n"))
            reslist = ["Name:"]
            for line in res:
                reslist.extend(map(lambda y: y.strip(), re.split("\s{3}", line)))
            print reslist
            repoinfo = []
            rh_repo = 0
            rh_repo_info = 0
            for line in reslist:
                # Readling lines
                if line == '':
                    continue
                if rh_repo_info == 1:
                    line = "rh_repo"
                    rh_repo_info = 0
                if line == "Red Hat":
                    rh_repo = 1
                if "Relative Path:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                if "Package Count:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                if "Last Sync:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                if "Next Sync:" in line:
                    if rh_repo == 1:
                        rh_repo_info = 1
                repoinfo.append(line)
            print repoinfo

        except:
            repoinfo = []

        Expect.enter(connection, 'q')
        return repoinfo
示例#10
0
 def change_password(connection, username, password):
     '''
     change a user's password
     '''
     RHUIManager.screen(connection, "users")
     Expect.enter(connection, "p")
     Expect.expect(connection, "Username:"******"New Password:"******"Re-enter Password:"******"Password successfully updated")
示例#11
0
 def _sync_cds(self, cdslist):
     """ Sync cds """
     if (not "RHUA" in self.rs.Instances.keys()) or len(
             self.rs.Instances["RHUA"]) < 1:
         raise nose.exc.SkipTest("can't test without RHUA!")
     try:
         RHUIManagerSync.sync_cds(self.rs.Instances["RHUA"][0], cdslist)
     except ExpectFailed:
         # The CDS is not available for syncing so most probably it's syncing right now
         # Trying to check the status
         Expect.enter(self.rs.Instances["RHUA"][0], "b")
         RHUIManager.quit(self.rs.Instances["RHUA"][0])
     self._sync_wait_cds(cdslist)
 def list(connection):
     """
     return the list currently managed CDSes and clusters as it is provided
     by the cds list command
     """
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "l")
     # eating prompt!!
     pattern = re.compile("l(\r\n)+(.*)rhui\s* \(cds\)\s* =>", re.DOTALL)
     ret = Expect.match(connection, pattern, grouplist=[2])[0]
     # custom quitting; have eaten the prompt
     Expect.enter(connection, "q")
     return ret
 def list(connection):
     '''
     return the list currently managed CDSes and clusters as it is provided
     by the cds list command
     '''
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "l")
     # eating prompt!!
     pattern = re.compile('l(\r\n)+(.*)rhui\s* \(cds\)\s* =>',
             re.DOTALL)
     ret = Expect.match(connection, pattern, grouplist=[2])[0]
     # custom quitting; have eaten the prompt
     Expect.enter(connection, 'q')
     return ret
 def delete_cds(connection, clustername, cdslist, force=False):
     '''
     unregister (delete) a CDS instance from the RHUI
     '''
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "d")
     RHUIManager.select_one(connection, clustername)
     RHUIManager.select(connection, cdslist)
     RHUIManager.proceed_with_check(connection, "The following CDS instances from the %s cluster will be unregistered:"
             % clustername, cdslist)
     if force:
         Expect.expect(connection, "Forcibly remove these CDS instances", 60)
         Expect.enter(connection, "y")
     RHUIManager.quit(connection, timeout=30)
 def get_cds_status(connection, cdsname):
     '''
     display CDS sync summary
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "dc")
     res_list = Expect.match(connection, re.compile(".*\n" + cdsname.replace(".", "\.") + "[\.\s]*\[([^\n]*)\].*" + cdsname.replace(".", "\.") + "\s*\r\n([^\n]*)\r\n", re.DOTALL), [1, 2], 60)
     connection.cli.exec_command("killall -s SIGINT rhui-manager")
     ret_list = []
     for val in [res_list[0]] + res_list[1].split("             "):
         val = Util.uncolorify(val.strip())
         ret_list.append(val)
     RHUIManager.quit(connection)
     return ret_list
 def delete_cds(connection, clustername, cdslist, force=False):
     """
     unregister (delete) a CDS instance from the RHUI
     """
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "d")
     RHUIManager.select_one(connection, clustername)
     RHUIManager.select(connection, cdslist)
     RHUIManager.proceed_with_check(
         connection, "The following CDS instances from the %s cluster will be unregistered:" % clustername, cdslist
     )
     if force:
         Expect.expect(connection, "Forcibly remove these CDS instances", 60)
         Expect.enter(connection, "y")
     RHUIManager.quit(connection, timeout=30)
 def get_repo_status(connection, reponame):
     '''
     display repo sync summary
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "dr")
     reponame_quoted = reponame.replace(".", "\.")
     res = Expect.match(connection, re.compile(".*" + reponame_quoted + "\s*\r\n([^\n]*)\r\n.*", re.DOTALL), [1], 60)[0]
     connection.cli.exec_command("killall -s SIGINT rhui-manager")
     res = Util.uncolorify(res)
     ret_list = res.split("             ")
     for i in range(len(ret_list)):
         ret_list[i] = ret_list[i].strip()
     RHUIManager.quit(connection)
     return ret_list
 def associate_repo_cds(connection, clustername, repolist):
     """
     associate a repository with a CDS cluster
     """
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "s")
     RHUIManager.select_one(connection, clustername)
     RHUIManager.select(connection, repolist)
     RHUIManager.proceed_with_check(
         connection,
         "The following repositories will be associated with the " + clustername + " cluster:",
         repolist,
         ["Red Hat Repositories", "Custom Repositories"],
     )
     RHUIManager.quit(connection)
 def generate_new(connection, days="", cert_pw=None):
     '''
     generate a new identity certificate
     '''
     RHUIManager.screen(connection, "identity")
     Expect.enter(connection, "g")
     Expect.expect(connection, "Proceed\? \[y/n\]")
     Expect.enter(connection, "y")
     Expect.expect(connection, "regenerated using rhui-manager.*:")
     Expect.enter(connection, days)
     Expect.expect(connection, "Enter pass phrase for.*:")
     if cert_pw:
         Expect.enter(connection, cert_pw)
     else:
         Expect.enter(connection, Util.get_ca_password(connection))
     RHUIManager.quit(connection, "Successfully regenerated RHUI Identity certificate", 30)
 def sync_cluster(connection, clusterlist):
     '''
     sync a CDS cluster immediately
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "sl")
     RHUIManager.select(connection, clusterlist)
     RHUIManager.proceed_with_check(connection, "The following CDS clusters will be scheduled for synchronization:", clusterlist)
     RHUIManager.quit(connection)
 def delete_repo(connection, repolist):
     '''
     delete a repository from the RHUI
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "d")
     RHUIManager.select(connection, repolist)
     RHUIManager.proceed_with_check(connection, "The following repositories will be deleted:", repolist, ["Red Hat Repositories", "Custom Repositories"])
     RHUIManager.quit(connection)
 def sync_cds(connection, cdslist):
     '''
     sync an individual CDS immediately
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "sc")
     RHUIManager.select(connection, cdslist)
     RHUIManager.proceed_with_check(connection, "The following CDS instances will be scheduled for synchronization:", cdslist)
     RHUIManager.quit(connection)
 def _sync_repo(self, repolist):
     """ Sync repo """
     if (not "RHUA" in self.rs.Instances.keys()) or len(self.rs.Instances["RHUA"]) < 1:
         raise nose.exc.SkipTest("can't test without RHUA!")
     try:
         RHUIManagerSync.sync_repo(self.rs.Instances["RHUA"][0], repolist)
     except ExpectFailed:
         # The repo is not available for syncing so most probably it's syncing right now
         # Trying to check the status
         Expect.enter(self.rs.Instances["RHUA"][0], "b")
         RHUIManager.quit(self.rs.Instances["RHUA"][0])
     for repo in repolist:
         reposync = ["In Progress", "", ""]
         while reposync[0] in ["In Progress", "Never"]:
             time.sleep(10)
             reposync = RHUIManagerSync.get_repo_status(self.rs.Instances["RHUA"][0], repo)
         nose.tools.assert_equal(reposync[2], "Success")
示例#24
0
 def get_repo_status(connection, reponame):
     '''
     display repo sync summary
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "dr")
     reponame_quoted = reponame.replace(".", "\.")
     res = Expect.match(
         connection,
         re.compile(".*" + reponame_quoted + "\s*\r\n([^\n]*)\r\n.*",
                    re.DOTALL), [1], 60)[0]
     connection.cli.exec_command("killall -s SIGINT rhui-manager")
     res = Util.uncolorify(res)
     ret_list = res.split("             ")
     for i in range(len(ret_list)):
         ret_list[i] = ret_list[i].strip()
     RHUIManager.quit(connection)
     return ret_list
 def generate_new(connection, days="", cert_pw=None):
     '''
     generate a new identity certificate
     '''
     RHUIManager.screen(connection, "identity")
     Expect.enter(connection, "g")
     Expect.expect(connection, "Proceed\? \[y/n\]")
     Expect.enter(connection, "y")
     Expect.expect(connection, "regenerated using rhui-manager.*:")
     Expect.enter(connection, days)
     Expect.expect(connection, "Enter pass phrase for.*:")
     if cert_pw:
         Expect.enter(connection, cert_pw)
     else:
         Expect.enter(connection, Util.get_ca_password(connection))
     RHUIManager.quit(connection,
                      "Successfully regenerated RHUI Identity certificate",
                      30)
 def add_rh_repo_by_product(connection, productlist):
     '''
     add a new Red Hat content repository (By Product)
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Import Repositories:.*to abort:", 180)
     Expect.enter(connection, "2")
     RHUIManager.select(connection, productlist)
     RHUIManager.proceed_with_check(connection, "The following products will be deployed:", productlist)
     RHUIManager.quit(connection, "Content will not be downloaded", 45)
 def upload_content(connection, repolist, path):
     '''
     upload content to a custom repository
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "u")
     RHUIManager.select(connection, repolist)
     Expect.expect(connection, "will be uploaded:")
     Expect.enter(connection, path)
     RHUIManager.proceed_without_check(connection)
     RHUIManager.quit(connection)
示例#28
0
 def delete_repo(connection, repolist):
     '''
     delete a repository from the RHUI
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "d")
     RHUIManager.select(connection, repolist)
     RHUIManager.proceed_with_check(
         connection, "The following repositories will be deleted:",
         repolist, ["Red Hat Repositories", "Custom Repositories"])
     RHUIManager.quit(connection)
 def sync_repo(connection, repolist):
     '''
     sync an individual repository immediately
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "sr")
     Expect.expect(connection, "Select one or more repositories.*for more commands:", 60)
     Expect.enter(connection, "l")
     RHUIManager.select(connection, repolist)
     RHUIManager.proceed_with_check(connection, "The following repositories will be scheduled for synchronization:", repolist)
     RHUIManager.quit(connection)
示例#30
0
 def upload_content(connection, repolist, path):
     '''
     upload content to a custom repository
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "u")
     RHUIManager.select(connection, repolist)
     Expect.expect(connection, "will be uploaded:")
     Expect.enter(connection, path)
     RHUIManager.proceed_without_check(connection)
     RHUIManager.quit(connection)
示例#31
0
 def sync_cluster(connection, clusterlist):
     '''
     sync a CDS cluster immediately
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "sl")
     RHUIManager.select(connection, clusterlist)
     RHUIManager.proceed_with_check(
         connection,
         "The following CDS clusters will be scheduled for synchronization:",
         clusterlist)
     RHUIManager.quit(connection)
示例#32
0
 def sync_cds(connection, cdslist):
     '''
     sync an individual CDS immediately
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "sc")
     RHUIManager.select(connection, cdslist)
     RHUIManager.proceed_with_check(
         connection,
         "The following CDS instances will be scheduled for synchronization:",
         cdslist)
     RHUIManager.quit(connection)
示例#33
0
 def get_cds_status(connection, cdsname):
     '''
     display CDS sync summary
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "dc")
     res_list = Expect.match(
         connection,
         re.compile(
             ".*\n" + cdsname.replace(".", "\.") + "[\.\s]*\[([^\n]*)\].*" +
             cdsname.replace(".", "\.") + "\s*\r\n([^\n]*)\r\n", re.DOTALL),
         [1, 2], 60)
     connection.cli.exec_command("killall -s SIGINT rhui-manager")
     ret_list = []
     for val in [res_list[0]] + res_list[1].split("             "):
         val = Util.uncolorify(val.strip())
         ret_list.append(val)
     RHUIManager.quit(connection)
     return ret_list
 def move_cds(connection, cdslist, clustername):
     '''
     move the CDSes to clustername
     '''
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "m")
     RHUIManager.select(connection, cdslist)
     RHUIManagerCds._select_cluster(connection, clustername)
     RHUIManager.proceed_with_check(connection,
             "The following Content Delivery Servers will be moved to the %s cluster:\r\n.*-+" % clustername,
             cdslist)
     RHUIManager.quit(connection, "successfully moved CDS")
示例#35
0
 def _sync_repo(self, repolist):
     """ Sync repo """
     if (not "RHUA" in self.rs.Instances.keys()) or len(
             self.rs.Instances["RHUA"]) < 1:
         raise nose.exc.SkipTest("can't test without RHUA!")
     try:
         RHUIManagerSync.sync_repo(self.rs.Instances["RHUA"][0], repolist)
     except ExpectFailed:
         # The repo is not available for syncing so most probably it's syncing right now
         # Trying to check the status
         Expect.enter(self.rs.Instances["RHUA"][0], "b")
         RHUIManager.quit(self.rs.Instances["RHUA"][0])
     for repo in repolist:
         reposync = ["In Progress", "", ""]
         while reposync[0] in ["In Progress", "Never"]:
             time.sleep(10)
             reposync = RHUIManagerSync.get_repo_status(
                 self.rs.Instances["RHUA"][0], repo)
         nose.tools.assert_equal(reposync[2], "Success")
示例#36
0
 def add_rh_repo_by_product(connection, productlist):
     '''
     add a new Red Hat content repository (By Product)
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Import Repositories:.*to abort:", 180)
     Expect.enter(connection, "2")
     RHUIManager.select(connection, productlist)
     RHUIManager.proceed_with_check(
         connection, "The following products will be deployed:",
         productlist)
     RHUIManager.quit(connection, "Content will not be downloaded", 45)
示例#37
0
 def add_cds(connection, cds=Cds(), update=False):
     '''
     Register (add) a new CDS instance
     @param cds: rhuilib.cds.Cds instance
     @param update: Bool; update the cds if it is already tracked or rise ExpectFailed
     '''
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Hostname of the Content Delivery Server instance to register:")
     Expect.enter(connection, cds.host_name)
     state = Expect.expect_list(connection, [ \
         (re.compile(".*Username with SSH access to %s and sudo privileges:.*" % cds.host_name, re.DOTALL), 1),
         (re.compile(".*A Content Delivery Server instance with that hostname exists.*Continue\?\s+\(y/n\): ", re.DOTALL), 2)
     ])
     if state == 2:
         # cds of the same hostname is already being tracked
         if not update:
             # but we don't wish to update its config: raise
             raise ExpectFailed("%s already tracked but update wasn't required" % cds.host_name)
         else:
             # we wish to update, send 'y' answer
             Expect.enter(connection, "y")
             # the question about user name comes now
             Expect.expect(connection, "Username with SSH access to %s and sudo privileges:" % cds.host_name)
     # if the execution reaches here, uesername question was already asked
     Expect.enter(connection, cds.user_name)
     Expect.expect(connection, "Absolute path to an SSH private key to log into %s as ec2-user:"******".*Cannot find file, please enter a valid path.*", re.DOTALL), 1),
         (PROCEED_PATTERN, 2)
     ])
     if state == 1:
         # don't know how to continue with invalid path: raise
         Expect.enter(connection, CTRL_C)
         Expect.enter(connection, "q")
         raise InvalidSshKeyPath(cds.ssh_key_path)
     # all OK, confirm
     Expect.enter(connection, "y")
     # some installation and configuration through Puppet happens here, let it take its time
     RHUIManager.quit(connection, "The Content Delivery Server was successfully configured.", timeout=180)
 def create_conf_rpm(connection, clustername, primary_cds, dirname, certpath, certkey, rpmname, rpmversion="", unprotected_repos=None):
     '''
     create a client configuration RPM from an entitlement certificate
     '''
     RHUIManager.screen(connection, "client")
     Expect.enter(connection, "c")
     Expect.expect(connection, "Full path to local directory.*:")
     Expect.enter(connection, dirname)
     Expect.expect(connection, "Name of the RPM:")
     Expect.enter(connection, rpmname)
     Expect.expect(connection, "Version of the configuration RPM.*:")
     Expect.enter(connection, rpmversion)
     Expect.expect(connection, "Full path to the entitlement certificate.*:")
     Expect.enter(connection, certpath)
     Expect.expect(connection, "Full path to the private key for the above entitlement certificate:")
     Expect.enter(connection, certkey)
     RHUIManager.select_one(connection, clustername)
     RHUIManager.select_one(connection, primary_cds)
     if unprotected_repos:
         RHUIManager.select(connection, unprotected_repos)
     RHUIManager.quit(connection, "Successfully created client configuration RPM")
 def add_cds(connection, clustername, cdsname, hostname="", displayname=""):
     """
     register (add) a new CDS instance
     """
     RHUIManager.screen(connection, "cds")
     RHUIManagerCds._add_cds_part1(connection, cdsname, hostname, displayname)
     state = Expect.expect_list(
         connection,
         [
             (re.compile(".*Enter a CDS cluster name:.*", re.DOTALL), 1),
             (re.compile(".*Select a CDS cluster or enter a new one:.*", re.DOTALL), 2),
         ],
     )
     if state == 1:
         Expect.enter(connection, clustername)
     else:
         Expect.enter(connection, "b")
         Expect.expect(connection, "rhui \(cds\) =>")
         RHUIManagerCds._add_cds_part1(connection, cdsname, hostname, displayname)
         RHUIManagerCds._select_cluster(connection, clustername)
     # We need to compare the output before proceeding
     checklist = ["Hostname: " + cdsname]
     if hostname != "":
         checklist.append("Client Hostname: " + hostname)
     else:
         checklist.append("Client Hostname: " + cdsname)
     if displayname != "":
         checklist.append("Name: " + displayname)
     else:
         checklist.append("Name: " + cdsname)
     checklist.append("Cluster: " + clustername)
     RHUIManager.proceed_with_check(connection, "The following CDS instance will be registered:", checklist)
     RHUIManager.quit(connection, "Successfully registered")
 def move_cds(connection, cdslist, clustername):
     """
     move the CDSes to clustername
     """
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "m")
     RHUIManager.select(connection, cdslist)
     RHUIManagerCds._select_cluster(connection, clustername)
     RHUIManager.proceed_with_check(
         connection,
         "The following Content Delivery Servers will be moved to the %s cluster:\r\n.*-+" % clustername,
         cdslist,
     )
     RHUIManager.quit(connection, "successfully moved CDS")
 def add_cds(connection, clustername, cdsname, hostname="", displayname=""):
     '''
     register (add) a new CDS instance
     '''
     RHUIManager.screen(connection, "cds")
     RHUIManagerCds._add_cds_part1(connection, cdsname, hostname, displayname)
     state = Expect.expect_list(connection, [(re.compile(".*Enter a CDS cluster name:.*", re.DOTALL), 1),
                                             (re.compile(".*Select a CDS cluster or enter a new one:.*", re.DOTALL), 2)])
     if state == 1:
         Expect.enter(connection, clustername)
     else:
         Expect.enter(connection, 'b')
         Expect.expect(connection, "rhui \(cds\) =>")
         RHUIManagerCds._add_cds_part1(connection, cdsname, hostname, displayname)
         RHUIManagerCds._select_cluster(connection, clustername)
     # We need to compare the output before proceeding
     checklist = ["Hostname: " + cdsname]
     if hostname != "":
         checklist.append("Client Hostname: " + hostname)
     else:
         checklist.append("Client Hostname: " + cdsname)
     if displayname != "":
         checklist.append("Name: " + displayname)
     else:
         checklist.append("Name: " + cdsname)
     checklist.append("Cluster: " + clustername)
     RHUIManager.proceed_with_check(connection, "The following CDS instance will be registered:", checklist)
     RHUIManager.quit(connection, "Successfully registered")
 def generate_ent_cert(connection, clustername, repolist, certname, dirname, validity_days="", cert_pw=None):
     '''
     generate an entitlement certificate
     '''
     RHUIManager.screen(connection, "client")
     Expect.enter(connection, "e")
     RHUIManager.select_one(connection, clustername)
     RHUIManager.select(connection, repolist)
     Expect.expect(connection, "Name of the certificate.*contained with it:")
     Expect.enter(connection, certname)
     Expect.expect(connection, "Local directory in which to save the generated certificate.*:")
     Expect.enter(connection, dirname)
     Expect.expect(connection, "Number of days the certificate should be valid.*:")
     Expect.enter(connection, validity_days)
     RHUIManager.proceed_with_check(connection, "Repositories to be included in the entitlement certificate:",
                                    repolist, ["Custom Entitlements", "Red Hat Repositories"])
     Expect.expect(connection, "Enter pass phrase for.*:")
     if cert_pw:
         Expect.enter(connection, cert_pw)
     else:
         Expect.enter(connection, Util.get_ca_password(connection))
     RHUIManager.quit(connection)
示例#43
0
 def delete_cdses(connection, *cdses):
     '''
     unregister (delete) CDS instance from the RHUI
     '''
     RHUIManager.screen(connection, "cds")
     Expect.enter(connection, "d")
     RHUIManager.select_items(connection, *cdses)
     RHUIManager.quit(connection, timeout=30)
示例#44
0
 def sync_repo(connection, repolist):
     '''
     sync an individual repository immediately
     '''
     RHUIManager.screen(connection, "sync")
     Expect.enter(connection, "sr")
     Expect.expect(connection,
                   "Select one or more repositories.*for more commands:",
                   60)
     Expect.enter(connection, "l")
     RHUIManager.select(connection, repolist)
     RHUIManager.proceed_with_check(
         connection,
         "The following repositories will be scheduled for synchronization:",
         repolist)
     RHUIManager.quit(connection)
 def add_rh_repo_by_repo(connection, repolist):
     '''
     add a new Red Hat content repository (By Repository)
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Import Repositories:.*to abort:", 180)
     Expect.enter(connection, "3")
     RHUIManager.select(connection, repolist)
     repocheck = list(repolist)
     for repo in repolist:
         #adding repo titles to check list
         repotitle = re.sub(" \\\\\([^\(]*\\\\\)$", "", repo)
         if not repotitle in repocheck:
             repocheck.append(repotitle)
     RHUIManager.proceed_with_check(connection, "The following product repositories will be deployed:", repocheck)
     RHUIManager.quit(connection, "Content will not be downloaded", 45)
示例#46
0
 def add_rh_repo_all(connection):
     '''
     add a new Red Hat content repository (All in Certificate)
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Import Repositories:.*to abort:", 180)
     Expect.enter(connection, "1")
     RHUIManager.proceed_without_check(connection)
     RHUIManager.quit(connection, "Content will not be downloaded", 45)
 def add_rh_repo_all(connection):
     '''
     add a new Red Hat content repository (All in Certificate)
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Import Repositories:.*to abort:", 180)
     Expect.enter(connection, "1")
     RHUIManager.proceed_without_check(connection)
     RHUIManager.quit(connection, "Content will not be downloaded", 45)
示例#48
0
 def add_rh_repo_by_repo(connection, repolist):
     '''
     add a new Red Hat content repository (By Repository)
     '''
     RHUIManager.screen(connection, "repo")
     Expect.enter(connection, "a")
     Expect.expect(connection, "Import Repositories:.*to abort:", 180)
     Expect.enter(connection, "3")
     RHUIManager.select(connection, repolist)
     repocheck = list(repolist)
     for repo in repolist:
         #adding repo titles to check list
         repotitle = re.sub(" \\\\\([^\(]*\\\\\)$", "", repo)
         if not repotitle in repocheck:
             repocheck.append(repotitle)
     RHUIManager.proceed_with_check(
         connection, "The following product repositories will be deployed:",
         repocheck)
     RHUIManager.quit(connection, "Content will not be downloaded", 45)
 def upload_content_cert(connection, certpath):
     '''
     upload a new or updated Red Hat content certificate
     '''
     if certpath[:1] == '/':
         Expect.enter(connection, "mkdir -p `dirname " + certpath + "` && echo SUCCESS")
         Expect.expect(connection, "[^ ]SUCCESS")
     connection.sftp.put(certpath, certpath)
     RHUIManager.screen(connection, "entitlements")
     Expect.enter(connection, "u")
     Expect.expect(connection, "Full path to the new content certificate:")
     Expect.enter(connection, certpath)
     RHUIManager.proceed_with_check(connection, "The RHUI will be updated with the following certificate:", [certpath])
     RHUIManager.quit(connection, "Red Hat Entitlements.*Valid.*------------------")
示例#50
0
 def upload_content_cert(connection, certpath):
     '''
     upload a new or updated Red Hat content certificate
     '''
     if certpath[:1] == '/':
         Expect.enter(connection,
                      "mkdir -p `dirname " + certpath + "` && echo SUCCESS")
         Expect.expect(connection, "[^ ]SUCCESS")
     connection.sftp.put(certpath, certpath)
     RHUIManager.screen(connection, "entitlements")
     Expect.enter(connection, "u")
     Expect.expect(connection, "Full path to the new content certificate:")
     Expect.enter(connection, certpath)
     RHUIManager.proceed_with_check(
         connection,
         "The RHUI will be updated with the following certificate:",
         [certpath])
     RHUIManager.quit(connection,
                      "Red Hat Entitlements.*Valid.*------------------")
示例#51
0
    def add_custom_repo(connection,
                        reponame,
                        displayname="",
                        path="",
                        checksum_alg="2",
                        entitlement="y",
                        entitlement_path="",
                        redhat_gpg="y",
                        custom_gpg=None):
        '''
        create a new custom repository
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "c")
        Expect.expect(connection, "Unique ID for the custom repository.*:")
        Expect.enter(connection, reponame)
        checklist = ["ID: " + reponame]
        Expect.expect(connection, "Display name for the custom repository.*:")
        Expect.enter(connection, displayname)
        if displayname != "":
            checklist.append("Name: " + displayname)
        else:
            checklist.append("Name: " + reponame)
        Expect.expect(connection,
                      "Path at which the repository will be served.*:")
        Expect.enter(connection, path)
        if path != "":
            path_real = path
        else:
            path_real = reponame
        checklist.append("Path: " + path_real)
        Expect.expect(connection, "Enter value.*:")
        Expect.enter(connection, checksum_alg)
        Expect.expect(
            connection,
            "Should the repository require an entitlement certificate to access\? \(y/n\)"
        )
        Expect.enter(connection, entitlement)
        if entitlement == "y":
            Expect.expect(
                connection,
                "Path that should be used when granting an entitlement for this repository.*:"
            )
            Expect.enter(connection, entitlement_path)
            if entitlement_path != "":
                checklist.append("Entitlement: " + entitlement_path)
            else:
                educated_guess, replace_count = re.subn(
                    "(i386|x86_64)", "$basearch", path_real)
                if replace_count > 1:
                    # bug 815975
                    educated_guess = path_real
                checklist.append("Entitlement: " + educated_guess)
        Expect.expect(connection, "packages are signed by a GPG key\? \(y/n\)")
        if redhat_gpg == "y" or custom_gpg:
            Expect.enter(connection, "y")
            checklist.append("GPG Check Yes")
            Expect.expect(
                connection,
                "Will the repository be used to host any Red Hat GPG signed content\? \(y/n\)"
            )
            Expect.enter(connection, redhat_gpg)
            if redhat_gpg == "y":
                checklist.append("Red Hat GPG Key: Yes")
            else:
                checklist.append("Red Hat GPG Key: No")
            Expect.expect(
                connection,
                "Will the repository be used to host any custom GPG signed content\? \(y/n\)"
            )
            if custom_gpg:
                Expect.enter(connection, "y")
                Expect.expect(
                    connection,
                    "Enter the absolute path to the public key of the GPG keypair:"
                )
                Expect.enter(connection, custom_gpg)
                Expect.expect(
                    connection,
                    "Would you like to enter another public key\? \(y/n\)")
                Expect.enter(connection, "n")
                checklist.append("Custom GPG Keys: '" + custom_gpg + "'")
            else:
                Expect.enter(connection, "n")
                checklist.append("Custom GPG Keys: \(None\)")
        else:
            Expect.enter(connection, "n")
            checklist.append("GPG Check No")
            checklist.append("Red Hat GPG Key: No")

        RHUIManager.proceed_with_check(
            connection, "The following repository will be created:", checklist)
        RHUIManager.quit(connection, "Successfully created repository")
    def add_custom_repo(connection, reponame, displayname="", path="", checksum_alg="2", entitlement="y", entitlement_path="", redhat_gpg="y", custom_gpg=None):
        '''
        create a new custom repository
        '''
        RHUIManager.screen(connection, "repo")
        Expect.enter(connection, "c")
        Expect.expect(connection, "Unique ID for the custom repository.*:")
        Expect.enter(connection, reponame)
        checklist = ["ID: " + reponame]
        Expect.expect(connection, "Display name for the custom repository.*:")
        Expect.enter(connection, displayname)
        if displayname != "":
            checklist.append("Name: " + displayname)
        else:
            checklist.append("Name: " + reponame)
        Expect.expect(connection, "Path at which the repository will be served.*:")
        Expect.enter(connection, path)
        if path != "":
            path_real = path
        else:
            path_real = reponame
        checklist.append("Path: " + path_real)
        Expect.expect(connection, "Enter value.*:")
        Expect.enter(connection, checksum_alg)
        Expect.expect(connection, "Should the repository require an entitlement certificate to access\? \(y/n\)")
        Expect.enter(connection, entitlement)
        if entitlement == "y":
            Expect.expect(connection, "Path that should be used when granting an entitlement for this repository.*:")
            Expect.enter(connection, entitlement_path)
            if entitlement_path != "":
                checklist.append("Entitlement: " + entitlement_path)
            else:
                educated_guess, replace_count = re.subn("(i386|x86_64)", "$basearch", path_real)
                if replace_count > 1:
                    # bug 815975
                    educated_guess = path_real
                checklist.append("Entitlement: " + educated_guess)
        Expect.expect(connection, "packages are signed by a GPG key\? \(y/n\)")
        if redhat_gpg == "y" or custom_gpg:
            Expect.enter(connection, "y")
            checklist.append("GPG Check Yes")
            Expect.expect(connection, "Will the repository be used to host any Red Hat GPG signed content\? \(y/n\)")
            Expect.enter(connection, redhat_gpg)
            if redhat_gpg == "y":
                checklist.append("Red Hat GPG Key: Yes")
            else:
                checklist.append("Red Hat GPG Key: No")
            Expect.expect(connection, "Will the repository be used to host any custom GPG signed content\? \(y/n\)")
            if custom_gpg:
                Expect.enter(connection, "y")
                Expect.expect(connection, "Enter the absolute path to the public key of the GPG keypair:")
                Expect.enter(connection, custom_gpg)
                Expect.expect(connection, "Would you like to enter another public key\? \(y/n\)")
                Expect.enter(connection, "n")
                checklist.append("Custom GPG Keys: '" + custom_gpg + "'")
            else:
                Expect.enter(connection, "n")
                checklist.append("Custom GPG Keys: \(None\)")
        else:
            Expect.enter(connection, "n")
            checklist.append("GPG Check No")
            checklist.append("Red Hat GPG Key: No")

        RHUIManager.proceed_with_check(connection, "The following repository will be created:", checklist)
        RHUIManager.quit(connection, "Successfully created repository")
    def info(connection, clusterlist):
        '''
        display detailed information on a CDS clusters

        @param clusterlist - list of clusters to examine
        @returns a list of Cds instances
        '''
        RHUIManager.screen(connection, "cds")
        Expect.enter(connection, "i")
        RHUIManager.select(connection, clusterlist)
        pattern = re.compile('.*-= RHUI CDS Clusters =-(.*)rhui\s* \(cds\)\s* =>',
                re.DOTALL)
        ret = Expect.match(connection, pattern, grouplist=[1])[0]
        reslist = ret.split("\r\n")
        i = 0
        clusterlist = []
        cluster = {}
        while i < len(reslist):
            line = reslist[i]
            # Readling lines and searching for clusters
            if line.strip() != '':
                if line[:2] == '  ' and not line[2:3] in [' ', '-']:
                    # We've found a new cluster!
                    if cluster != {}:
                        clusterlist.append(cluster)
                        cluster = {}
                    cluster['Name'] = line[2:]
                    i += 2
                    while reslist[i][:4] == '    ' or reslist[i] == '':
                        if reslist[i] == '':
                            i += 1
                            continue
                        line = reslist[i].strip()
                        if line == "CDS Instances":
                            # Figuring out cds instances
                            instances = []
                            i += 2
                            while reslist[i].strip() != "":
                                # New cds
                                cds = reslist[i].strip()
                                hostname = reslist[i + 1].strip().split(':')[1].strip()
                                client = reslist[i + 2].strip().split(':')[1].strip()
                                instances.append(RhuiCds(name=reslist[i].strip(), hostname=hostname, client_hostname=client,
                                    description='RHUI CDS',
                                    cluster=cluster['Name']))
                                i += 3
                            cluster['Instances'] = sorted(instances)
                        elif line == "Repositories":
                            # Figuring out repositories
                            repositories = []
                            i += 2
                            while reslist[i].strip() != "":
                                # New repo
                                repo = reslist[i].strip()
                                i += 1
                                if repo == '(None)':
                                    # no repos, continue with next (empty)
                                    # line
                                    continue
                                repositories.append(repo)
                            cluster['Repositories'] = repositories
                            # update all cluster CDSes with appropriate repo
                            # records
                            for cds in cluster['Instances']:
                                cds.repos = repositories
                            break
                        else:
                            i += 1
            i += 1

        if cluster != {}:
            clusterlist.append(cluster)
        cdses = []
        for cluster in clusterlist:
            cdses.extend(cluster['Instances'])
        Expect.enter(connection, 'q')
        return cdses
    def info(connection, clusterlist):
        """
        display detailed information on a CDS clusters

        @param clusterlist - list of clusters to examine
        @returns a list of Cds instances
        """
        RHUIManager.screen(connection, "cds")
        Expect.enter(connection, "i")
        RHUIManager.select(connection, clusterlist)
        pattern = re.compile(".*-= RHUI CDS Clusters =-(.*)rhui\s* \(cds\)\s* =>", re.DOTALL)
        ret = Expect.match(connection, pattern, grouplist=[1])[0]
        reslist = ret.split("\r\n")
        i = 0
        clusterlist = []
        cluster = {}
        while i < len(reslist):
            line = reslist[i]
            # Readling lines and searching for clusters
            if line.strip() != "":
                if line[:2] == "  " and not line[2:3] in [" ", "-"]:
                    # We've found a new cluster!
                    if cluster != {}:
                        clusterlist.append(cluster)
                        cluster = {}
                    cluster["Name"] = line[2:]
                    i += 2
                    while reslist[i][:4] == "    " or reslist[i] == "":
                        if reslist[i] == "":
                            i += 1
                            continue
                        line = reslist[i].strip()
                        if line == "CDS Instances":
                            # Figuring out cds instances
                            instances = []
                            i += 2
                            while reslist[i].strip() != "":
                                # New cds
                                cds = reslist[i].strip()
                                hostname = reslist[i + 1].strip().split(":")[1].strip()
                                client = reslist[i + 2].strip().split(":")[1].strip()
                                instances.append(
                                    RhuiCds(
                                        name=reslist[i].strip(),
                                        hostname=hostname,
                                        client_hostname=client,
                                        description="RHUI CDS",
                                        cluster=cluster["Name"],
                                    )
                                )
                                i += 3
                            cluster["Instances"] = sorted(instances)
                        elif line == "Repositories":
                            # Figuring out repositories
                            repositories = []
                            i += 2
                            while reslist[i].strip() != "":
                                # New repo
                                repo = reslist[i].strip()
                                i += 1
                                if repo == "(None)":
                                    # no repos, continue with next (empty)
                                    # line
                                    continue
                                repositories.append(repo)
                            cluster["Repositories"] = repositories
                            # update all cluster CDSes with appropriate repo
                            # records
                            for cds in cluster["Instances"]:
                                cds.repos = repositories
                            break
                        else:
                            i += 1
            i += 1

        if cluster != {}:
            clusterlist.append(cluster)
        cdses = []
        for cluster in clusterlist:
            cdses.extend(cluster["Instances"])
        Expect.enter(connection, "q")
        return cdses