Example #1
0
 def test_agent_is_not_run(self, test_local):
     test_local.side_effect = [
         create_attribute_string(
             'The agent has no identities', succeeded=True),
         create_attribute_string('Agent pid 1234\n/foo/bar',
                                 succeeded=True),
     ]
     utils.forward_agent(['test_key_1', 'test_key_2'])
     self.assertFalse(
         utils.ensure_ssh_key_added(['test_key_1', 'test_key_2']))
Example #2
0
 def test_agent_is_not_run(self, test_local):
     test_local.side_effect = [
         create_attribute_string('The agent has no identities',
                                 succeeded=True),
         create_attribute_string('Agent pid 1234\n/foo/bar',
                                 succeeded=True),
     ]
     utils.forward_agent(['test_key_1', 'test_key_2'])
     self.assertFalse(
         utils.ensure_ssh_key_added(['test_key_1', 'test_key_2']))
Example #3
0
 def test_agent_is_already_run_w_keys(self, test_local):
     test_local.side_effect = [
         create_attribute_string(
             '4096 de:3b:90:e1:3e:f7:3e:f5:4b:e3:ca:9f:1c:68:45:fb '
             'test_key_1 (RSA)\n'
             '2048 8a:f7:05:14:f7:3a:9b:28:70:d8:95:6e:df:e9:78:c7 '
             'test_key_2 (RSA)\n',
             succeeded=True),
     ]
     utils.forward_agent(['test_key_1', 'test_key_2'])
     self.assertTrue(
         utils.ensure_ssh_key_added(['test_key_1', 'test_key_2']))
Example #4
0
 def test_agent_is_already_run_w_keys(self, test_local):
     test_local.side_effect = [
         create_attribute_string(
             '4096 de:3b:90:e1:3e:f7:3e:f5:4b:e3:ca:9f:1c:68:45:fb '
             'test_key_1 (RSA)\n'
             '2048 8a:f7:05:14:f7:3a:9b:28:70:d8:95:6e:df:e9:78:c7 '
             'test_key_2 (RSA)\n',
             succeeded=True),
     ]
     utils.forward_agent(['test_key_1', 'test_key_2'])
     self.assertTrue(
         utils.ensure_ssh_key_added(['test_key_1', 'test_key_2']))
Example #5
0
 def test_agent_is_already_run_w_another_key(self, test_local):
     test_local.return_value = local(
         "echo test_session_num test_fingerprint test_key test_type\n",
         capture=True)
     test_local.side_effect = [
         create_attribute_string(
             '4096 de:3b:90:e1:3e:f7:3e:f5:4b:e3:ca:9f:1c:68:45:fb '
             'test_key_1 (RSA)\n',
             succeeded=True),
         create_attribute_string('Agent pid 1234\n/foo/bar',
                                 succeeded=True),
     ]
     utils.forward_agent(['test_key_1', 'test_key_2'])
     self.assertFalse(
         utils.ensure_ssh_key_added(['test_key_1', 'test_key_2']))
Example #6
0
 def convert_file_to_raw(host, disk_format, filepath):
     with settings(host_string=host,
                   connection_attempts=env.connection_attempts):
         with forward_agent(env.key_filename):
             run("qemu-img convert -f %s -O raw %s %s.tmp" %
                 (disk_format, filepath, filepath))
             run("mv -f %s.tmp %s" % (filepath, filepath))
Example #7
0
def transfer_file_to_file(src_cloud,
                          dst_cloud,
                          host_src,
                          host_dst,
                          path_src,
                          path_dst,
                          cfg_migrate):
    # TODO: Delete after transport_db_via_ssh action rewriting
    LOG.debug("| | copy file")
    ssh_ip_src = src_cloud.cloud_config.cloud.ssh_host
    ssh_ip_dst = dst_cloud.cloud_config.cloud.ssh_host
    with settings(host_string=ssh_ip_src,
                  connection_attempts=env.connection_attempts):
        with utils.forward_agent(cfg_migrate.key_filename):
            with utils.up_ssh_tunnel(host_dst, ssh_ip_dst, ssh_ip_src) as port:
                if cfg_migrate.file_compression == "dd":
                    run(("ssh -oStrictHostKeyChecking=no %s 'dd bs=1M " +
                         "if=%s' | ssh -oStrictHostKeyChecking=no " +
                         "-p %s localhost 'dd bs=1M of=%s'") %
                        (host_src, path_src, port, path_dst))
                elif cfg_migrate.file_compression == "gzip":
                    run(("ssh -oStrictHostKeyChecking=no " +
                         "%s 'gzip -%s -c %s' " +
                         "| ssh -oStrictHostKeyChecking=no -p %s localhost " +
                         "'gunzip | dd bs=1M of=%s'") %
                        (host_src, cfg_migrate.level_compression,
                         path_src, port, path_dst))
Example #8
0
 def test_agent_is_already_run_w_another_key(self, test_local):
     test_local.return_value = local(
         "echo test_session_num test_fingerprint test_key test_type\n",
         capture=True
     )
     test_local.side_effect = [
         create_attribute_string(
             '4096 de:3b:90:e1:3e:f7:3e:f5:4b:e3:ca:9f:1c:68:45:fb '
             'test_key_1 (RSA)\n',
             succeeded=True),
         create_attribute_string('Agent pid 1234\n/foo/bar',
                                 succeeded=True),
     ]
     utils.forward_agent(['test_key_1', 'test_key_2'])
     self.assertFalse(
         utils.ensure_ssh_key_added(['test_key_1', 'test_key_2']))
 def delete_remote_file_on_compute(path_file, host_cloud,
                                   host_instance):
     with settings(host_string=host_cloud,
                   connection_attempts=env.connection_attempts):
         with forward_agent(env.key_filename):
             run("ssh -oStrictHostKeyChecking=no %s  'rm -rf %s'" %
                 (host_instance, path_file))
Example #10
0
    def run(self, image_id=None, base_filename=None, **kwargs):
        cfg = self.cloud.cloud_config.cloud
        ssh_attempts = self.cloud.cloud_config.migrate.ssh_connection_attempts

        with settings(host_string=cfg.ssh_host,
                      connection_attempts=ssh_attempts):
            with forward_agent(env.key_filename):
                cmd = image.glance_image_download_cmd(cfg, image_id,
                                                      base_filename)
                run(cmd)
    def run(self, image_id=None, base_filename=None, **kwargs):
        cfg = self.cloud.cloud_config.cloud
        ssh_attempts = self.cloud.cloud_config.migrate.ssh_connection_attempts

        with settings(host_string=cfg.ssh_host,
                      connection_attempts=ssh_attempts):
            with forward_agent(env.key_filename):
                cmd = image.glance_image_download_cmd(cfg, image_id,
                                                      base_filename)
                run(cmd)
Example #12
0
    def get_mac_addresses(self, instance):
        compute_node = getattr(instance, nova_compute.INSTANCE_HOST_ATTRIBUTE)
        libvirt_name = getattr(instance, 'OS-EXT-SRV-ATTR:instance_name')
        ssh_attempts = self.config.migrate.ssh_connection_attempts

        with settings(host_string=self.config.ssh_host,
                      connection_attempts=ssh_attempts):
            with forward_agent(env.key_filename):
                cmd = "virsh dumpxml %s | grep 'mac address' | " \
                      "cut -d\\' -f2" % libvirt_name
                out = run("ssh -oStrictHostKeyChecking=no %s %s" %
                          (compute_node, cmd))
                mac_addresses = out.split()
        mac_iter = iter(mac_addresses)
        return mac_iter
Example #13
0
    def get_mac_addresses(self, instance):
        compute_node = getattr(instance, nova_compute.INSTANCE_HOST_ATTRIBUTE)
        libvirt_name = getattr(instance, 'OS-EXT-SRV-ATTR:instance_name')
        ssh_attempts = self.config.migrate.ssh_connection_attempts

        with settings(host_string=self.config.ssh_host,
                      connection_attempts=ssh_attempts):
            with forward_agent(env.key_filename):
                cmd = "virsh dumpxml %s | grep 'mac address' | " \
                      "cut -d\\' -f2" % libvirt_name
                out = run("ssh -oStrictHostKeyChecking=no %s %s" %
                          (compute_node, cmd))
                mac_addresses = out.split()
        mac_iter = iter(mac_addresses)
        return mac_iter
Example #14
0
    def transfer(self, data):
        ssh_ip_src = self.src_cloud.cloud_config.cloud.ssh_host
        ssh_ip_dst = self.dst_cloud.cloud_config.cloud.ssh_host
        with utils.forward_agent(api.env.key_filename), \
                utils.up_ssh_tunnel(data['host_dst'], ssh_ip_dst,
                                    ssh_ip_src) as port:
            dd = cmd_cfg.dd_cmd_of
            ssh_cmd = cmd_cfg.ssh_cmd_port
            rbd_export = rbd_util.RbdUtil.rbd_export_cmd

            ssh_dd = ssh_cmd(port, 'localhost', dd)

            process = rbd_export >> ssh_dd
            process = process(data['path_src'], '-', '1M', data['path_dst'])

            self.src_cloud.ssh_util.execute(process)
Example #15
0
    def transfer(self, data):
        ssh_ip_src = self.src_cloud.cloud_config.cloud.ssh_host
        ssh_ip_dst = self.dst_cloud.cloud_config.cloud.ssh_host
        with utils.forward_agent(api.env.key_filename), \
                utils.up_ssh_tunnel(data['host_dst'], ssh_ip_dst,
                                    ssh_ip_src) as port:
            dd = cmd_cfg.dd_cmd_of
            ssh_cmd = cmd_cfg.ssh_cmd_port
            rbd_export = rbd_util.RbdUtil.rbd_export_cmd

            ssh_dd = ssh_cmd(port, 'localhost', dd)

            process = rbd_export >> ssh_dd
            process = process(data['path_src'], '-', '1M',
                              data['path_dst'])

            self.src_cloud.ssh_util.execute(process)
Example #16
0
    def run(self, cmd, **kwargs):
        abort_exception = None
        if not self.ignore_errors:
            abort_exception = RemoteExecutionError

        if kwargs:
            cmd = cmd.format(**kwargs)

        ssh_attempts = CONF.migrate.ssh_connection_attempts

        if self.sudo and self.user != 'root':
            run = api.sudo
        else:
            run = api.run

        if self.remote_tunnel is not None:
            run = self._run_with_remote_tunnel(run)

        if self.mute_stdout:
            run = self._run_with_mute_stdout(run)

        with api.settings(warn_only=self.ignore_errors,
                          host_string=self.host,
                          user=self.user,
                          password=self.password,
                          abort_exception=abort_exception,
                          reject_unkown_hosts=False,
                          combine_stderr=False,
                          connection_attempts=ssh_attempts,
                          command_timeout=self.timeout,
                          gateway=self.gateway):
            with utils.forward_agent(self.key):
                LOG.debug("running '%s' on '%s' host as user '%s'", cmd,
                          self.host, self.user)
                try:
                    result = run(cmd)
                except fabric_exceptions.NetworkError as e:
                    raise RemoteExecutionError(e.message)
                if not self.mute_stdout:
                    LOG.debug('[%s] Command "%s" result: %s', self.host, cmd,
                              result)
                return result
Example #17
0
    def run(self, cmd, **kwargs):
        abort_exception = None
        if not self.ignore_errors:
            abort_exception = RemoteExecutionError

        if kwargs:
            cmd = cmd.format(**kwargs)

        ssh_attempts = CONF.migrate.ssh_connection_attempts

        if self.sudo and self.user != 'root':
            run = api.sudo
        else:
            run = api.run

        if self.remote_tunnel is not None:
            run = self._run_with_remote_tunnel(run)

        if self.mute_stdout:
            run = self._run_with_mute_stdout(run)

        with api.settings(warn_only=self.ignore_errors,
                          host_string=self.host,
                          user=self.user,
                          password=self.password,
                          abort_exception=abort_exception,
                          reject_unkown_hosts=False,
                          combine_stderr=False,
                          connection_attempts=ssh_attempts,
                          command_timeout=self.timeout,
                          gateway=self.gateway):
            with utils.forward_agent(self.key):
                LOG.debug("running '%s' on '%s' host as user '%s'",
                          cmd, self.host, self.user)
                try:
                    result = run(cmd)
                except fabric_exceptions.NetworkError as e:
                    raise RemoteExecutionError(e.message)
                if not self.mute_stdout:
                    LOG.debug('[%s] Command "%s" result: %s',
                              self.host, cmd, result)
                return result
Example #18
0
    def transfer(self, data):
        ssh_ip_src = self.src_cloud.cloud_config.cloud.ssh_host
        ssh_ip_dst = self.dst_cloud.cloud_config.cloud.ssh_host
        action_utils.delete_file_from_rbd(ssh_ip_dst, data['path_dst'])
        with api.settings(host_string=ssh_ip_src,
                          connection_attempts=api.env.connection_attempts), \
                utils.forward_agent(api.env.key_filename):
            rbd_import = rbd_util.RbdUtil.rbd_import_cmd
            ssh_cmd_dst = cmd_cfg.ssh_cmd
            ssh_dst = ssh_cmd_dst(ssh_ip_dst, rbd_import)

            dd = cmd_cfg.dd_cmd_if
            ssh_cmd_src = cmd_cfg.ssh_cmd
            ssh_src = ssh_cmd_src(data['host_src'], dd)

            process = ssh_src >> ssh_dst
            process = process('1M', data['path_src'], '2', '-',
                              data['path_dst'])

            self.src_cloud.ssh_util.execute(process)
Example #19
0
    def transfer(self, data):
        if CONF.migrate.direct_transfer:
            return self.transfer_direct(data)

        LOG.debug("| | copy file")
        ssh_ip_src = self.src_cloud.cloud_config.cloud.ssh_host
        ssh_ip_dst = self.dst_cloud.cloud_config.cloud.ssh_host
        # pylint: disable=not-callable
        with utils.forward_agent(CONF.migrate.key_filename), \
                utils.up_ssh_tunnel(data['host_dst'], ssh_ip_dst,
                                    ssh_ip_src) as port:
            if CONF.migrate.file_compression == "dd":
                dd_dst = cmd_cfg.dd_cmd_of
                ssh_cmd_dst = cmd_cfg.ssh_cmd_port
                ssh_dst = ssh_cmd_dst(port, 'localhost', dd_dst)

                dd_src = cmd_cfg.dd_cmd_if
                ssh_cmd_src = cmd_cfg.ssh_cmd
                ssh_src = ssh_cmd_src(data['host_src'], dd_src)

                process = ssh_src >> ssh_dst
                process = process('1M', data['path_src'], '1M',
                                  data['path_dst'])

                self.src_cloud.ssh_util.execute(process)

            elif CONF.migrate.file_compression == "gzip":
                dd = cmd_cfg.dd_cmd_of
                gunzip_dd = cmd_cfg.gunzip_cmd >> dd
                ssh_cmd_dst = cmd_cfg.ssh_cmd_port
                ssh_dst = ssh_cmd_dst(port, 'localhost', gunzip_dd)

                gzip_cmd = cmd_cfg.gzip_cmd
                ssh_cmd_src = cmd_cfg.ssh_cmd
                ssh_src = ssh_cmd_src(data['host_src'], gzip_cmd)

                process = ssh_src >> ssh_dst
                process = process(CONF.migrate.level_compression,
                                  data['path_src'], '1M', data['path_dst'])

                self.src_cloud.ssh_util.execute(process)
    def run(self, info=None, **kwargs):
        cfg = self.cloud.cloud_config.cloud
        ssh_attempts = self.cloud.cloud_config.migrate.ssh_connection_attempts

        for instance_id, instance in info[utl.INSTANCES_TYPE].iteritems():
            inst = info[utl.INSTANCES_TYPE][instance_id][utl.INSTANCE_BODY]
            image_id = inst['image_id']

            base_file = "/tmp/%s" % ("temp%s_base" % instance_id)
            diff_file = "/tmp/%s" % ("temp%s" % instance_id)

            with settings(host_string=cfg.ssh_host,
                          connection_attempts=ssh_attempts):
                with forward_agent(env.key_filename):
                    cmd = image.glance_image_download_cmd(
                        cfg, image_id, base_file)
                    run(cmd)
            instance[DIFF][PATH_DST] = diff_file
            instance[DIFF][HOST_DST] = \
                self.dst_cloud.cloud_config.cloud.ssh_host
        return {'info': info}
    def transfer(
            self,
            data,  # pylint: disable=arguments-differ
            snapshot=None,
            snapshot_type=1):
        host_src = data.get('host_src',
                            self.src_cloud.cloud_config.cloud.ssh_host)
        host_dst = data.get('host_dst',
                            self.dst_cloud.cloud_config.cloud.ssh_host)
        with api.settings(host_string=host_src,
                          connection_attempts=api.env.connection_attempts), \
                utils.forward_agent(api.env.key_filename):
            rbd_import_diff = rbd_util.RbdUtil.rbd_import_diff_cmd
            ssh_cmd = cmd_cfg.ssh_cmd
            ssh_rbd_import_diff = ssh_cmd(host_dst, rbd_import_diff)

            if snapshot:
                process_params = [
                    snapshot['name'], data['path_src'], '-', '-',
                    data['path_dst']
                ]
                if snapshot_type == 1:
                    rbd_export_diff = rbd_util.RbdUtil.rbd_export_diff_snap_cmd
                elif snapshot_type == 2:
                    rbd_export_diff = \
                        rbd_util.RbdUtil.rbd_export_diff_from_snap_cmd
                    process_params.insert(0, snapshot['prev_snapname'])
                elif snapshot_type == 3:
                    rbd_export_diff = rbd_util.RbdUtil.rbd_export_diff_from_cmd
                else:
                    raise ValueError("Unsupported snapshot type %s",
                                     snapshot_type)
            else:
                rbd_export_diff = rbd_util.RbdUtil.rbd_export_diff_cmd
                process_params = [data['path_src'], '-', '-', data['path_dst']]

            process = rbd_export_diff >> ssh_rbd_import_diff
            process = process(*process_params)

            self.src_cloud.ssh_util.execute(process)
Example #22
0
def transfer_file_to_file(src_cloud, dst_cloud, host_src, host_dst, path_src,
                          path_dst, cfg_migrate):
    # TODO: Delete after transport_db_via_ssh action rewriting
    LOG.debug("| | copy file")
    ssh_ip_src = src_cloud.cloud_config.cloud.ssh_host
    ssh_ip_dst = dst_cloud.cloud_config.cloud.ssh_host
    with settings(host_string=ssh_ip_src,
                  connection_attempts=env.connection_attempts):
        with utils.forward_agent(cfg_migrate.key_filename):
            with utils.up_ssh_tunnel(host_dst, ssh_ip_dst, ssh_ip_src) as port:
                if cfg_migrate.file_compression == "dd":
                    run(("ssh -oStrictHostKeyChecking=no %s 'dd bs=1M " +
                         "if=%s' | ssh -oStrictHostKeyChecking=no " +
                         "-p %s localhost 'dd bs=1M of=%s'") %
                        (host_src, path_src, port, path_dst))
                elif cfg_migrate.file_compression == "gzip":
                    run(("ssh -oStrictHostKeyChecking=no " +
                         "%s 'gzip -%s -c %s' " +
                         "| ssh -oStrictHostKeyChecking=no -p %s localhost " +
                         "'gunzip | dd bs=1M of=%s'") %
                        (host_src, cfg_migrate.level_compression, path_src,
                         port, path_dst))
Example #23
0
    def transfer_direct(self, data):
        ssh_attempts = CONF.migrate.ssh_connection_attempts
        LOG.debug("| | copy file")
        if CONF.src.ssh_user != 'root' or CONF.dst.ssh_user != 'root':
            LOG.critical("This operation needs 'sudo' access rights, that is "
                         "currently not implemented in this driver. "
                         "Please use the default driver from "
                         "cloudferry.lib/copy_engines/.")
        with api.settings(host_string=data['host_src'],
                          connection_attempts=ssh_attempts), \
                utils.forward_agent(CONF.migrate.key_filename):
            if CONF.migrate.file_compression == "dd":
                dd_dst = cmd_cfg.dd_cmd_of
                ssh_cmd_dst = cmd_cfg.ssh_cmd
                ssh_dst = ssh_cmd_dst(data['host_dst'], dd_dst)

                dd_src = cmd_cfg.dd_cmd_if

                process = dd_src >> ssh_dst
                process = process('1M', data['path_src'], '1M',
                                  data['path_dst'])

                self.src_cloud.ssh_util.execute(process,
                                                host_exec=data['host_src'])

            elif CONF.migrate.file_compression == "gzip":
                dd = cmd_cfg.dd_cmd_of
                gunzip_dd = cmd_cfg.gunzip_cmd >> dd
                ssh_cmd_dst = cmd_cfg.ssh_cmd
                ssh_dst = ssh_cmd_dst(data['host_dst'], gunzip_dd)

                gzip_cmd = cmd_cfg.gzip_cmd

                process = gzip_cmd >> ssh_dst
                process = process(CONF.migrate.level_compression,
                                  data['path_src'], '1M', data['path_dst'])

                self.src_cloud.ssh_util.execute(process,
                                                host_exec=data['host_src'])
    def run(self, info=None, **kwargs):
        cfg = self.cloud.cloud_config.cloud
        ssh_attempts = self.cloud.cloud_config.migrate.ssh_connection_attempts

        for instance_id, instance in info[utl.INSTANCES_TYPE].iteritems():
            inst = info[utl.INSTANCES_TYPE][instance_id][utl.INSTANCE_BODY]
            image_id = inst['image_id']

            base_file = "/tmp/%s" % ("temp%s_base" % instance_id)
            diff_file = "/tmp/%s" % ("temp%s" % instance_id)

            with settings(host_string=cfg.ssh_host,
                          connection_attempts=ssh_attempts):
                with forward_agent(env.key_filename):
                    cmd = image.glance_image_download_cmd(cfg, image_id,
                                                          base_file)
                    run(cmd)
            instance[DIFF][PATH_DST] = diff_file
            instance[DIFF][HOST_DST] = \
                self.dst_cloud.cloud_config.cloud.ssh_host
        return {
            'info': info
        }
Example #25
0
    def transfer(self, data,  # pylint: disable=arguments-differ
                 snapshot=None,
                 snapshot_type=1):
        host_src = data.get('host_src',
                            self.src_cloud.cloud_config.cloud.ssh_host)
        host_dst = data.get('host_dst',
                            self.dst_cloud.cloud_config.cloud.ssh_host)
        with api.settings(host_string=host_src,
                          connection_attempts=api.env.connection_attempts), \
                utils.forward_agent(api.env.key_filename):
            rbd_import_diff = rbd_util.RbdUtil.rbd_import_diff_cmd
            ssh_cmd = cmd_cfg.ssh_cmd
            ssh_rbd_import_diff = ssh_cmd(host_dst, rbd_import_diff)

            if snapshot:
                process_params = [snapshot['name'], data['path_src'], '-', '-',
                                  data['path_dst']]
                if snapshot_type == 1:
                    rbd_export_diff = rbd_util.RbdUtil.rbd_export_diff_snap_cmd
                elif snapshot_type == 2:
                    rbd_export_diff = \
                        rbd_util.RbdUtil.rbd_export_diff_from_snap_cmd
                    process_params.insert(0, snapshot['prev_snapname'])
                elif snapshot_type == 3:
                    rbd_export_diff = rbd_util.RbdUtil.rbd_export_diff_from_cmd
                else:
                    raise ValueError("Unsupported snapshot type %s",
                                     snapshot_type)
            else:
                rbd_export_diff = rbd_util.RbdUtil.rbd_export_diff_cmd
                process_params = [data['path_src'], '-', '-', data['path_dst']]

            process = rbd_export_diff >> ssh_rbd_import_diff
            process = process(*process_params)

            self.src_cloud.ssh_util.execute(process)
Example #26
0
 def execute_on_inthost(self, runner, cmd, host):
     with utils.forward_agent(self.config_migrate.key_filename):
         return runner.run(str(cmd_cfg.ssh_cmd(host, str(cmd))))
Example #27
0
    def run(self, **kwargs):
        cfg = self.cloud.cloud_config.cloud
        runner = remote_runner.RemoteRunner(cfg.ssh_host, cfg.ssh_user)

        temp_dir_name = os.popen('mktemp -dt check_band_XXXX').read().rstrip()
        temp_file_name = str(uuid.uuid4())

        claimed_bandw = self.cloud.cloud_config.initial_check.claimed_bandwidth
        test_file_size = self.cloud.cloud_config.initial_check.test_file_size

        ssh_user = self.cloud.cloud_config.cloud.ssh_user

        factor = self.cloud.cloud_config.initial_check.factor
        req_bandwidth = claimed_bandw * factor

        local_file_path = os.path.join(temp_dir_name, temp_file_name)
        remote_file_path = os.path.join(temp_dir_name,
                                        temp_file_name)

        scp_upload = cmd_cfg.scp_cmd(ssh_util.get_cipher_option(),
                                     '',
                                     ssh_user,
                                     cfg.ssh_host,
                                     remote_file_path,
                                     temp_dir_name)

        scp_download = cmd_cfg.scp_cmd(ssh_util.get_cipher_option(),
                                       local_file_path,
                                       ssh_user,
                                       cfg.ssh_host,
                                       temp_dir_name,
                                       '')

        with files.RemoteDir(runner, temp_dir_name):
            try:
                with utils.forward_agent(env.key_filename):
                    dd_command = cmd_cfg.dd_full('/dev/zero',
                                                 remote_file_path,
                                                 1,
                                                 0,
                                                 test_file_size)
                    self.cloud.ssh_util.execute(dd_command)

                    LOG.info("Checking upload speed... Wait please.")
                    period_upload = utils.timer(subprocess.call,
                                                str(scp_upload),
                                                shell=True)

                    LOG.info("Checking download speed... Wait please.")
                    period_download = utils.timer(subprocess.call,
                                                  str(scp_download),
                                                  shell=True)
            finally:
                if len(temp_dir_name) > 1:
                    os.system("rm -rf {}".format(temp_dir_name))
                else:
                    raise RuntimeError('Wrong dirname %s, stopping' %
                                       temp_dir_name)

        # To have Megabits per second
        upload_speed = test_file_size / period_upload * 8
        download_speed = test_file_size / period_download * 8

        if upload_speed < req_bandwidth or download_speed < req_bandwidth:
            raise RuntimeError('Bandwidth is not OK. '
                               'Claimed bandwidth: %s Mb/s. '
                               'Required speed: %s Mb/s. '
                               'Actual upload speed: %.2f Mb/s. '
                               'Actual download speed: %.2f Mb/s. '
                               'Aborting migration...' %
                               (claimed_bandw,
                                req_bandwidth,
                                upload_speed,
                                download_speed))

        LOG.info("Bandwith is OK. "
                 "Required speed: %.2f Mb/s. "
                 "Upload speed: %.2f Mb/s. "
                 "Download speed: %.2f Mb/s",
                 req_bandwidth,
                 upload_speed,
                 download_speed)
Example #28
0
def delete_file_from_rbd(ssh_ip, file_path):
    with settings(host_string=ssh_ip,
                  connection_attempts=env.connection_attempts):
        with utils.forward_agent(env.key_filename):
            run("rbd rm %s" % file_path)
Example #29
0
 def execute_on_inthost(self, runner, cmd, host):
     with utils.forward_agent(self.config_migrate.key_filename):
         return runner.run(str(cmd_cfg.ssh_cmd(host, str(cmd))))
Example #30
0
def delete_file_from_rbd(ssh_ip, file_path):
    with settings(host_string=ssh_ip,
                  connection_attempts=env.connection_attempts):
        with utils.forward_agent(env.key_filename):
            run("rbd rm %s" % file_path)
 def delete_remote_file_on_compute(path_file, host_cloud, host_instance):
     with settings(host_string=host_cloud,
                   connection_attempts=env.connection_attempts):
         with forward_agent(env.key_filename):
             run("ssh -oStrictHostKeyChecking=no %s  'rm -rf %s'" %
                 (host_instance, path_file))