def get_vm_config_modified_time(name, vm_name, datastore_url, provider_key):
    try:
        providers_data = cfme_data.get("management_systems", {})
        hosts = providers_data[provider_key]['hosts']
        host_creds = providers_data[provider_key].get('host_credentials',
                                                      'host_default')
        hostname = [host['name'] for host in hosts if name in host['name']]
        if not hostname:
            hostname = re.findall(r'[0-9]+(?:\.[0-9]+){3}', name)
        connect_kwargs = {
            'username': credentials[host_creds]['username'],
            'password': credentials[host_creds]['password'],
            'hostname': hostname[0]
        }
        datastore_path = re.findall(r'([^ds:`/*].*)', str(datastore_url))
        ssh_client = SSHClient(**connect_kwargs)
        command = 'find ~/{}/{} -name {} | xargs  date -r'.format(
            datastore_path[0], str(vm_name),
            str(vm_name) + '.vmx')
        exit_status, output = ssh_client.run_command(command)
        ssh_client.close()
        modified_time = parser.parse(output.rstrip())
        modified_time = modified_time.astimezone(
            pytz.timezone(str(get_localzone())))
        return modified_time.replace(tzinfo=None)
    except Exception as e:
        logger.error(e)
        return False
示例#2
0
文件: net.py 项目: FilipB/cfme_tests
def net_check_remote(port, addr=None, machine_addr=None, ssh_creds=None, force=False):
    """Checks the availability of a port from outside using another machine (over SSH)"""
    from utils.ssh import SSHClient
    port = int(port)
    if not addr:
        addr = my_ip_address()
    if port not in _ports[addr] or force:
        if not machine_addr:
            machine_addr = urlparse.urlparse(store.base_url).hostname
        if not ssh_creds:
            ssh = store.current_appliance.ssh_client
        else:
            ssh = SSHClient(
                hostname=machine_addr,
                username=ssh_creds['username'],
                password=ssh_creds['password']
            )
        with ssh:
            # on exception => fails with return code 1
            cmd = '''python -c "
import sys, socket
addr = socket.gethostbyname('%s')
socket.create_connection((addr, %d), timeout=10)
sys.exit(0)
            "''' % (addr, port)
            ret, out = ssh.run_command(cmd)
            if ret == 0:
                _ports[addr][port] = True
            else:
                _ports[addr][port] = False
    return _ports[addr][port]
示例#3
0
def get_vm_config_modified_time(name, vm_name, datastore_url, provider_key):
    try:
        providers_data = cfme_data.get("management_systems", {})
        hosts = providers_data[provider_key]['hosts']
        host_creds = providers_data[provider_key].get('host_credentials', 'host_default')
        hostname = [host['name'] for host in hosts if name in host['name']]
        if not hostname:
            hostname = re.findall(r'[0-9]+(?:\.[0-9]+){3}', name)
        connect_kwargs = {
            'username': credentials[host_creds]['username'],
            'password': credentials[host_creds]['password'],
            'hostname': hostname[0]
        }
        datastore_path = re.findall(r'([^ds:`/*].*)', str(datastore_url))
        ssh_client = SSHClient(**connect_kwargs)
        command = 'find ~/{}/{} -name {} | xargs  date -r'.format(
            datastore_path[0], str(vm_name), str(vm_name) + '.vmx')
        exit_status, output = ssh_client.run_command(command)
        ssh_client.close()
        modified_time = parser.parse(output.rstrip())
        modified_time = modified_time.astimezone(pytz.timezone(str(get_localzone())))
        return modified_time.replace(tzinfo=None)
    except Exception as e:
        logger.error(e)
        return False
示例#4
0
def get_appliance(provider):
    """Fixture to provision appliance to the provider being tested if necessary"""
    global appliance_list
    global appliance_vm_name
    if provider not in appliance_list:
        if (
            "appliances_provider" not in cfme_data["basic_info"].keys()
            or provider != cfme_data["basic_info"]["appliances_provider"]
        ):
            appliance_list[provider] = provision_appliance(provider)
        else:
            appliance_list[provider] = re.findall(r"[0-9]+(?:\.[0-9]+){3}", conf.env["base_url"])[0]

            prov_data = cfme_data["management_systems"][provider]
            if prov_data["type"] == "virtualcenter":
                # ssh in and see if vddk already present, if not, install
                ssh_kwargs = {
                    "username": conf.credentials["ssh"]["username"],
                    "password": conf.credentials["ssh"]["password"],
                    "hostname": appliance_list[provider],
                }
                # Init SSH client
                client = SSHClient(**ssh_kwargs)
                if int(client.run_command("ldconfig -p | grep vix | wc -l")[1]) < 1:
                    install_vddk(appliance_list[provider])
                client.close()
            elif prov_data["type"] == "rhevm":
                add_rhev_direct_lun_disk(provider, appliance_vm_name)
    return appliance_list[provider]
示例#5
0
def get_appliance(provider):
    '''Fixture to provision appliance to the provider being tested if necessary'''
    global appliance_list
    global appliance_vm_name
    if provider not in appliance_list:
        if ('appliances_provider' not in cfme_data['basic_info'].keys()
                or provider != cfme_data['basic_info']['appliances_provider']):
            appliance_list[provider] = provision_appliance(provider)
        else:
            appliance_list[provider] = re.findall(r'[0-9]+(?:\.[0-9]+){3}',
                                                  conf.env['base_url'])[0]

            prov_data = cfme_data['management_systems'][provider]
            if prov_data['type'] == 'virtualcenter':
                # ssh in and see if vddk already present, if not, install
                ssh_kwargs = {
                    'username': conf.credentials['ssh']['username'],
                    'password': conf.credentials['ssh']['password'],
                    'hostname': appliance_list[provider]
                }
                # Init SSH client
                client = SSHClient(**ssh_kwargs)
                if int(
                        client.run_command("ldconfig -p | grep vix | wc -l")
                    [1]) < 1:
                    install_vddk(appliance_list[provider])
                client.close()
            elif prov_data['type'] == 'rhevm':
                add_rhev_direct_lun_disk(provider, appliance_vm_name)
    return appliance_list[provider]
示例#6
0
def setup_external_auth_ipa(**data):
    """Sets up the appliance for an external authentication with IPA.

    Keywords:
        get_groups: Get User Groups from External Authentication (httpd).
        ipaserver: IPA server address.
        iparealm: Realm.
        credentials: Key of the credential in credentials.yaml
    """
    ssh = SSHClient()
    ensure_browser_open()
    login_admin()
    if data["ipaserver"] not in get_ntp_servers():
        set_ntp_servers(data["ipaserver"])
        sleep(120)
    auth = ExternalAuthSetting(get_groups=data.pop("get_groups", False))
    auth.setup()
    logout()
    creds = credentials.get(data.pop("credentials"), {})
    data.update(**creds)
    rc, out = ssh.run_command(
        "appliance_console_cli --ipaserver {ipaserver} --iparealm {iparealm} "
        "--ipaprincipal {principal} --ipapassword {password}".format(**data)
    )
    assert rc == 0, out
    assert "failed" not in out.lower(), "External auth setup failed:\n{}".format(out)
    login_admin()
示例#7
0
def get_appliance(provider):
    '''Fixture to provision appliance to the provider being tested if necessary'''
    global appliance_list
    global appliance_vm_name
    if provider not in appliance_list:
        if ('appliances_provider' not in cfme_data['basic_info'].keys() or
                provider != cfme_data['basic_info']['appliances_provider']):
            appliance_list[provider] = provision_appliance(provider)
        else:
            appliance_list[provider] = re.findall(r'[0-9]+(?:\.[0-9]+){3}', conf.env['base_url'])[0]

            prov_data = cfme_data['management_systems'][provider]
            if prov_data['type'] == 'virtualcenter':
                # ssh in and see if vddk already present, if not, install
                ssh_kwargs = {
                    'username': conf.credentials['ssh']['username'],
                    'password': conf.credentials['ssh']['password'],
                    'hostname': appliance_list[provider]
                }
                # Init SSH client
                client = SSHClient(**ssh_kwargs)
                if int(client.run_command("ldconfig -p | grep vix | wc -l")[1]) < 1:
                    install_vddk(appliance_list[provider])
                client.close()
            elif prov_data['type'] == 'rhevm':
                add_rhev_direct_lun_disk(provider, appliance_vm_name)
    return appliance_list[provider]
示例#8
0
def net_check_remote(port,
                     addr=None,
                     machine_addr=None,
                     ssh_creds=None,
                     force=False):
    """Checks the availability of a port from outside using another machine (over SSH)"""
    from utils.ssh import SSHClient
    port = int(port)
    if not addr:
        addr = my_ip_address()
    if port not in _ports[addr] or force:
        if not machine_addr:
            machine_addr = urlparse.urlparse(store.base_url).hostname
        if not ssh_creds:
            ssh = SSHClient(hostname=machine_addr)
        else:
            ssh = SSHClient(hostname=machine_addr,
                            username=ssh_creds['username'],
                            password=ssh_creds['password'])
        with ssh:
            # on exception => fails with return code 1
            cmd = '''python -c "
import sys, socket
addr = socket.gethostbyname('%s')
socket.create_connection((addr, %d), timeout=10)
sys.exit(0)
            "''' % (addr, port)
            ret, out = ssh.run_command(cmd)
            if ret == 0:
                _ports[addr][port] = True
            else:
                _ports[addr][port] = False
    return _ports[addr][port]
示例#9
0
    def setSSHConnection(self):

        self.ssh_conn = SSHClient(log_path=self.output_dir + "/cumulus_" +
                                  self.userid + ".ssh.log")
        self.ssh_conn.connect(hostname=self.server,
                              username=self.userid,
                              password=self.password)
示例#10
0
def setup_external_auth_ipa(**data):
    """Sets up the appliance for an external authentication with IPA.

    Keywords:
        get_groups: Get User Groups from External Authentication (httpd).
        ipaserver: IPA server address.
        iparealm: Realm.
        credentials: Key of the credential in credentials.yaml
    """
    ssh = SSHClient()
    ensure_browser_open()
    login_admin()
    if data["ipaserver"] not in get_ntp_servers():
        set_ntp_servers(data["ipaserver"])
        sleep(120)
    auth = ExternalAuthSetting(get_groups=data.pop("get_groups", False))
    auth.setup()
    logout()
    creds = credentials.get(data.pop("credentials"), {})
    data.update(**creds)
    rc, out = ssh.run_command(
        "appliance_console_cli --ipaserver {ipaserver} --iparealm {iparealm} "
        "--ipaprincipal {principal} --ipapassword {password}".format(**data))
    assert rc == 0, out
    assert "failed" not in out.lower(
    ), "External auth setup failed:\n{}".format(out)
    login_admin()
示例#11
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("address", help="hostname or ip address of target appliance")
    parser.add_argument("sdk_url", help="url to download sdk pkg")
    parser.add_argument(
        "--restart",
        help="restart evmserverd after installation " + "(required for proper operation)",
        action="store_true",
    )

    args = parser.parse_args()

    ssh_kwargs = {
        "username": credentials["ssh"]["username"],
        "password": credentials["ssh"]["password"],
        "hostname": args.address,
    }

    # Init SSH client
    client = SSHClient(**ssh_kwargs)

    # start
    filename = args.sdk_url.split("/")[-1]
    foldername = os.path.splitext(filename)[0]

    # download
    print "Downloading sdk"
    status, out = client.run_command(
        "curl %(url)s -o %(file)s > /root/unzip.out 2>&1" % {"url": args.sdk_url, "file": filename}
    )

    # extract
    print "Extracting sdk (" + filename + ")"
    status, out = client.run_command("unzip -o -f -d /var/www/miq/vmdb/lib/ %s" % filename)
    if status != 0:
        print out
        sys.exit(1)

    # install
    print "Installing sdk (" + foldername + ")"
    status, out = client.run_command(
        'echo "export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:'
        + "/var/www/miq/vmdb/lib/"
        + foldername
        + '/lib/linux-64" >> /etc/default/evm'
    )
    if status != 0:
        print "SDK installation failure (rc:" + out + ")"
        print out
        sys.exit(1)

    # service evmserverd restart
    if args.restart:
        print "Appliance restart"
        status, out = client.run_command("service evmserverd restart")
        print "evmserverd restarted, the UI should start shortly."
    else:
        print "evmserverd must be restarted before netapp sdk can be used"
示例#12
0
def setup_collectd(perf_data):
    command_str = "until ping -c1 " + str(perf_data['appliance']['ip_address']
                                          ) + " &>/dev/null; do sleep 5; done"
    print subprocess.Popen(command_str, shell=True,
                           stdout=subprocess.PIPE).stdout.read()

    id_pub = subprocess.Popen("ssh-keygen -y -f ~/.ssh/id_rsa_t",
                              shell=True,
                              stdout=subprocess.PIPE).stdout.read()
    commandstring = "echo \"" + str(id_pub) + "\" > ~/.ssh/authorized_keys"
    ssh_client = SSHClient()
    ssh_client.run_command(commandstring)

    version_string = get_current_version_string().replace(".", "")
    appliance_name_update = perf_data['appliance']['appliance_name'].replace(
        "LATEST", version_string)
    perf_data['appliance']['appliance_name'] = appliance_name_update

    stream = open("cfme-performance/conf/data.yml", "r")
    datayml = yaml.load(stream)

    perf_data['tools']['grafana']['ip_address'] = datayml['grafana']['ip']
    perf_data['tools']['grafana']['enabled'] = 'true'
    hosts_local = "[monitorhost]\n" + str(
        perf_data['tools']['grafana']['ip_address']) + "\n\n"
    hosts_local = hosts_local + "[cfme-vmdb]\n" + perf_data['appliance'][
        'appliance_name'] + "\n\n"
    hosts_local = hosts_local + "[cfme-worker]\n\n[cfme-worker]\n\n[cfme-all-in-one]\n\n[rhevm]\n"
    hostfile = open("ansible/hosts.local", "w")
    hostfile.write(hosts_local)
    hostfile.close()

    cstr = "\n\tIdentityFile ~/.ssh/id_rsa_t\n\tStrictHostKeyChecking no\n\tUserKnownHostsFile=/dev/null"
    ssh_config = "Host " + perf_data['appliance'][
        'appliance_name'] + "\n\tHostname " + perf_data['appliance'][
            'ip_address'] + cstr
    ssh_config = ssh_config + "\nHost " + datayml['grafana'][
        'host'] + "\n\tHostname " + datayml['grafana']['ip'] + cstr
    #print ssh_config
    sshfile = open('ansible/ssh-config.local', 'w')
    sshfile.write(ssh_config)
    sshfile.close()

    stream = open("cfme-performance/conf/all.yml", "r")
    allstream = yaml.load(stream)
    allstream['appliances'][perf_data['appliance']['appliance_name']] = {}
    allstream['appliances'][perf_data['appliance'][
        'appliance_name']] = allstream['appliances']['CF-B2B-R0000-test']
    del allstream['appliances']['CF-B2B-R0000-test']
    with open('ansible/group_vars/all.local.yml', 'w') as outfile:
        yaml.dump(allstream, outfile, default_flow_style=False)

    subprocess.Popen("sleep 300", shell=True)
    print subprocess.Popen(
        "ansible-playbook -i hosts.local configure/postdeploy.yml -vvv",
        shell=True,
        stdout=subprocess.PIPE,
        cwd="ansible").stdout.read()
示例#13
0
def disable_external_auth_ipa():
    """Unconfigure external auth."""
    ssh = SSHClient()
    ensure_browser_open()
    login_admin()
    auth = DatabaseAuthSetting()
    auth.update()
    rc, out = ssh.run_command("appliance_console_cli --uninstall-ipa")
    assert rc == 0, out
示例#14
0
def disable_external_auth_ipa():
    """Unconfigure external auth."""
    ssh = SSHClient()
    ensure_browser_open()
    login_admin()
    auth = DatabaseAuthSetting()
    auth.update()
    rc, out = ssh.run_command("appliance_console_cli --uninstall-ipa")
    assert rc == 0, out
示例#15
0
def disable_external_auth_ipa():
    """Unconfigure external auth."""
    ssh = SSHClient()
    ensure_browser_open()
    login_admin()
    auth = DatabaseAuthSetting()
    auth.update()
    assert ssh.run_command("appliance_console_cli --uninstall-ipa")
    appliance.IPAppliance().wait_for_web_ui()
    logout()
示例#16
0
def use_storage(uses_ssh):
    ssh_client = SSHClient()
    if ssh_client.appliance_has_netapp():
        return
    if not current_version().is_in_series("5.2"):
        pytest.skip("Storage tests run only on .2 so far")
    subprocess.call("python ./scripts/install_netapp_lib.py --restart", shell=True)
    subprocess.call("python ./scripts/wait_for_appliance_ui.py", shell=True)
    if not ssh_client.appliance_has_netapp():
        pytest.fail("Could not setup the netapp for storage testing")
示例#17
0
def disable_external_auth_ipa():
    """Unconfigure external auth."""
    ssh = SSHClient()
    ensure_browser_open()
    login_admin()
    auth = DatabaseAuthSetting()
    auth.update()
    assert ssh.run_command("appliance_console_cli --uninstall-ipa")
    appliance.IPAppliance().wait_for_web_ui()
    logout()
示例#18
0
def use_storage(uses_ssh):
    ssh_client = SSHClient()
    if ssh_client.appliance_has_netapp():
        return
    if not current_version().is_in_series("5.2"):
        pytest.skip("Storage tests run only on .2 so far")
    subprocess.call("python ./scripts/install_netapp_lib.py --restart",
                    shell=True)
    subprocess.call("python ./scripts/wait_for_appliance_ui.py", shell=True)
    if not ssh_client.appliance_has_netapp():
        pytest.fail("Could not setup the netapp for storage testing")
示例#19
0
def set_default_domain():
    if current_version() < "5.3":
        return  # Domains are not in 5.2.x and lower
    ssh_client = SSHClient()
    # The command ignores the case when the Default domain is not present (: true)
    result = ssh_client.run_rails_command(
        "\"d = MiqAeDomain.where :name => 'Default'; puts (d) ? d.first.enabled : true\"")
    if result.output.lower().strip() != "true":
        # Re-enable the domain
        ssh_client.run_rails_command(
            "\"d = MiqAeDomain.where :name => 'Default'; d = d.first; d.enabled = true; d.save!\"")
示例#20
0
def set_yaml_config(config_name, data_dict, hostname=None):
    """Given a yaml name, dictionary and hostname, set the configuration yaml on the server

    The configuration yamls must be inserted into the DB using the ruby console, so this function
    uses SSH, not the database. It makes sense to be included here as a counterpart to
    :py:func:`get_yaml_config`

    Args:
        config_name: Name of the yaml configuration file
        data_dict: Dictionary with data to set/change
        hostname: Hostname/address of the server that we want to set up (default ``None``)

    Note:
        If hostname is set to ``None``, the default server set up for this session will be
        used. See :py:class:``utils.ssh.SSHClient`` for details of the default setup.

    Warning:

        Manually editing the config yamls is potentially dangerous. Furthermore,
        the rails runner doesn't return useful information on the outcome of the
        set request, so errors that arise from the newly loading config file
        will go unreported.

    Usage:

        # Update the appliance name, for example
        vmbd_yaml = get_yaml_config('vmdb')
        vmdb_yaml['server']['name'] = 'EVM IS AWESOME'
        set_yaml_config('vmdb', vmdb_yaml, '1.2.3.4')

    """
    # CFME does a lot of things when loading a configfile, so
    # let their native conf loader handle the job
    # If hostname is defined, connect to the specified server
    if hostname is not None:
        _ssh_client = SSHClient(hostname=hostname)
    # Else, connect to the default one set up for this session
    else:
        _ssh_client = SSHClient()
    # Build & send new config
    temp_yaml = NamedTemporaryFile()
    dest_yaml = '/tmp/conf.yaml'
    yaml.dump(data_dict, temp_yaml, default_flow_style=False)
    _ssh_client.put_file(temp_yaml.name, dest_yaml)
    # Build and send ruby script
    dest_ruby = '/tmp/load_conf.rb'
    ruby_template = data_path.join('utils', 'cfmedb_load_config.rbt')
    ruby_replacements = {'config_name': config_name, 'config_file': dest_yaml}
    temp_ruby = load_data_file(ruby_template.strpath, ruby_replacements)
    _ssh_client.put_file(temp_ruby.name, dest_ruby)

    # Run it
    _ssh_client.run_rails_command(dest_ruby)
def test_verify_revert_snapshot(test_vm, provider, soft_assert, register_event,
                                request):
    """Tests revert snapshot

    Metadata:
        test_flag: snapshot, provision
    """
    snapshot1 = new_snapshot(test_vm)
    ip = snapshot1.vm.provider.mgmt.get_ip_address(snapshot1.vm.name)
    ssh_kwargs = {
        'username':
        credentials[provider.data['full_template']['creds']]['username'],
        'password':
        credentials[provider.data['full_template']['creds']]['password'],
        'hostname':
        ip
    }
    with SSHClient(**ssh_kwargs) as ssh_client:
        ssh_client.run_command('touch snapshot1.txt')
        snapshot1.create()
        ssh_client.run_command('touch snapshot2.txt')
        snapshot2 = new_snapshot(test_vm)
        snapshot2.create()
        snapshot1.revert_to()
    # Wait for the snapshot to become active
    logger.info('Waiting for vm %s to become active', snapshot1.name)
    wait_for(snapshot1.wait_for_snapshot_active,
             num_sec=300,
             delay=20,
             fail_func=sel.refresh)
    test_vm.wait_for_vm_state_change(desired_state=test_vm.STATE_OFF,
                                     timeout=720)
    register_event(target_type='VmOrTemplate',
                   target_name=test_vm.name,
                   event_type='request_vm_start')
    register_event(target_type='VmOrTemplate',
                   target_name=test_vm.name,
                   event_type='vm_start')
    test_vm.power_control_from_cfme(option=test_vm.POWER_ON, cancel=False)
    navigate_to(test_vm.provider, 'Details')
    test_vm.wait_for_vm_state_change(desired_state=test_vm.STATE_ON,
                                     timeout=900)
    soft_assert(test_vm.find_quadicon().state == 'currentstate-on')
    soft_assert(test_vm.provider.mgmt.is_vm_running(test_vm.name),
                "vm not running")
    with SSHClient(**ssh_kwargs) as ssh_client:
        try:
            wait_for(lambda: ssh_client.run_command('test -e snapshot2.txt')[1]
                     == 0,
                     fail_condition=False)
            logger.info('Revert to snapshot %s successful', snapshot1.name)
        except:
            logger.info('Revert to snapshot %s Failed', snapshot1.name)
示例#22
0
def test_basic_metrics(provider):
    """ Basic Metrics availability test
        This test checks that the Metrics service is up
        Curls the hawkular status page and checks if it's up
        """
    username, password = provider.credentials['token'].principal,\
        provider.credentials['token'].secret
    hostname = conf.cfme_data.get('management_systems', {})[provider.key]\
        .get('hostname', [])
    host_url = 'https://' + hostname + '/hawkular/metrics/'
    command = 'curl -X GET ' + host_url + ' --insecure'
    ssh_client = SSHClient(hostname=hostname, username=username, password=password)
    assert re.search("Hawkular[ -]Metrics", str(ssh_client.run_command(command)))
示例#23
0
def get_worker_pid(worker_type):
    """Obtains the pid of the first worker with the worker_type specified"""
    ssh_client = SSHClient()
    exit_status, out = ssh_client.run_command('service evmserverd status 2> /dev/null | grep -m 1 '
        '\'{}\' | awk \'{{print $7}}\''.format(worker_type))
    worker_pid = str(out).strip()
    if out:
        logger.info('Obtained {} PID: {}'.format(worker_type, worker_pid))
    else:
        logger.error('Could not obtain {} PID, check evmserverd running or if specific role is'
            ' enabled...'.format(worker_type))
        assert out
    return worker_pid
示例#24
0
def disable_external_auth_openldap():
    auth = DatabaseAuthSetting()
    auth.update()
    sssd_conf = '/etc/sssd/sssd.conf'
    httpd_auth = '/etc/pam.d/httpd-auth'
    manageiq_remoteuser = '******'
    manageiq_ext_auth = '/etc/httpd/conf.d/manageiq-external-auth.conf'
    command = 'rm -rf {} && rm -rf {} && rm -rf {} && rm -rf {}'.format(
        sssd_conf, httpd_auth, manageiq_ext_auth, manageiq_remoteuser)
    ssh = SSHClient()
    assert ssh.run_command(command)
    ssh.run_command('systemctl restart evmserverd')
    appliance.IPAppliance().wait_for_web_ui()
    logout()
示例#25
0
def setup_external_auth_openldap(**data):
    """Sets up the appliance for an external authentication with OpenLdap.

    Keywords:
        get_groups: Get User Groups from External Authentication (httpd).
        ipaserver: IPA server address.
        iparealm: Realm.
        credentials: Key of the credential in credentials.yaml
    """
    connect_kwargs = {
        'username': credentials['host_default']['username'],
        'password': credentials['host_default']['password'],
        'hostname': data['ipaddress'],
    }
    appliance_obj = appliance.IPAppliance()
    appliance_name = 'cfmeappliance{}'.format(fauxfactory.gen_alpha(7).lower())
    appliance_address = appliance_obj.address
    appliance_fqdn = '{}.{}'.format(appliance_name, data['domain_name'])
    ldapserver_ssh = SSHClient(**connect_kwargs)
    # updating the /etc/hosts is a workaround due to the
    # https://bugzilla.redhat.com/show_bug.cgi?id=1360928
    command = 'echo "{}\t{}" >> /etc/hosts'.format(appliance_address,
                                                   appliance_fqdn)
    ldapserver_ssh.run_command(command)
    ldapserver_ssh.get_file(remote_file=data['cert_filepath'],
                            local_path=conf_path.strpath)
    ldapserver_ssh.close()
    ensure_browser_open()
    login_admin()
    auth = ExternalAuthSetting(get_groups=data.pop("get_groups", True))
    auth.setup()
    appliance_obj.configure_appliance_for_openldap_ext_auth(appliance_fqdn)
    logout()
示例#26
0
def disable_external_auth_openldap():
    auth = DatabaseAuthSetting()
    auth.update()
    sssd_conf = '/etc/sssd/sssd.conf'
    httpd_auth = '/etc/pam.d/httpd-auth'
    manageiq_remoteuser = '******'
    manageiq_ext_auth = '/etc/httpd/conf.d/manageiq-external-auth.conf'
    command = 'rm -rf {} && rm -rf {} && rm -rf {} && rm -rf {}'.format(
        sssd_conf, httpd_auth, manageiq_ext_auth, manageiq_remoteuser)
    ssh = SSHClient()
    assert ssh.run_command(command)
    ssh.run_command('systemctl restart evmserverd')
    appliance.IPAppliance().wait_for_web_ui()
    logout()
def main():
    parser = argparse.ArgumentParser(
        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address',
                        help='hostname or ip address of target appliance')

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }

    # Init SSH client
    client = SSHClient(**ssh_kwargs)

    # generate installed rpm list
    status, out = client.run_command(
        'rpm -qa | sort > /tmp/installed_rpms.txt')
    client.get_file('/tmp/installed_rpms.txt', 'installed_rpms.txt')

    # compress logs dir
    status, out = client.run_command(
        'cd /var/www/miq/vmdb; tar zcvf /tmp/appliance_logs.tgz log')
    client.get_file('/tmp/appliance_logs.tgz', 'appliance_logs.tgz')
示例#28
0
def test_idle_default(request):
    """Runs an appliance at idle for specific amount of time. Memory Monitor creates graphs and
    summary at the end of the scenario."""
    from_ts = int(time.time() * 1000)
    ssh_client = SSHClient()

    clean_appliance(ssh_client)

    quantifiers = {}
    scenario_data = {
        'appliance_ip': cfme_performance['appliance']['ip_address'],
        'appliance_name': cfme_performance['appliance']['appliance_name'],
        'test_dir': 'workload-idle',
        'test_name': 'Idle with Default Roles',
        'appliance_roles':
        get_server_roles_workload_idle_default(separator=', '),
        'scenario': {
            'name': 'default'
        }
    }
    monitor_thread = SmemMemoryMonitor(SSHClient(), scenario_data)

    def cleanup_workload(from_ts, quantifiers, scenario_data):
        starttime = time.time()
        to_ts = int(starttime * 1000)
        g_url = get_default_dashboard_url(from_ts, to_ts)
        logger.debug('Started cleaning up monitoring thread.')
        monitor_thread.grafana_url = g_url
        monitor_thread.signal = False
        monitor_thread.join()
        add_workload_quantifiers(quantifiers, scenario_data)
        timediff = time.time() - starttime
        logger.info(
            'Finished cleaning up monitoring thread in {}'.format(timediff))

    request.addfinalizer(
        lambda: cleanup_workload(from_ts, quantifiers, scenario_data))

    monitor_thread.start()

    wait_for_miq_server_workers_started(poll_interval=2)
    # No need to set server roles as we are using the default set of roles

    s_time = cfme_performance['workloads']['test_idle_default']['total_time']
    logger.info('Idling appliance for {}s'.format(s_time))
    time.sleep(s_time)

    quantifiers['Elapsed_Time'] = s_time
    logger.info('Test Ending...')
示例#29
0
def get_worker_pid(worker_type):
    """Obtains the pid of the first worker with the worker_type specified"""
    ssh_client = SSHClient()
    exit_status, out = ssh_client.run_command(
        'service evmserverd status 2> /dev/null | grep -m 1 '
        '\'{}\' | awk \'{{print $7}}\''.format(worker_type))
    worker_pid = str(out).strip()
    if out:
        logger.info('Obtained {} PID: {}'.format(worker_type, worker_pid))
    else:
        logger.error(
            'Could not obtain {} PID, check evmserverd running or if specific role is'
            ' enabled...'.format(worker_type))
        assert out
    return worker_pid
示例#30
0
def main():
    parser = argparse.ArgumentParser(
        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('hostname',
                        nargs='?',
                        default=None,
                        help='hostname or ip address of target appliance')
    parser.add_argument('source',
                        nargs='?',
                        default='ManageIQ',
                        help='Source Domain name')
    parser.add_argument('dest',
                        nargs='?',
                        default='Default',
                        help='Destination Domain name')
    parser.add_argument('username',
                        nargs='?',
                        default=credentials['ssh']['username'],
                        help='SSH username for target appliance')
    parser.add_argument('password',
                        nargs='?',
                        default=credentials['ssh']['password'],
                        help='SSH password for target appliance')

    args = parser.parse_args()

    ssh_kwargs = {'username': args.username, 'password': args.password}
    if args.hostname is not None:
        ssh_kwargs['hostname'] = args.hostname

    client = SSHClient(stream_output=True, **ssh_kwargs)

    # Make sure the working dir exists
    client.run_command('mkdir -p /tmp/miq')
    print 'Exporting domain...'
    export_opts = 'DOMAIN={} EXPORT_DIR=/tmp/miq PREVIEW=false OVERWRITE=true'.format(
        args.source)
    export_cmd = 'evm:automate:export {}'.format(export_opts)
    print export_cmd
    client.run_rake_command(export_cmd)
    ro_fix_cmd = "sed -i 's/system: true/system: false/g' /tmp/miq/ManageIQ/__domain__.yaml"
    client.run_command(ro_fix_cmd)
    import_opts = 'DOMAIN={} IMPORT_DIR=/tmp/miq PREVIEW=false'.format(
        args.source)
    import_opts += ' OVERWRITE=true IMPORT_AS={}'.format(args.dest)
    import_cmd = 'evm:automate:import {}'.format(import_opts)
    print import_cmd
    client.run_rake_command(import_cmd)
示例#31
0
def db_restore(temp_appliance_extended_db):
    app = temp_appliance_extended_db
    app.stop_evm_service()
    app.drop_database()
    db_storage_hostname = conf.cfme_data['bottlenecks']['hostname']
    db_storage = SSHClient(hostname=db_storage_hostname, **conf.credentials['bottlenecks'])
    with db_storage as ssh:
        # Different files for different versions
        ver = "_56" if current_version() < '5.7' else ""
        rand_filename = "/tmp/v2_key_{}".format(fauxfactory.gen_alphanumeric())
        ssh.get_file("/home/backups/otsuman_db_bottlenecks/v2_key{}".format(ver), rand_filename)
        dump_filename = "/tmp/db_dump_{}".format(fauxfactory.gen_alphanumeric())
        ssh.get_file("/home/backups/otsuman_db_bottlenecks/db.backup{}".format(ver), dump_filename)
        region_filename = "/tmp/REGION_{}".format(fauxfactory.gen_alphanumeric())
        ssh.get_file("/home/backups/otsuman_db_bottlenecks/REGION{}".format(ver), region_filename)
        guid_filename = "/tmp/GUID_{}".format(fauxfactory.gen_alphanumeric())
        ssh.get_file("/home/backups/otsuman_db_bottlenecks/GUID{}".format(ver), guid_filename)

    with app.ssh_client as ssh:
        ssh.put_file(rand_filename, "/var/www/miq/vmdb/certs/v2_key")
        ssh.put_file(dump_filename, "/tmp/evm_db.backup")
        ssh.put_file(region_filename, "/var/www/miq/vmdb/REGION")
        ssh.put_file(guid_filename, "/var/www/miq/vmdb/GUID")

        app.restore_database()
        app.start_evm_service()
        app.wait_for_web_ui()
示例#32
0
def sat6_unregister():
    with SSHClient() as ssh:
        ssh.run_command('subscription-manager remove --all')
        ssh.run_command('subscription-manager unregister')
        ssh.run_command('subscription-manager clean')
        ssh.run_command('mv -f /etc/rhsm/rhsm.conf.kat-backup /etc/rhsm/rhsm.conf')
        ssh.run_command('rpm -qa | grep katello-ca-consumer | xargs rpm -e')
示例#33
0
    def __init__(self, provider):

        provider_cfme_data = provider.get_yaml_data()
        self.hostname = provider_cfme_data['hostname']
        creds = provider_cfme_data.get('ssh_creds')

        if not creds:
            raise Exception(
                'Could not find ssh_creds in provider\'s cfme data.')
        if isinstance(creds, dict):
            self.username = creds.get('username')
            self.password = creds.get('password')
        else:
            self.username = credentials[creds].get('username')
            self.password = credentials[creds].get('password')

        with SSHClient(hostname=self.hostname,
                       username=self.username,
                       password=self.password,
                       look_for_keys=True) as ssh_client:
            self.ssh_client = ssh_client
            self.ssh_client.load_system_host_keys()

        self._command_counter = 0
        self.log_line_limit = 500
示例#34
0
def make_ssh_client(ip, sshname, sshpass):
    connect_kwargs = {
        'username': sshname,
        'password': sshpass,
        'hostname': ip
    }
    return SSHClient(**connect_kwargs)
def test_navigate_explorer():
    """Initial Example Workload, Add Provider, turn on some things, initiate navigations on the
    WebUI from python.  Currently lets disable cleaning the appliance etc."""
    from_ts = int(time.time() * 1000)
    ssh_client = SSHClient()

    # clean_appliance(ssh_client)

    cfme_ip = cfme_performance['appliance']['ip_address']
    cfme_web_ui_user = cfme_performance['appliance']['web_ui']['username']
    cfme_web_ui_password = cfme_performance['appliance']['web_ui']['password']

    url = "https://{}/".format(cfme_ip)
    params = {"user_name": cfme_web_ui_user,
        "user_password": cfme_web_ui_password }

    with requests.Session() as sess:
        r = sess.get("{}{}".format(url, "api/auth?requester_type=ui"),
            auth=HTTPBasicAuth(cfme_web_ui_user, cfme_web_ui_password), verify=False,
            allow_redirects=False)
        r = sess.post("{}{}".format(url, "dashboard/authenticate"), params=params, verify=False, allow_redirects=False)
        dump_r(r)
        # Get a protected page now:
        #r = sess.get(url + 'dashboard/show', verify=False, allow_redirects=False)
        for i in range(10):
            r = sess.get("{}{}".format(url, "dashboard/show"), verify=False)
            r = sess.get("{}{}".format(url, "vm_infra/explorer"), verify=False)
示例#36
0
def main():
    parser = argparse.ArgumentParser(
        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address',
                        help='hostname or ip address of target appliance')
    args = parser.parse_args()
    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }
    with SSHClient(**ssh_kwargs) as ssh:
        print("Setting appliance's time. Please wait.")
        servers_str = " ".join(
            ["'%s'" % server for server in cfme_data["clock_servers"]])
        status, out = ssh.run_command("ntpdate " + servers_str)
        if status != 0:
            print(
                "Could not set the time. Check the output of the command, please:"
            )
            print(out.strip())
            return 1

        print(
            "Time was set. Now it should be safe to log in and test on the appliance."
        )
        return 0
def make_ssh_client(ssh_host, ssh_user, ssh_pass):
    connect_kwargs = {
        'username': ssh_user,
        'password': ssh_pass,
        'hostname': ssh_host
    }
    return SSHClient(**connect_kwargs)
示例#38
0
def test_idle(request, scenario):
    """Runs an appliance at idle with specific roles turned on for specific amount of time. Memory
    Monitor creates graphs and summary at the end of the scenario."""
    from_ts = int(time.time() * 1000)
    ssh_client = SSHClient()
    logger.debug('Scenario: {}'.format(scenario['name']))

    clean_appliance(ssh_client)

    quantifiers = {}
    scenario_data = {
        'appliance_ip': cfme_performance['appliance']['ip_address'],
        'appliance_name': cfme_performance['appliance']['appliance_name'],
        'test_dir': 'workload-idle',
        'test_name': 'Idle with {} Roles'.format(scenario['name']),
        'appliance_roles': ', '.join(scenario['roles']),
        'scenario': scenario
    }
    monitor_thread = SmemMemoryMonitor(SSHClient(), scenario_data)

    def cleanup_workload(from_ts, quantifiers, scenario_data):
        starttime = time.time()
        to_ts = int(starttime * 1000)
        g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts)
        logger.debug('Started cleaning up monitoring thread.')
        monitor_thread.grafana_urls = g_urls
        monitor_thread.signal = False
        monitor_thread.join()
        add_workload_quantifiers(quantifiers, scenario_data)
        timediff = time.time() - starttime
        logger.info(
            'Finished cleaning up monitoring thread in {}'.format(timediff))

    request.addfinalizer(
        lambda: cleanup_workload(from_ts, quantifiers, scenario_data))

    monitor_thread.start()

    wait_for_miq_server_workers_started(poll_interval=2)
    set_server_roles(ssh_client, scenario['roles'])

    s_time = scenario['total_time']
    logger.info('Idling appliance for {}s'.format(s_time))
    time.sleep(s_time)

    quantifiers['Elapsed_Time'] = s_time
    logger.info('Test Ending...')
示例#39
0
def test_verify_revert_snapshot(test_vm, provider, soft_assert, register_event,
                                request):
    """Tests revert snapshot

    Metadata:
        test_flag: snapshot, provision
    """
    snapshot1 = new_snapshot(test_vm)
    ip = snapshot1.vm.provider_crud.get_mgmt_system().get_ip_address(
        snapshot1.vm.name)
    print ip
    ssh_kwargs = {
        'username':
        credentials[provider.data['full_template']['creds']]['username'],
        'password':
        credentials[provider.data['full_template']['creds']]['password'],
        'hostname':
        ip
    }
    ssh = SSHClient(**ssh_kwargs)
    ssh.run_command('touch snapshot1.txt')
    snapshot1.create()
    ssh.run_command('touch snapshot2.txt')
    snapshot2 = new_snapshot(test_vm)
    snapshot2.create()
    snapshot1.revert_to()
    # Wait for the snapshot to become active
    logger.info('Waiting for vm %s to become active', snapshot1.name)
    wait_for(snapshot1.wait_for_snapshot_active,
             num_sec=300,
             delay=20,
             fail_func=sel.refresh)
    test_vm.wait_for_vm_state_change(desired_state=Vm.STATE_OFF, timeout=720)
    register_event(test_vm.provider_crud.get_yaml_data()['type'], "vm",
                   test_vm.name, ["vm_power_on_req", "vm_power_on"])
    test_vm.power_control_from_cfme(option=Vm.POWER_ON, cancel=False)
    pytest.sel.force_navigate('infrastructure_provider',
                              context={'provider': test_vm.provider_crud})
    test_vm.wait_for_vm_state_change(desired_state=Vm.STATE_ON, timeout=900)
    soft_assert(test_vm.find_quadicon().state == 'currentstate-on')
    soft_assert(
        test_vm.provider_crud.get_mgmt_system().is_vm_running(test_vm.name),
        "vm not running")
    client = SSHClient(**ssh_kwargs)
    request.addfinalizer(test_vm.delete_from_provider)
    try:
        wait_for(lambda: client.run_command('test -e snapshot2.txt')[1] == 0,
                 fail_condition=False)
        logger.info('Revert to snapshot %s successful', snapshot1.name)
    except:
        logger.info('Revert to snapshot %s Failed', snapshot1.name)
示例#40
0
文件: db.py 项目: jkrocil/cfme_tests
def set_yaml_config(config_name, data_dict, hostname=None):
    """Given a yaml name, dictionary and hostname, set the configuration yaml on the server

    The configuration yamls must be inserted into the DB using the ruby console, so this function
    uses SSH, not the database. It makes sense to be included here as a counterpart to
    :py:func:`get_yaml_config`

    Args:
        config_name: Name of the yaml configuration file
        data_dict: Dictionary with data to set/change
        hostname: Hostname/address of the server that we want to set up (default ``None``)

    Note:
        If hostname is set to ``None``, the default server set up for this session will be
        used. See :py:class:``utils.ssh.SSHClient`` for details of the default setup.

    Warning:

        Manually editing the config yamls is potentially dangerous. Furthermore,
        the rails runner doesn't return useful information on the outcome of the
        set request, so errors that arise from the newly loading config file
        will go unreported.

    Usage:

        # Update the appliance name, for example
        vmbd_yaml = get_yaml_config('vmdb')
        vmdb_yaml['server']['name'] = 'EVM IS AWESOME'
        set_yaml_config('vmdb', vmdb_yaml, '1.2.3.4')

    """
    # CFME does a lot of things when loading a configfile, so
    # let their native conf loader handle the job
    # If hostname is defined, connect to the specified server
    if hostname is not None:
        _ssh_client = SSHClient(hostname=hostname)
    # Else, connect to the default one set up for this session
    else:
        _ssh_client = SSHClient()
    # Build & send new config
    temp_yaml = NamedTemporaryFile()
    dest_yaml = '/tmp/conf.yaml'
    yaml.dump(data_dict, temp_yaml, default_flow_style=False)
    _ssh_client.put_file(temp_yaml.name, dest_yaml)
    # Build and send ruby script
    dest_ruby = '/tmp/load_conf.rb'
    ruby_template = data_path.join('utils', 'cfmedb_load_config.rbt')
    ruby_replacements = {
        'config_name': config_name,
        'config_file': dest_yaml
    }
    temp_ruby = load_data_file(ruby_template.strpath, ruby_replacements)
    _ssh_client.put_file(temp_ruby.name, dest_ruby)

    # Run it
    _ssh_client.run_rails_command(dest_ruby)
def main():
    parser = argparse.ArgumentParser(
        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address',
                        help='hostname or ip address of target appliance')

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }

    # Init SSH client
    with SSHClient(**ssh_kwargs) as ssh_client:

        snmp_path = scripts_data_path.join("snmp")

        # Copy
        print("Copying files")
        ssh_client.put_file(
            snmp_path.join("snmp_listen.rb").strpath, "/root/snmp_listen.rb")
        ssh_client.put_file(
            snmp_path.join("snmp_listen.sh").strpath, "/root/snmp_listen.sh")

        # Enable after startup
        print("Enabling after startup")
        status = ssh_client.run_command(
            "grep 'snmp_listen[.]sh' /etc/rc.local")[0]
        if status != 0:
            ssh_client.run_command(
                "echo 'cd /root/ && ./snmp_listen.sh start' >> /etc/rc.local")
        assert ssh_client.run_command("grep 'snmp_listen[.]sh' /etc/rc.local")[0] == 0, \
            "Could not enable!"

        # Run!
        print("Starting listener")
        assert ssh_client.run_command("cd /root/ && ./snmp_listen.sh start")[0] == 0, \
            "Could not start!"

        # Open the port if not opened
        print("Opening the port in iptables")
        status = ssh_client.run_command(
            "grep '--dport 8765' /etc/sysconfig/iptables")[0]
        if status != 0:
            # append after the 5432 entry
            ssh_client.run_command(
                "sed -i '/--dport 5432/a -A INPUT -p tcp -m tcp --dport 8765 -j ACCEPT' "
                "/etc/sysconfig/iptables")
            ssh_client.run_command("systemctl restart iptables")
            # last ssh command, close
            # Check if accessible
            try:
                requests.get("http://{}:8765/".format(args.address))
            except requests.exceptions.ConnectionError:
                print("Could not detect running listener!")
                exit(2)
示例#42
0
def main():
    parser = argparse.ArgumentParser(
        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address',
                        help='hostname or ip address of target appliance')
    parser.add_argument('repo_url', help='updates base url')
    parser.add_argument('--reboot',
                        help='reboot after installation ' +
                        '(required for proper operation)',
                        action="store_true")

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }

    # Init SSH client
    client = SSHClient(**ssh_kwargs)

    # create repo file
    repo_file = "[rhel-updates]\nname=rhel6-updates\nbaseurl=" + \
                args.repo_url + "\nenabled=1\ngpgcheck=0"

    # create repo file on appliance
    print 'Create update repo file'
    status, out = client.run_command(
        'echo "%s" >/etc/yum.repos.d/rhel_updates.repo' % repo_file)

    # update
    print 'Running rhel updates...'
    status, out = client.run_command('yum update -y --nogpgcheck')
    print "\n" + out + "\n"
    if status != 0:
        print "ERROR during update"
        sys.exit(1)

    # reboot
    if args.reboot:
        print 'Appliance reboot'
        status, out = client.run_command('reboot')
    else:
        print 'A reboot is recommended.'
示例#43
0
def setup_external_auth_openldap(**data):
    """Sets up the appliance for an external authentication with OpenLdap.

    Keywords:
        get_groups: Get User Groups from External Authentication (httpd).
        ipaserver: IPA server address.
        iparealm: Realm.
        credentials: Key of the credential in credentials.yaml
    """
    connect_kwargs = {
        'username': credentials['host_default']['username'],
        'password': credentials['host_default']['password'],
        'hostname': data['ipaddress'],
    }
    appliance_obj = appliance.IPAppliance()
    appliance_name = 'cfmeappliance{}'.format(fauxfactory.gen_alpha(7).lower())
    appliance_address = appliance_obj.address
    appliance_fqdn = '{}.{}'.format(appliance_name, data['domain_name'])
    ldapserver_ssh = SSHClient(**connect_kwargs)
    # updating the /etc/hosts is a workaround due to the
    # https://bugzilla.redhat.com/show_bug.cgi?id=1360928
    command = 'echo "{}\t{}" >> /etc/hosts'.format(appliance_address, appliance_fqdn)
    ldapserver_ssh.run_command(command)
    ldapserver_ssh.get_file(remote_file=data['cert_filepath'],
                            local_path=conf_path.strpath)
    ldapserver_ssh.close()
    ensure_browser_open()
    login_admin()
    auth = ExternalAuthSetting(get_groups=data.pop("get_groups", True))
    auth.setup()
    appliance_obj.configure_appliance_for_openldap_ext_auth(appliance_fqdn)
    logout()
示例#44
0
def setup_external_auth_ipa(**data):
    """Sets up the appliance for an external authentication with IPA.

    Keywords:
        get_groups: Get User Groups from External Authentication (httpd).
        ipaserver: IPA server address.
        iparealm: Realm.
        credentials: Key of the credential in credentials.yaml
    """
    connect_kwargs = {
        'username': credentials['host_default']['username'],
        'password': credentials['host_default']['password'],
        'hostname': data['ipaserver'],
    }
    import fauxfactory
    appliance_name = 'cfmeappliance'.format(fauxfactory.gen_alpha(7).lower())
    appliance_address = appliance.IPAppliance().address
    appliance_fqdn = '{}.{}'.format(appliance_name, data['iparealm'].lower())
    ipaserver_ssh = SSHClient(**connect_kwargs)
    # updating the /etc/hosts is a workaround due to the
    # https://bugzilla.redhat.com/show_bug.cgi?id=1360928
    command = 'echo "{}\t{}" >> /etc/hosts'.format(appliance_address, appliance_fqdn)
    ipaserver_ssh.run_command(command)
    ipaserver_ssh.close()
    ssh = SSHClient()
    rc, out = ssh.run_command('appliance_console_cli --host {}'.format(appliance_fqdn))
    assert rc == 0, out
    ssh.run_command('echo "127.0.0.1\t{}" > /etc/hosts'.format(appliance_fqdn))
    ensure_browser_open()
    login_admin()
    if data["ipaserver"] not in get_ntp_servers():
        set_ntp_servers(data["ipaserver"])
        sleep(120)
    auth = ExternalAuthSetting(get_groups=data.pop("get_groups", False))
    auth.setup()
    logout()
    creds = credentials.get(data.pop("credentials"), {})
    data.update(**creds)
    rc, out = ssh.run_command(
        "appliance_console_cli --ipaserver {ipaserver} --iparealm {iparealm} "
        "--ipaprincipal {principal} --ipapassword {password}".format(**data)
    )
    assert rc == 0, out
    assert "failed" not in out.lower(), "External auth setup failed:\n{}".format(out)
    login_admin()
示例#45
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address', help='hostname or ip address of target appliance',
        nargs='?', default=None)

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
    }
    if args.address:
        ssh_kwargs['hostname'] = args.address

    # Init SSH client
    ssh_client = SSHClient(**ssh_kwargs)

    # compile assets if required (not required on 5.2)
    if not ssh_client.get_version().startswith("5.2"):
        if ssh_client.run_command("ls /var/www/miq/vmdb/public/assets")[0] != 0:
            ssh_client.run_rake_command("assets:precompile")
            ssh_client.run_rake_command("evm:restart")

    print "CFME UI worker restarted, UI should be available shortly"
 def restart_appliance(address):
     print('Restarting evmserverd on {}'.format(address))
     with SSHClient(hostname=address, **ssh_creds) as client:
         status, out = client.run_command('systemctl restart evmserverd')
         if status != 0:
             print("Restarting evmserverd failed on {}".format(address))
             sys.exit(1)
         else:
             print("Restarting succeeded on {}".format(address))
示例#47
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address', help='hostname or ip address of target appliance')
    parser.add_argument('-R', '--reverse', help='flag to indicate the patch should be undone',
        action='store_true', default=False, dest='reverse')

    args = parser.parse_args()

    # Find the patch file
    patch_file_name = data_path_for_filename('ajax_wait.diff', scripts_path.strpath)

    # Set up temp dir
    tmpdir = mkdtemp()
    atexit.register(shutil.rmtree, tmpdir)
    source = '/var/www/miq/vmdb/public/javascripts/application.js'
    target = os.path.join(tmpdir, 'application.js')

    # Init SSH client
    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }
    client = SSHClient(**ssh_kwargs)

    print 'retriving appliance.js from appliance'
    client.get_file(source, target)

    os.chdir(tmpdir)
    # patch, level 4, patch direction (default forward), ignore whitespace, don't output rejects
    direction = '-N -R' if args.reverse else '-N'
    exitcode = subprocess.call('patch -p4 %s -l -r- < %s' % (direction, patch_file_name),
        shell=True)

    if exitcode == 0:
        # Put it back after successful patching.
        print 'replacing appliance.js on appliance'
        client.put_file(target, source)
    else:
        print 'not changing appliance'

    return exitcode
示例#48
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address', help='hostname or ip address of target appliance')
    parser.add_argument('repo_url', help='updates base url')
    parser.add_argument('--reboot', help='reboot after installation ' +
        '(required for proper operation)', action="store_true")

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }

    # Init SSH client
    client = SSHClient(**ssh_kwargs)

    # create repo file
    repo_file = "[rhel-updates]\nname=rhel6-updates\nbaseurl=" + args.repo_url + "\nenabled=1\ngpgcheck=0"

    # create repo file on appliance
    print 'Create update repo file'
    status, out = client.run_command('echo "%s" >/etc/yum.repos.d/rhel_updates.repo' % repo_file)

    # update
    print 'Running rhel updates...'
    status, out = client.run_command('yum update -y --nogpgcheck')
    print "\n" + out + "\n"
    if status != 0:
        print "ERROR during update"
        sys.exit(1)


    # reboot
    if args.reboot:
        print 'Appliance reboot'
        status, out = client.run_command('reboot')
    else:
        print 'A reboot is recommended.'
示例#49
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address',
        help='hostname or ip address of target appliance')
    parser.add_argument('--region', default=0, type=int,
        help='region to assign to the new DB')

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }
    client = SSHClient(**ssh_kwargs)
    print 'Initializing Appliance Internal DB'

    if client.run_command('ls -l /bin/appliance_console_cli')[0] == 0:
        status, out = client.run_command('appliance_console_cli --ca --region 1 --internal')
        if status != 0:
            print 'Enabling DB failed with error:'
            print out
            sys.exit(1)
        else:
            print 'DB Enabled, evm watchdog should start the UI shortly.'
    else:
        rbt_repl = {
            'miq_lib': '/var/www/miq/lib',
            'region': args.region
        }

        # Find and load our rb template with replacements
        base_path = os.path.dirname(__file__)
        rbt = datafile.data_path_for_filename(
            'enable-internal-db.rbt', base_path)
        rb = datafile.load_data_file(rbt, rbt_repl)

        # sent rb file over to /tmp
        remote_file = '/tmp/%s' % generate_random_string()
        client.put_file(rb.name, remote_file)

        # Run the rb script, clean it up when done
        status, out = client.run_command('ruby %s' % remote_file)
        client.run_command('rm %s' % remote_file)
        if status != 0:
            print 'Enabling DB failed with error:'
            print out
            sys.exit(1)
        else:
            print 'DB Enabled, evm watchdog should start the UI shortly.'
示例#50
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("address", help="hostname or ip address of target appliance")
    parser.add_argument("repo_url", help="updates base url")
    parser.add_argument(
        "--reboot", help="reboot after installation " + "(required for proper operation)", action="store_true"
    )

    args = parser.parse_args()

    ssh_kwargs = {
        "username": credentials["ssh"]["username"],
        "password": credentials["ssh"]["password"],
        "hostname": args.address,
    }

    # Init SSH client
    client = SSHClient(**ssh_kwargs)

    # create repo file
    repo_file = "[rhel-updates]\nname=rhel6-updates\nbaseurl=" + args.repo_url + "\nenabled=1\ngpgcheck=0"

    # create repo file on appliance
    print "Create update repo file"
    status, out = client.run_command('echo "%s" >/etc/yum.repos.d/rhel_updates.repo' % repo_file)

    # update
    print "Running rhel updates..."
    status, out = client.run_command("yum update -y --nogpgcheck")
    print "\n" + out + "\n"
    if status != 0:
        print "ERROR during update"
        sys.exit(1)

    # reboot
    if args.reboot:
        print "Appliance reboot"
        status, out = client.run_command("reboot")
    else:
        print "A reboot is recommended."
def generate_version_files():
    yield
    starttime = time.time()
    ssh_client = SSHClient()
    relative_path = os.path.relpath(str(results_path), str(os.getcwd()))
    relative_string = relative_path + '/{}*'.format(test_ts)
    directory_list = glob.glob(relative_string)

    for directory in directory_list:
        module_path = os.path.join(directory, 'version_info')
        if os.path.exists(str(module_path)):
            return
        else:
            os.mkdir(str(module_path))
        generate_system_file(ssh_client, module_path)
        generate_processes_file(ssh_client, module_path)
        generate_gems_file(ssh_client, module_path)
        generate_rpms_file(ssh_client, module_path)

    timediff = time.time() - starttime
    logger.info('Generated all version files in {}'.format(timediff))
    ssh_client.close()
示例#52
0
def fix_merkyl_workaround():
    """Workaround around merkyl not opening an iptables port for communication"""
    ssh_client = SSHClient()
    if ssh_client.run_command('test -f /etc/init.d/merkyl').rc == 0:
        logger.info('Rudely overwriting merkyl init.d on appliance;')
        local_file = data_path.join("bundles").join("merkyl").join("merkyl")
        remote_file = "/etc/init.d/merkyl"
        ssh_client.put_file(local_file.strpath, remote_file)
        ssh_client.run_command("service merkyl restart")
示例#53
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('hostname', nargs='?', default=None,
        help='hostname or ip address of target appliance')
    parser.add_argument('source', nargs='?', default='ManageIQ',
        help='Source Domain name')
    parser.add_argument('dest', nargs='?', default='Default',
        help='Destination Domain name')
    parser.add_argument('username', nargs='?', default=credentials['ssh']['username'],
        help='SSH username for target appliance')
    parser.add_argument('password', nargs='?', default=credentials['ssh']['password'],
        help='SSH password for target appliance')

    args = parser.parse_args()

    ssh_kwargs = {
        'username': args.username,
        'password': args.password
    }
    if args.hostname is not None:
        ssh_kwargs['hostname'] = args.hostname

    client = SSHClient(stream_output=True, **ssh_kwargs)

    # Make sure the working dir exists
    client.run_command('mkdir -p /tmp/miq')
    print 'Exporting domain...'
    export_opts = 'DOMAIN={} EXPORT_DIR=/tmp/miq PREVIEW=false OVERWRITE=true'.format(args.source)
    export_cmd = 'evm:automate:export {}'.format(export_opts)
    print export_cmd
    client.run_rake_command(export_cmd)
    ro_fix_cmd = "sed -i 's/system: true/system: false/g' /tmp/miq/ManageIQ/__domain__.yaml"
    client.run_command(ro_fix_cmd)
    import_opts = 'DOMAIN={} IMPORT_DIR=/tmp/miq PREVIEW=false'.format(args.source)
    import_opts += ' OVERWRITE=true IMPORT_AS={}'.format(args.dest)
    import_cmd = 'evm:automate:import {}'.format(import_opts)
    print import_cmd
    client.run_rake_command(import_cmd)
示例#54
0
def test_verify_revert_snapshot(test_vm, provider_key, provider_type, provider_data,
                                soft_assert, register_event, request):
    """Tests revert snapshot

    Metadata:
        test_flag: snapshot, provision
    """
    snapshot1 = new_snapshot(test_vm)
    ip = snapshot1.vm.provider_crud.get_mgmt_system().get_ip_address(snapshot1.vm.name)
    print ip
    ssh_kwargs = {
        'username': credentials[provider_data['full_template']['creds']]['username'],
        'password': credentials[provider_data['full_template']['creds']]['password'],
        'hostname': ip
    }
    ssh = SSHClient(**ssh_kwargs)
    ssh.run_command('touch snapshot1.txt')
    snapshot1.create()
    ssh.run_command('touch snapshot2.txt')
    snapshot2 = new_snapshot(test_vm)
    snapshot2.create()
    snapshot1.revert_to()
    # Wait for the snapshot to become active
    logger.info('Waiting for vm %s to become active', snapshot1.name)
    wait_for(snapshot1.wait_for_snapshot_active, num_sec=300, delay=20, fail_func=sel.refresh)
    test_vm.wait_for_vm_state_change(desired_state=Vm.STATE_OFF, timeout=720)
    register_event(
        test_vm.provider_crud.get_yaml_data()['type'],
        "vm", test_vm.name, ["vm_power_on_req", "vm_power_on"])
    test_vm.power_control_from_cfme(option=Vm.POWER_ON, cancel=False)
    pytest.sel.force_navigate(
        'infrastructure_provider', context={'provider': test_vm.provider_crud})
    test_vm.wait_for_vm_state_change(desired_state=Vm.STATE_ON, timeout=900)
    soft_assert(test_vm.find_quadicon().state == 'currentstate-on')
    soft_assert(
        test_vm.provider_crud.get_mgmt_system().is_vm_running(test_vm.name), "vm not running")
    client = SSHClient(**ssh_kwargs)
    request.addfinalizer(test_vm.delete_from_provider)
    try:
        wait_for(lambda: client.run_command('test -e snapshot2.txt')[1] == 0, fail_condition=False)
        logger.info('Revert to snapshot %s successful', snapshot1.name)
    except:
        logger.info('Revert to snapshot %s Failed', snapshot1.name)
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('address', help='hostname or ip address of target appliance')

    args = parser.parse_args()

    ssh_kwargs = {
        'username': credentials['ssh']['username'],
        'password': credentials['ssh']['password'],
        'hostname': args.address
    }

    # Init SSH client
    client = SSHClient(**ssh_kwargs)

    # generate installed rpm list
    status, out = client.run_command('rpm -qa | sort > /tmp/installed_rpms.txt')
    client.get_file('/tmp/installed_rpms.txt', 'installed_rpms.txt')

    # compress logs dir
    status, out = client.run_command('cd /var/www/miq/vmdb; tar zcvf /tmp/appliance_logs.tgz log')
    client.get_file('/tmp/appliance_logs.tgz', 'appliance_logs.tgz')
示例#56
0
def test_verify_revert_snapshot(test_vm, provider, soft_assert, register_event, request):
    """Tests revert snapshot

    Metadata:
        test_flag: snapshot, provision
    """
    snapshot1 = new_snapshot(test_vm)
    ip = snapshot1.vm.provider.mgmt.get_ip_address(snapshot1.vm.name)
    ssh_kwargs = {
        'username': credentials[provider.data['full_template']['creds']]['username'],
        'password': credentials[provider.data['full_template']['creds']]['password'],
        'hostname': ip
    }
    ssh = SSHClient(**ssh_kwargs)
    ssh.run_command('touch snapshot1.txt')
    snapshot1.create()
    ssh.run_command('touch snapshot2.txt')
    snapshot2 = new_snapshot(test_vm)
    snapshot2.create()
    snapshot1.revert_to()
    # Wait for the snapshot to become active
    logger.info('Waiting for vm %s to become active', snapshot1.name)
    wait_for(snapshot1.wait_for_snapshot_active, num_sec=300, delay=20, fail_func=sel.refresh)
    test_vm.wait_for_vm_state_change(desired_state=test_vm.STATE_OFF, timeout=720)
    register_event('VmOrTemplate', test_vm.name, ['request_vm_start', 'vm_start'])
    test_vm.power_control_from_cfme(option=test_vm.POWER_ON, cancel=False)
    navigate_to(test_vm.provider, 'Details')
    test_vm.wait_for_vm_state_change(desired_state=test_vm.STATE_ON, timeout=900)
    soft_assert(test_vm.find_quadicon().state == 'currentstate-on')
    soft_assert(
        test_vm.provider.mgmt.is_vm_running(test_vm.name), "vm not running")
    client = SSHClient(**ssh_kwargs)
    try:
        wait_for(lambda: client.run_command('test -e snapshot2.txt')[1] == 0, fail_condition=False)
        logger.info('Revert to snapshot %s successful', snapshot1.name)
    except:
        logger.info('Revert to snapshot %s Failed', snapshot1.name)
示例#57
0
def main():
    parser = argparse.ArgumentParser(epilog=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('hostname', nargs='?', default=None,
        help='hostname or ip address of target appliance')
    parser.add_argument('username', nargs='?', default=credentials['ssh']['username'],
        help='SSH username for target appliance')
    parser.add_argument('password', nargs='?', default=credentials['ssh']['password'],
        help='SSH password for target appliance')

    args = parser.parse_args()

    ssh_kwargs = {
        'username': args.username,
        'password': args.password
    }
    if args.hostname is not None:
        ssh_kwargs['hostname'] = args.hostname

    client = SSHClient(stream_output=True, **ssh_kwargs)

    # `service evmserverd stop` is a little slow, and we're destroying the
    # db, so rudely killing ruby speeds things up significantly
    print 'Stopping ruby processes...'
    client.run_command('killall ruby')
    client.run_rake_command('evm:db:reset')
    client.run_command('service evmserverd start')

    print 'Waiting for appliance UI...'
    args = [
        scripts_path.join('wait_for_appliance_ui.py').strpath,
        # SSHClient has the smarts to get our hostname if none was provided
        # Soon, utils.appliance.Appliance will be able to do all of this
        # and this will be made good
        'http://%s' % client._connect_kwargs['hostname']
    ]
    return subprocess.call(args)
def list_orphaned_files_per_host(host_name, host_datastore_urls, provider_key, vm_registered_files,
                                 unregistered_files):
    try:
        providers_data = cfme_data.get("management_systems", {})
        hosts = providers_data[provider_key]['hosts']
        hostname = [host['name'] for host in hosts if host_name in host['name']]
        # check if hostname returned is ipaddress
        if not hostname:
            hostname = re.findall(r'[0-9]+(?:\.[0-9]+){3}', host_name)
        connect_kwargs = {
            'username': credentials['host_default']['username'],
            'password': credentials['host_default']['password'],
            'hostname': hostname[0]
        }
        for datastore_url in host_datastore_urls:
            datastore_path = re.findall(r'([^ds:`/*].*)', str(datastore_url))
            ssh_client = SSHClient(**connect_kwargs)
            command = 'ls ~/{}'.format(datastore_path[0])
            exit_status, output = ssh_client.run_command(command)
            ssh_client.close()
            files_in_datastore = output.splitlines() if exit_status == 0 else []
            for fil in files_in_datastore:
                if fil not in vm_registered_files:
                    file_type = 'UNKNOWN'
                    number_of_files = 0
                    command = 'test -d ~/{}/{}; echo $?'.format(datastore_path[0], fil)
                    exit_status, output = ssh_client.run_command(command)
                    ssh_client.close()
                    file_extension = re.findall(r'.*\.(\w*)', fil)
                    if file_extension:
                        file_type = file_extension[0]
                        number_of_files = 1
                    if int(output.strip()) == 0:
                        command = 'ls ~/{}/{} | wc -l'.format(datastore_path[0], fil)
                        exit_status, output = ssh_client.run_command(command)
                        number_of_files = output.strip()
                        command = 'find ~/{}/{} -name "*.vmx" | wc -l'.format(
                            datastore_path[0], fil)
                        vmx_status, vmx_output = ssh_client.run_command(command)
                        command = 'find ~/{}/{} -name "*.vmtx" | wc -l'.format(
                            datastore_path[0], fil)
                        vmtx_status, vmtx_output = ssh_client.run_command(command)
                        command = 'find ~/{}/{} -name "*.vmdk" | wc -l'.format(
                            datastore_path[0], fil)
                        vmdk_status, vmdk_output = ssh_client.run_command(command)

                        ssh_client.close()
                        if int(vmx_output.strip()) > 0:
                            file_type = 'VirtualMachine'
                        elif int(vmtx_output.strip()) > 0:
                            file_type = 'Template'
                        elif int(vmdk_output.strip()) > 0:
                            file_type = 'VMDK'
                            # delete_this = '~/' + datastore_path[0] + fil
                            # command = 'rm -rf {}'.format(delete_this)
                            # exit_status, output = ssh_client.run_command(command)
                            # logger.info(output)

                    file_path = '~/' + datastore_path[0] + fil
                    if file_path not in unregistered_files:
                        unregistered_files.append(file_path)
                        print('{}\t\t{}\t\t{}\t\t{}'.format(
                            hostname[0], file_path, file_type, number_of_files))

    except Exception as e:
        logger.error(e)
        return False
示例#59
0
    def connect_direct_lun_to_appliance(self, vm_name, disconnect):
        """Connects or disconnects the direct lun disk to an appliance.

        Args:
            vm_name: Name of the VM with the appliance.
            disconnect: If False, it will connect, otherwise it will disconnect
        """
        if "provider_key" in self.kwargs:
            provider_name = self.kwargs["provider_key"]
        else:
            raise TypeError("provider_key not supplied to the provider.")
        # check that the vm exists on the rhev provider, get the ip address if so
        try:
            vm = self.api.vms.get(vm_name)
            ip_addr = self.get_ip_address(vm_name)
        except:
            raise NameError("{} not found on  {}".format(vm_name, provider_name))

        # check for direct lun definition on provider's cfme_data.yaml
        if "direct_lun" not in self.kwargs:
            raise ValueError("direct_lun key not in cfme_data.yaml under provider {}, exiting...".format(provider_name))

        # does the direct lun exist
        prov_data = self.kwargs
        dlun_name = prov_data["direct_lun"]["name"]
        dlun = self.api.disks.get(dlun_name)
        if dlun is None:

            #    Create the iSCSI storage connection:
            sc = params.StorageConnection()
            sc.set_address(prov_data["direct_lun"]["ip_address"])
            sc.set_type("iscsi")
            sc.set_port(int(prov_data["direct_lun"]["port"]))
            sc.set_target(prov_data["direct_lun"]["iscsi_target"])

            #    Add the direct LUN disk:
            lu = params.LogicalUnit()
            lu.set_id(prov_data["direct_lun"]["iscsi_target"])
            lu.set_address(sc.get_address())
            lu.set_port(sc.get_port())
            lu.set_target(sc.get_target())
            storage = params.Storage()
            storage.set_type("iscsi")
            storage.set_logical_unit([lu])
            disk = params.Disk()
            disk.set_name(dlun_name)
            disk.set_interface("virtio")
            disk.set_type("iscsi")
            disk.set_format("raw")
            disk.set_lun_storage(storage)
            disk.set_shareable(True)
            disk = self.api.disks.add(disk)
            dlun = self.api.disks.get(dlun_name)

        # add it
        if not disconnect:
            retries = 0
            while retries < 3:
                retries += 1
                direct_lun = params.Disk(id=dlun.id)
                try:
                    # is the disk present and active?
                    vm_disk_list = vm.get_disks().list()
                    for vm_disk in vm_disk_list:
                        if vm_disk.name == dlun_name:
                            if vm_disk.active:
                                return
                            else:
                                vm_disk.activate()
                                return

                    # if not present, add it and activate
                    direct_lun = params.Disk(id=dlun.id)
                    added_lun = vm.disks.add(direct_lun)
                    added_lun.activate()
                except Exception as e:
                    logger.error("Exception caught: %s" % str(e))
                    if retries == 3:
                        logger.error("exhausted retries and giving up")
                        raise
                    else:
                        logger.info("sleeping for 30s and retrying to connect direct lun")
                        time.sleep(30)

            # Init SSH client, run pvscan on the appliance
            ssh_kwargs = {
                "username": conf.credentials["ssh"]["username"],
                "password": conf.credentials["ssh"]["password"],
                "hostname": ip_addr,
            }
            client = SSHClient(**ssh_kwargs)
            status, out = client.run_command("pvscan", timeout=5 * 60)

        # remove it
        else:
            vm_dlun = vm.disks.get(name=dlun_name)
            if vm_dlun is None:
                return
            else:
                detach = params.Action(detach=True)
                vm_dlun.delete(action=detach)
示例#60
0
def get_current_version_string():
    """Returns string contents of /var/www/miq/vmdb/VERSION"""
    ssh_client = SSHClient()
    exit_status, current_version = ssh_client.run_command('cat /var/www/miq/vmdb/VERSION')
    return current_version.strip()