Python StandalonePrestoInstaller.assert_installed方法代码示例

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_twice(self):
        installer = StandalonePrestoInstaller(self)
        self.upload_topology()
        cmd_output = installer.install()
        expected = self.format_err_msgs_with_internal_hosts(installed_all_hosts_output)

        actual = cmd_output.splitlines()
        self.assertRegexpMatchesLineByLine(actual, expected)

        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

        output = installer.install(pa_raise_error=False)

        self.default_keywords.update(installer.get_keywords())

        with open(os.path.join(LOCAL_RESOURCES_DIR, 'install_twice.txt'),
                  'r') as f:
            expected = f.read()
        expected = self.escape_for_regex(
            self.replace_keywords(expected))

        self.assertRegexpMatchesLineByLine(output.splitlines(),
                                           expected.splitlines())
        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_when_connector_json_exists(self):
        installer = StandalonePrestoInstaller(self, dummy=True)
        topology = {"coordinator": "master",
                    "workers": ["slave1"]}
        self.upload_topology(topology)
        self.cluster.write_content_to_host(
            'connector.name=jmx',
            os.path.join(constants.CONNECTORS_DIR, 'jmx.properties'),
            self.cluster.master
        )

        cmd_output = installer.install()
        expected = ['Deploying rpm on master...',
                    'Deploying rpm on slave1...',
                    'Package deployed successfully on: slave1',
                    'Package installed successfully on: slave1',
                    'Package deployed successfully on: master',
                    'Package installed successfully on: master',
                    'Deploying configuration on: master',
                    'Deploying jmx.properties, tpch.properties '
                    'connector configurations on: master ',
                    'Deploying configuration on: slave1',
                    'Deploying jmx.properties, tpch.properties '
                    'connector configurations on: slave1 ']

        actual = cmd_output.splitlines()
        self.assertEqual(sorted(expected), sorted(actual))

        for container in [self.cluster.master,
                          self.cluster.slaves[0]]:
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)
            self.assert_has_jmx_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
 def assert_common_configs(self, host):
     installer = StandalonePrestoInstaller(self)
     installer.assert_installed(self, host)
     self.assert_file_content(host, '/etc/presto/jvm.config',
                              self.default_jvm_config_)
     self.assert_node_config(host, self.default_node_properties_)
     self.assert_has_default_connector(host)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_interactive_with_hostnames(self):
        installer = StandalonePrestoInstaller(self)
        self.cluster.write_content_to_host(
            'connector.name=jmx',
            os.path.join(constants.CONNECTORS_DIR, 'jmx.properties'),
            self.cluster.master
        )
        rpm_name = installer.copy_presto_rpm_to_master()
        self.write_test_configs(self.cluster)

        cmd_output = self.run_script_from_prestoadmin_dir(
            'echo -e "root\n22\n%(master)s\n%(slave1)s\n" | '
            './presto-admin server install /mnt/presto-admin/%(rpm)s ',
            rpm=rpm_name)

        actual = cmd_output.splitlines()
        expected = [r'Enter user name for SSH connection to all nodes: '
                    r'\[root\] '
                    r'Enter port number for SSH connections to all nodes: '
                    r'\[22\] '
                    r'Enter host name or IP address for coordinator node. '
                    r'Enter an external host name or ip address if this is a '
                    r'multi-node cluster: \[localhost\] '
                    r'Enter host names or IP addresses for worker nodes '
                    r'separated by spaces: '
                    r'\[localhost\] Using rpm_specifier as a local path',
                    r'Package deployed successfully on: ' +
                    self.cluster.internal_master,
                    r'Package installed successfully on: ' +
                    self.cluster.internal_master,
                    r'Package deployed successfully on: ' +
                    self.cluster.internal_slaves[0],
                    r'Package installed successfully on: ' +
                    self.cluster.internal_slaves[0],
                    r'Deploying configuration on: ' +
                    self.cluster.internal_master,
                    r'Deploying jmx.properties, tpch.properties connector '
                    r'configurations on: ' +
                    self.cluster.internal_master,
                    r'Deploying configuration on: ' +
                    self.cluster.internal_slaves[0],
                    r'Deploying jmx.properties, tpch.properties connector '
                    r'configurations on: ' +
                    self.cluster.internal_slaves[0],
                    r'Deploying rpm on .*\.\.\.',
                    r'Deploying rpm on .*\.\.\.',
                    r'Fetching local presto rpm at path: .*',
                    r'Found existing rpm at: .*'
                    ]

        self.assertRegexpMatchesLineByLine(actual, expected)
        for container in [self.cluster.master,
                          self.cluster.slaves[0]]:
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)
            self.assert_has_jmx_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install(self, installer=None):
        if installer is None:
            installer = StandalonePrestoInstaller(self)

        self.upload_topology()

        cmd_output = installer.install()
        expected = installed_all_hosts_output

        actual = cmd_output.splitlines()
        self.assertEqual(sorted(expected), sorted(actual))

        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_with_malformed_connector(self):
        installer = StandalonePrestoInstaller(self, dummy=True)
        self.upload_topology()
        self.cluster.write_content_to_host(
            'connectr.typo:invalid',
            os.path.join(constants.CONNECTORS_DIR, 'jmx.properties'),
            self.cluster.master
        )
        actual_out = installer.install(pa_raise_error=False)
        expected = 'Underlying exception:\n    Catalog configuration ' \
                   'jmx.properties does not contain connector.name'
        self.assertRegexpMatches(actual_out, expected)

        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_non_root_user(self):
        installer = StandalonePrestoInstaller(self)
        self.upload_topology(
            {"coordinator": "master",
             "workers": ["slave1", "slave2", "slave3"],
             "username": "app-admin"}
        )

        rpm_name = installer.copy_presto_rpm_to_master(cluster=self.cluster)
        self.write_test_configs(self.cluster)
        self.run_prestoadmin(
            'server install ' + os.path.join(self.cluster.mount_dir, rpm_name) + ' -p password'
        )

        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_twice(self):
        installer = StandalonePrestoInstaller(self, dummy=True)
        self.test_install(installer=installer)
        output = installer.install(pa_raise_error=False)

        self.default_keywords.update(installer.get_keywords())

        with open(os.path.join(LOCAL_RESOURCES_DIR, 'install_twice.txt'), 'r') \
                as f:
            expected = f.read()
        expected = self.escape_for_regex(
            self.replace_keywords(expected))

        self.assertRegexpMatchesLineByLine(output.splitlines(),
                                           expected.splitlines())
        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_with_java8_home(self):
        installer = StandalonePrestoInstaller(self)

        with relocate_jdk_directory(self.cluster, '/usr') as new_java_home:
            topology = {"coordinator": "master",
                        "workers": ["slave1", "slave2", "slave3"],
                        "java8_home": new_java_home}
            self.upload_topology(topology)

            cmd_output = installer.install()
            expected = self.format_err_msgs_with_internal_hosts(installed_all_hosts_output)

            actual = cmd_output.splitlines()
            self.assertRegexpMatchesLineByLine(actual, expected)

            for host in self.cluster.all_hosts():
                installer.assert_installed(self, host)
                self.assert_has_default_config(host)
                self.assert_has_default_connector(host)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_with_java8_home(self):
        installer = StandalonePrestoInstaller(self)
        new_java_home = relocate_default_java(self.cluster, '/usr')

        topology = {"coordinator": "master",
                    "workers": ["slave1", "slave2", "slave3"],
                    "java8_home": new_java_home}
        self.upload_topology(topology)

        cmd_output = installer.install()
        expected = installed_all_hosts_output

        actual = cmd_output.splitlines()
        self.assertRegexpMatchesLineByLine(actual, expected)

        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_with_java8_home(self):
        installer = StandalonePrestoInstaller(self, dummy=True)
        for container in self.cluster.all_hosts():
            self.cluster.exec_cmd_on_host(container,
                                          "mv /usr/java/jdk1.8.0_40 /usr/")
        topology = {"coordinator": "master",
                    "workers": ["slave1", "slave2", "slave3"],
                    "java8_home": "/usr/jdk1.8.0_40/jre"}
        self.upload_topology(topology)

        cmd_output = installer.install()
        expected = installed_all_hosts_output

        actual = cmd_output.splitlines()
        self.assertEqual(sorted(expected), sorted(actual))

        for container in self.cluster.all_hosts():
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
    def test_install_when_connector_json_exists(self):
        installer = StandalonePrestoInstaller(self)
        topology = {"coordinator": "master",
                    "workers": ["slave1"]}
        self.upload_topology(topology)
        self.cluster.write_content_to_host(
            'connector.name=jmx',
            os.path.join(get_connectors_directory(), 'jmx.properties'),
            self.cluster.master
        )

        cmd_output = installer.install()
        expected = ['Deploying rpm on master...',
                    'Deploying rpm on slave1...',
                    'Package deployed successfully on: slave1',
                    'Package installed successfully on: slave1',
                    'Package deployed successfully on: master',
                    'Package installed successfully on: master',
                    'Deploying configuration on: master',
                    'Deploying jmx.properties, tpch.properties '
                    'connector configurations on: master ',
                    'Deploying configuration on: slave1',
                    'Deploying jmx.properties, tpch.properties '
                    'connector configurations on: slave1 ',
                    'Using rpm_specifier as a local path',
                    'Fetching local presto rpm at path: .*',
                    'Found existing rpm at: .*']

        actual = cmd_output.splitlines()
        self.assertRegexpMatchesLineByLine(actual, expected)

        for container in [self.cluster.master,
                          self.cluster.slaves[0]]:
            installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)
            self.assert_has_jmx_connector(container)

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
class TestPackageInstall(BaseProductTestCase):
    def setUp(self):
        super(TestPackageInstall, self).setUp()
        self.setup_cluster(self.PA_ONLY_CLUSTER)
        self.upload_topology()
        self.installer = StandalonePrestoInstaller(self)

    @attr("smoketest")
    def test_package_install(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin("package install " "/mnt/presto-admin/%(rpm)s", rpm=rpm_name)
        for container in self.cluster.all_hosts():
            self.installer.assert_installed(self, container, msg=output)

    def test_install_coord_using_dash_h(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin("package install /mnt/presto-admin/%(rpm)s -H %(master)s", rpm=rpm_name)
        self.installer.assert_installed(self, self.cluster.master)
        for slave in self.cluster.slaves:
            self.installer.assert_uninstalled(slave, msg=output)

    def test_install_worker_using_dash_h(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin("package install /mnt/presto-admin/%(rpm)s -H %(slave1)s", rpm=rpm_name)

        self.installer.assert_installed(self, self.cluster.slaves[0], msg=output)
        self.installer.assert_uninstalled(self.cluster.master, msg=output)
        self.installer.assert_uninstalled(self.cluster.slaves[1], msg=output)
        self.installer.assert_uninstalled(self.cluster.slaves[2], msg=output)

    def test_install_workers_using_dash_h(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin(
            "package install /mnt/presto-admin/" "%(rpm)s -H %(slave1)s,%(slave2)s", rpm=rpm_name
        )

        self.installer.assert_installed(self, self.cluster.slaves[0], msg=output)
        self.installer.assert_installed(self, self.cluster.slaves[1], msg=output)
        self.installer.assert_uninstalled(self.cluster.master, msg=output)
        self.installer.assert_uninstalled(self.cluster.slaves[2], msg=output)

    def test_install_exclude_coord(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin("package install /mnt/presto-admin/" "%(rpm)s -x %(master)s", rpm=rpm_name)

        self.installer.assert_uninstalled(self.cluster.master, msg=output)
        for slave in self.cluster.slaves:
            self.installer.assert_installed(self, slave, msg=output)

    def test_install_exclude_worker(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin("package install /mnt/presto-admin/" "%(rpm)s -x %(slave1)s", rpm=rpm_name)
        self.installer.assert_uninstalled(self.cluster.slaves[0], msg=output)
        self.installer.assert_installed(self, self.cluster.slaves[1], msg=output)
        self.installer.assert_installed(self, self.cluster.master, msg=output)
        self.installer.assert_installed(self, self.cluster.slaves[2], msg=output)

    def test_install_exclude_workers(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin(
            "package install /mnt/presto-admin/" "%(rpm)s -x %(slave1)s,%(slave2)s", rpm=rpm_name
        )

        self.installer.assert_uninstalled(self.cluster.slaves[0], msg=output)
        self.installer.assert_uninstalled(self.cluster.slaves[1], msg=output)
        self.installer.assert_installed(self, self.cluster.master, msg=output)
        self.installer.assert_installed(self, self.cluster.slaves[2], msg=output)

    def test_install_invalid_path(self):
        rpm_name = self.installer.copy_presto_rpm_to_master()
        cmd_output = self.run_prestoadmin("package install /mnt/presto-admin" "/invalid-path/presto.rpm", rpm=rpm_name)
        error = (
            "\nFatal error: [%s] error: "
            "/mnt/presto-admin/invalid-path/presto.rpm: open failed: "
            "No such file or directory\n\nAborting.\n"
        )
        expected = ""
        for host in self.cluster.all_internal_hosts():
            expected += error % host

        self.assertEqualIgnoringOrder(cmd_output, expected)

    def test_install_no_path_arg(self):
        self.installer.copy_presto_rpm_to_master()
        output = self.run_prestoadmin("package install", raise_error=False)
        self.assertEqual(
            output,
            "Incorrect number of arguments to task.\n\n"
            "Displaying detailed information for task "
            "'package install':\n\n"
            "    Install the rpm package on the cluster\n"
            "    \n    Args:\n"
            "        local_path: Absolute path to the rpm"
            " to be installed\n        "
            "--nodeps (optional): Flag to indicate if "
            "rpm install\n"
            "            should ignore c"
            "hecking package dependencies. Equivalent\n"
            "            to adding --nodeps flag to rpm "
            "-i.\n\n",
#.........这里部分代码省略.........

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
class TestServerInstall(BaseProductTestCase):
    default_workers_config_with_slave1_ = """coordinator=false
discovery.uri=http://slave1:8080
http-server.http.port=8080
query.max-memory-per-node=512MB
query.max-memory=50GB\n"""

    default_coord_config_with_slave1_ = """coordinator=true
discovery-server.enabled=true
discovery.uri=http://slave1:8080
http-server.http.port=8080
node-scheduler.include-coordinator=false
query.max-memory-per-node=512MB
query.max-memory=50GB\n"""

    default_workers_config_regex_ = """coordinator=false
discovery.uri=http:.*:8080
http-server.http.port=8080
query.max-memory-per-node=512MB
query.max-memory=50GB\n"""

    default_coord_config_regex_ = """coordinator=true
discovery-server.enabled=true
discovery.uri=http:.*:8080
http-server.http.port=8080
node-scheduler.include-coordinator=false
query.max-memory-per-node=512MB
query.max-memory=50GB\n"""

    def setUp(self):
        super(TestServerInstall, self).setUp()
        self.setup_cluster(self.PA_ONLY_CLUSTER)
        self.installer = StandalonePrestoInstaller(self)

    def assert_common_configs(self, container):
        self.installer.assert_installed(self, container)
        self.assert_file_content(container, '/etc/presto/jvm.config',
                                 self.default_jvm_config_)
        self.assert_node_config(container, self.default_node_properties_)
        self.assert_has_default_connector(container)

    def assert_installed_with_configs(self, master, slaves):
        self.assert_common_configs(master)
        self.assert_file_content(master,
                                 '/etc/presto/config.properties',
                                 self.default_coord_config_with_slave1_)
        for container in slaves:
            self.assert_common_configs(container)
            self.assert_file_content(container,
                                     '/etc/presto/config.properties',
                                     self.default_workers_config_with_slave1_)

    def assert_installed_with_regex_configs(self, master, slaves):
        self.assert_common_configs(master)
        self.assert_file_content_regex(master,
                                       '/etc/presto/config.properties',
                                       self.default_coord_config_regex_)
        for container in slaves:
            self.assert_common_configs(container)
            self.assert_file_content_regex(container,
                                           '/etc/presto/config.properties',
                                           self.default_workers_config_regex_)

    @attr('smoketest')
    def test_install(self, dummy=False):
        self.upload_topology()

        cmd_output = self.installer.install(dummy)
        expected = installed_all_hosts_output

        actual = cmd_output.splitlines()
        self.assertEqual(sorted(expected), sorted(actual))

        for container in self.cluster.all_hosts():
            self.installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_connector(container)

    def test_install_worker_is_pa_master(self):
        topology = {"coordinator": "slave1",
                    "workers": ["master", "slave2", "slave3"]}
        self.upload_topology(topology)

        cmd_output = self.installer.install(dummy=True)
        expected = install_with_worker_pa_master_out

        actual = cmd_output.splitlines()
        self.assertEqual(sorted(expected), sorted(actual))

        self.assert_installed_with_configs(
            self.cluster.slaves[0],
            [self.cluster.slaves[1],
             self.cluster.slaves[2],
             self.cluster.master])

    def test_install_ext_host_is_pa_master(self):
        topology = {"coordinator": "slave1",
                    "workers": ["slave2", "slave3"]}
        self.upload_topology(topology)

#.........这里部分代码省略.........

# 需要导入模块: from tests.product.standalone.presto_installer import StandalonePrestoInstaller [as 别名]
# 或者: from tests.product.standalone.presto_installer.StandalonePrestoInstaller import assert_installed [as 别名]
class TestServerUpgrade(BaseProductTestCase):

    def setUp(self):
        super(TestServerUpgrade, self).setUp()
        self.setup_cluster(NoHadoopBareImageProvider(), STANDALONE_PRESTO_CLUSTER)
        self.dummy_installer = StandalonePrestoInstaller(
            self, (os.path.join(prestoadmin.main_dir, 'tests', 'product',
                                'resources'), 'dummy-rpm.rpm'))
        self.real_installer = StandalonePrestoInstaller(self)

    def start_and_assert_started(self):
        cmd_output = self.run_prestoadmin('server start')
        process_per_host = self.get_process_per_host(cmd_output.splitlines())
        self.assert_started(process_per_host)

    #
    # The dummy RPM is not guaranteed to have any functionality beyond not
    # including any real payload and adding the random README file. It's a
    # hacky one-off that satisfies the requirement of having *something* to
    # upgrade to without downloading another copy of the real RPM. This is NOT
    # the place to test functionality that the presto-server-rpm normally
    # provides, because the dummy rpm probably doesn't provide it, or worse,
    # provides an old and/or broken version of it.
    #
    def assert_upgraded_to_dummy_rpm(self, hosts):
        for container in hosts:
            # Still should have the same configs
            self.dummy_installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_catalog(container)

            # However, dummy_rpm.rpm removes /usr/lib/presto/lib and
            # /usr/lib/presto/lib/plugin
            self.assert_path_removed(container, '/usr/lib/presto/lib')
            self.assert_path_removed(container, '/usr/lib/presto/lib/plugin')

            # And adds /usr/lib/presto/README.txt
            self.assert_path_exists(container, '/usr/lib/presto/README.txt')

            # And modifies the text of the readme in
            # /usr/shared/doc/presto/README.txt
            self.assert_file_content_regex(
                container,
                '/usr/shared/doc/presto/README.txt',
                r'.*New line of text here.$'
            )

    @attr('smoketest')
    def test_upgrade(self):
        self.start_and_assert_started()

        self.run_prestoadmin('configuration deploy')
        for container in self.cluster.all_hosts():
            self.real_installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_catalog(container)

        path_on_cluster = self.copy_upgrade_rpm_to_cluster()
        self.upgrade_and_assert_success(path_on_cluster)

    def upgrade_and_assert_success(self, path_on_cluster, extra_arguments=''):
        self.run_prestoadmin('server upgrade ' + path_on_cluster + extra_arguments)
        self.assert_upgraded_to_dummy_rpm(self.cluster.all_hosts())

    def copy_upgrade_rpm_to_cluster(self):
        rpm_name = self.dummy_installer.copy_presto_rpm_to_master()
        return os.path.join(self.cluster.rpm_cache_dir, rpm_name)

    def test_upgrade_fails_given_directory(self):
        dir_on_cluster = '/opt/prestoadmin'
        self.assertRaisesRegexp(
            OSError,
            'RPM file not found at %s.' % dir_on_cluster,
            self.run_prestoadmin,
            'server upgrade ' + dir_on_cluster
        )

    def test_upgrade_works_with_symlink(self):
        self.run_prestoadmin('configuration deploy')
        for container in self.cluster.all_hosts():
            self.real_installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_catalog(container)

        path_on_cluster = self.copy_upgrade_rpm_to_cluster()
        symlink = os.path.join(get_install_directory(), 'link.rpm')
        self.cluster.exec_cmd_on_host(self.cluster.master, 'ln -s %s %s'
                                      % (path_on_cluster, symlink))
        self.upgrade_and_assert_success(symlink)

    def test_configuration_preserved_on_upgrade(self):
        book_content = 'Call me Ishmael ... FINIS'
        book_path = '/etc/presto/moby_dick_abridged'
        self.run_prestoadmin('configuration deploy')
        big_files = {}
        for container in self.cluster.all_hosts():
            self.real_installer.assert_installed(self, container)
            self.assert_has_default_config(container)
            self.assert_has_default_catalog(container)

#.........这里部分代码省略.........