def main():
parser = argparse.ArgumentParser(
epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'url',
nargs='?',
default=None,
help='URL of target appliance, e.g. "https://ip_or_host/"')
parser.add_argument(
'--num-sec',
default=600,
type=int,
dest='num_sec',
help=
'Maximum number of seconds to wait before giving up, default 600 (10 minutes)'
)
args = parser.parse_args()
if args.url:
ip_a = IPAppliance.from_url(args.url)
else:
ip_a = IPAppliance()
result = ip_a.wait_for_web_ui(timeout=args.num_sec)
if not result:
return 1
def main():
parser = argparse.ArgumentParser(
epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--address',
help='hostname or ip address of target appliance',
default=None)
parser.add_argument('--vddk_url', help='url to download vddk pkg')
parser.add_argument('--reboot',
help='reboot after installation ' +
'(required for proper operation)',
action="store_true")
parser.add_argument('--force',
help='force installation if version detected',
action="store_true")
args = parser.parse_args()
if not args.address:
appliance = get_or_create_current_appliance()
else:
appliance = IPAppliance(address=urlparse(args.address).netloc)
appliance.install_vddk(reboot=args.reboot,
force=args.force,
vddk_url=args.vddk_url,
log_callback=log)
def main():
parser = argparse.ArgumentParser(
epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--address',
help='hostname or ip address of target appliance',
default=None)
parser.add_argument('--sdk_url',
help='url to download sdk pkg',
default=cfme_data.get("basic_info",
{}).get("netapp_sdk_url"))
parser.add_argument('--restart',
help='restart evmserverd after installation ' +
'(required for proper operation)',
action="store_true")
args = parser.parse_args()
if not args.address:
appliance = get_or_create_current_appliance()
else:
appliance = IPAppliance(address=args.address)
print('Address: {}'.format(appliance.address))
print('SDK URL: {}'.format(args.sdk_url))
print('Restart: {}'.format(args.restart))
appliance.install_netapp_sdk(sdk_url=args.sdk_url,
reboot=args.restart,
log_callback=log)
def main():
parser = argparse.ArgumentParser(epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("address", nargs="?", default=None, help="hostname or ip address of target appliance")
args = parser.parse_args()
ip_a = IPAppliance(args.address)
ip_a.fix_ntp_clock()
print("Time was set")
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("-u", "--url", help="url(s) to use for update",
dest="urls", action="append")
parser.add_argument("-c", "--cleanup", help="Whether to cleanup /etc/yum.repos.d before start",
dest="cleanup", action="store_true")
parser.add_argument("--no_wait_ui", help="Whether to NOT wait for UI after reboot",
dest="no_wait_ui", action="store_false")
parser.add_argument('--reboot', help='reboot after installation ' +
'(required for proper operation)', action="store_true", default=False)
args = parser.parse_args()
ip_a = IPAppliance(args.address)
# Don't reboot here, so we can print updates to the console when we do
res = ip_a.update_rhel(*args.urls, reboot=False, streaming=True, cleanup=args.cleanup)
if res.rc == 0:
if args.reboot:
print('Rebooting')
ip_a.reboot(wait_for_web_ui=args.no_wait_ui)
print('Appliance update complete')
return res.rc
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("-u",
"--url",
help="url(s) to use for update",
dest="urls",
action="append")
parser.add_argument('--reboot',
help='reboot after installation ' +
'(required for proper operation)',
action="store_true",
default=False)
args = parser.parse_args()
ip_a = IPAppliance(args.address)
# Don't reboot here, so we can print updates to the console when we do
res = ip_a.update_rhel(*args.urls, reboot=False, streaming=True)
if res.rc == 0:
if args.reboot:
print('Rebooting')
ip_a.reboot()
print('Appliance update complete')
return res.rc
def main():
parser = argparse.ArgumentParser(epilog=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('address', nargs='?', default=None,
help='hostname or ip address of target appliance')
parser.add_argument('db_address',
help='hostname or ip address of external database')
parser.add_argument('--database', default='vmdb_production',
help='name of the external database')
parser.add_argument('--region', default=0, type=int,
help='region to assign to the new DB')
parser.add_argument('--username', default=credentials['database']['username'],
help='username for external database')
parser.add_argument('--password', default=credentials['database']['password'],
help='password for external database')
args = parser.parse_args()
print('Initializing Appliance External DB')
ip_a = IPAppliance(args.address)
status, out = ip_a.enable_external_db(args.db_address, args.region, args.database,
args.username, args.password)
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.')
def pytest_configure(config):
global appliance
global pool_id
global sprout
if not config.option.appliances and (config.option.use_sprout and
config.option.sprout_appliances == 1):
terminal = reporter()
sprout = SproutClient.from_config()
terminal.write("Requesting a single appliance from sprout...\n")
pool_id = sprout.request_appliances(
config.option.sprout_group,
count=config.option.sprout_appliances,
version=config.option.sprout_version,
date=config.option.sprout_date,
lease_time=config.option.sprout_timeout)
terminal.write(
"Appliance pool {}. Waiting for fulfillment ...\n".format(pool_id))
at_exit(destroy_the_pool)
if config.option.sprout_desc is not None:
sprout.set_pool_description(pool_id,
str(config.option.sprout_desc))
try:
result = wait_for(
lambda: sprout.request_check(pool_id)["fulfilled"],
num_sec=config.option.sprout_provision_timeout * 60,
delay=5,
message="requesting appliance was fulfilled")
except:
pool = sprout.request_check(pool_id)
dump_pool_info(lambda x: terminal.write("{}\n".format(x)), pool)
terminal.write("Destroying the pool on error.\n")
sprout.destroy_pool(pool_id)
raise
terminal.write("Provisioning took {0:.1f} seconds\n".format(
result.duration))
request = sprout.request_check(pool_id)
ip_address = request["appliances"][0]["ip_address"]
terminal.write(
"Appliance requested at address {} ...\n".format(ip_address))
reset_timer(sprout, pool_id, config.option.sprout_timeout)
terminal.write("Appliance lease timer is running ...\n")
appliance = IPAppliance(address=ip_address)
appliance.push()
# Retrieve and print the template_name for Jenkins to pick up
template_name = request["appliances"][0]["template_name"]
conf.runtime["cfme_data"]["basic_info"][
"appliance_template"] = template_name
terminal.write("appliance_template=\"{}\";\n".format(template_name))
with project_path.join('.appliance_template').open(
'w') as template_file:
template_file.write(
'export appliance_template="{}"'.format(template_name))
terminal.write("Single appliance Sprout setup finished.\n")
# And set also the appliances_provider
provider = request["appliances"][0]["provider"]
terminal.write("appliance_provider=\"{}\";\n".format(provider))
conf.runtime["cfme_data"]["basic_info"][
"appliances_provider"] = provider
yield
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)
parser.add_argument('--with_ssl', help='update for ssl connections', action="store_true")
args = parser.parse_args()
ip_a = IPAppliance(args.address)
return ip_a.loosen_pgssl()
def main():
parser = argparse.ArgumentParser(
epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('address',
nargs="?",
default=None,
help='hostname or ip address of target appliance')
args = parser.parse_args()
ip_a = IPAppliance(args.address)
ip_a.fix_ntp_clock()
print("Time was set")
def main():
parser = argparse.ArgumentParser(epilog=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('address', nargs='?', default=None,
help='hostname or ip address of target appliance')
args = parser.parse_args()
ip_a = IPAppliance(args.address)
status = ip_a.precompile_assets()
if status == 0:
print("CFME UI worker restarted, UI should be available shortly")
return status
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')
args = parser.parse_args()
ip_a = IPAppliance(args.hostname)
status, out = ip_a.clone_domain(args.source, args.dest)
return status
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('start', action="store_true", default=False, help='Start Merkyl?')
args = parser.parse_args()
if args.hostname is not None:
ip_a = IPAppliance(args.hostname)
else:
ip_a = IPAppliance.from_url()
ip_a.deploy_merkyl(args.start)
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)
parser.add_argument('--with_ssl',
help='update for ssl connections',
action="store_true")
args = parser.parse_args()
ip_a = IPAppliance(args.address)
return ip_a.loosen_pgssl()
def mark(api, provider_key, template, usable, diagnose):
# set some defaults
diagnosis = None
build_number = None
if not usable:
build_number = os.environ.get('BUILD_NUMBER', None)
if diagnose:
# diagnose will return None on a usable appliance, so don't bother
from utils.appliance import IPAppliance
ipa = IPAppliance()
diagnosis = ipa.diagnose_evm_failure()
if diagnosis:
logger.error('Appliance failed: {}'.format(diagnosis.split(os.linesep)[0]))
trackerbot.mark_provider_template(api, provider_key, template, tested=True, usable=usable,
diagnosis=diagnosis, build_number=build_number)
def pytest_configure(config):
if config.getoption("appliances"):
return
if not config.getoption('--use-sprout'):
return
provision_request = SproutProvisioningRequest.from_config(config)
mgr = config._sprout_mgr = SproutManager()
requested_appliances = mgr.request_appliances(provision_request)
config.option.appliances[:] = []
appliances = config.option.appliances
# Push an appliance to the stack to have proper reference for test collection
# FIXME: this is a bad hack based on the need for controll of collection partitioning
appliance_stack.push(
IPAppliance(address=requested_appliances[0]["ip_address"]))
log.info("Appliances were provided:")
for appliance in requested_appliances:
url = "https://{}/".format(appliance["ip_address"])
appliances.append(url)
log.info("- %s is %s", url, appliance['name'])
mgr.reset_timer()
# Set the base_url for collection purposes on the first appliance
conf.runtime["env"]["base_url"] = appliances[0]
# Retrieve and print the template_name for Jenkins to pick up
template_name = requested_appliances[0]["template_name"]
conf.runtime["cfme_data"]["basic_info"]["appliance_template"] = template_name
log.info("appliance_template: %s", template_name)
with project_path.join('.appliance_template').open('w') as template_file:
template_file.write('export appliance_template="{}"'.format(template_name))
log.info("Sprout setup finished.")
def call_appliance(order, result_dict, ip_address, action, args, kwargs):
# Given a provider class, find the named method and call it with
# *args. This could possibly be generalized for other CLI tools.
appliance = IPAppliance(ip_address)
result = None
try:
call = getattr(appliance, action)
except AttributeError:
raise Exception('Action "{}" not found'.format(action))
if isinstance(getattr(type(appliance), action), property):
result = call
else:
try:
argspec = inspect.getargspec(call)
except TypeError:
try:
result = call(*args, **kwargs)
except Exception as e:
result = e
else:
if argspec.keywords is not None or 'log_callback' in argspec.args:
kwargs['log_callback'] = generate_log_callback(ip_address)
try:
result = call(*args, **kwargs)
except Exception as e:
result = e
with lock:
result_dict[order] = result
def test_ipappliance_use_baseurl():
ip_a = IPAppliance()
ip_a_parsed = urlparse(ip_a.url)
env_parsed = urlparse(store.base_url)
assert (ip_a_parsed.scheme, ip_a_parsed.netloc) == (env_parsed.scheme,
env_parsed.netloc)
assert ip_a.address in store.base_url
def main():
parser = argparse.ArgumentParser(epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
"--address", help="hostname or ip address of target appliance", default=env.get("base_url", None)
)
parser.add_argument("--vddk_url", help="url to download vddk pkg")
parser.add_argument(
"--reboot", help="reboot after installation " + "(required for proper operation)", action="store_true"
)
parser.add_argument("--force", help="force installation if version detected", action="store_true")
args = parser.parse_args()
address = urlparse(args.address).netloc
appliance = IPAppliance(address=address)
appliance.install_vddk(reboot=args.reboot, force=args.force, vddk_url=args.vddk_url, log_callback=log)
def collection_appliance(self):
# if parallelized, this is decided in sessionstart and written to the conf
if store.parallelizer_role == 'slave':
from utils.appliance import IPAppliance
return IPAppliance(conf['.ui-coverage']['collection_appliance'])
else:
# otherwise, coverage only happens on one appliance
return store.current_appliance
def get_appliance(appliance_ip):
"""Checks an appliance is not None and if so, loads the appropriate things"""
from utils.appliance import IPAppliance, get_or_create_current_appliance
if not appliance_ip:
app = get_or_create_current_appliance()
else:
app = IPAppliance(appliance_ip)
return app
def main():
parser = argparse.ArgumentParser(epilog=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('url', nargs='?', default=None,
help='URL of target appliance, e.g. "https://ip_or_host/"')
parser.add_argument('--num-sec', default=600, type=int, dest='num_sec',
help='Maximum number of seconds to wait before giving up, default 600 (10 minutes)')
args = parser.parse_args()
if args.url:
ip_a = IPAppliance.from_url(args.url)
else:
ip_a = IPAppliance()
result = ip_a.wait_for_web_ui(timeout=args.num_sec)
if not result:
return 1
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()
print 'Initializing Appliance Internal DB'
ip_a = IPAppliance(args.address)
status, out = ip_a.enable_internal_db(args.region)
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.'
def current_appliance(self):
if not self._current_appliance:
from utils.appliance import IPAppliance
base_url = conf.env['base_url']
if base_url is None or str(base_url.lower()) == 'none':
raise ValueError(
'No IP address specified! Specified: {}'.format(
repr(base_url)))
self._current_appliance.append(IPAppliance(urlparse(base_url)))
return self._current_appliance[-1]
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('start',
action="store_true",
default=False,
help='Start Merkyl?')
args = parser.parse_args()
if args.hostname is not None:
ip_a = IPAppliance(args.hostname)
else:
ip_a = IPAppliance.from_url()
ip_a.deploy_merkyl(args.start)
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()
print('Initializing Appliance Internal DB')
ip_a = IPAppliance(args.address)
status, out = ip_a.enable_internal_db(args.region)
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.')
def fn(method, *args, **kwargs):
"""Helper to access the right properties"""
app = IPAppliance(kwargs['appliance_ip'])
descriptor = getattr(IPAppliance, method)
if isinstance(descriptor, (cached_property, property)):
out = getattr(app, method)
else:
out = getattr(app, method)(*args, **kwargs)
if out is not None:
print(out)
def test_context_hack(monkeypatch):
ip_a = IPAppliance.from_url('http://127.0.0.2/')
def not_good(*k):
raise RuntimeError()
monkeypatch.setattr(ip_a, '_screenshot_capture_at_context_leave', not_good)
with pytest.raises(ValueError):
with ip_a:
raise ValueError("test")
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("-u", "--url", help="url(s) to use for update",
dest="urls", action="append")
parser.add_argument('--reboot', help='reboot after installation ' +
'(required for proper operation)', action="store_true")
args = parser.parse_args()
ip_a = IPAppliance(args.address)
status, out = ip_a.update_rhel(*args.urls)
if status == 0:
print out
print 'Appliance update complete'
if args.reboot:
ip_a.reboot()
return status
def main():
parser = argparse.ArgumentParser(epilog=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'--address',
help='hostname or ip address of target appliance', default=None)
parser.add_argument('--vddk_url', help='url to download vddk pkg')
parser.add_argument('--reboot', help='reboot after installation ' +
'(required for proper operation)', action="store_true")
parser.add_argument('--force',
help='force installation if version detected', action="store_true")
args = parser.parse_args()
if not args.address:
appliance = get_or_create_current_appliance()
else:
appliance = IPAppliance(address=urlparse(args.address).netloc)
appliance.install_vddk(
reboot=args.reboot, force=args.force, vddk_url=args.vddk_url, log_callback=log)
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("-u", "--url", help="url(s) to use for update",
dest="urls", action="append")
parser.add_argument('--reboot', help='reboot after installation ' +
'(required for proper operation)', action="store_true", default=False)
args = parser.parse_args()
ip_a = IPAppliance(args.address)
# Don't reboot here, so we can print updates to the console when we do
res = ip_a.update_rhel(*args.urls, reboot=False, streaming=True)
if res.rc == 0:
if args.reboot:
print 'Rebooting'
ip_a.reboot()
print 'Appliance update complete'
return res.rc
def main():
parser = argparse.ArgumentParser(epilog=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'--address',
help='hostname or ip address of target appliance',
default=parse_if_not_none(env.get("base_url", None)))
parser.add_argument(
'--sdk_url',
help='url to download sdk pkg',
default=cfme_data.get("basic_info", {}).get("netapp_sdk_url", None))
parser.add_argument('--restart', help='restart evmserverd after installation ' +
'(required for proper operation)', action="store_true")
args = parser.parse_args()
print('Address: {}'.format(args.address))
print('SDK URL: {}'.format(args.sdk_url))
print('Restart: {}'.format(args.restart))
appliance = IPAppliance(address=args.address)
appliance.install_netapp_sdk(sdk_url=args.sdk_url, reboot=args.restart, log_callback=log)
def test_context_hack(monkeypatch):
ip_a = IPAppliance.from_url('http://127.0.0.2/')
def not_good(*k):
raise RuntimeError()
monkeypatch.setattr(ip_a, '_screenshot_capture_at_context_leave', not_good)
with pytest.raises(ValueError):
with ip_a:
raise ValueError("test")
def main():
parser = argparse.ArgumentParser(
epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('address',
nargs='?',
default=None,
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()
return IPAppliance(args.address).patch_ajax_wait(args.reverse)
def provision_appliances(self,
count=1,
preconfigured=False,
version=None,
stream=None,
provider=None,
lease_time=120,
ram=None,
cpu=None):
# If we specify version, stream is ignored because we will get that specific version
if version:
stream = get_stream(version)
# If we specify stream but not version, sprout will give us latest version of that stream
elif stream:
pass
# If we dont specify either, we will get the same version as current appliance
else:
stream = get_stream(current_appliance.version)
version = current_appliance.version.vstring
request_id = self.call_method('request_appliances',
preconfigured=preconfigured,
version=version,
group=stream,
provider=provider,
lease_time=lease_time,
ram=ram,
cpu=cpu,
count=count)
wait_for(lambda: self.call_method('request_check', str(request_id))[
'finished'],
num_sec=300,
message='provision {} appliance(s) from sprout'.format(count))
data = self.call_method('request_check', str(request_id))
logger.debug(data)
appliances = []
for appliance in data['appliances']:
appliances.append(IPAppliance(appliance['ip_address']))
return appliances, request_id
def ipapp(self):
return IPAppliance(self.ip_address)
def test_ipappliance_from_address():
address = '1.2.3.4'
ip_a = IPAppliance(address)
assert ip_a.address == address
assert ip_a.url == 'https://{}/'.format(address)
def test_ipappliance_managed_providers(infra_provider):
ip_a = IPAppliance()
assert infra_provider in ip_a.managed_known_providers
def __init__(self, config):
self.config = config
self.session = None
self.session_finished = False
self.countfailures = 0
self.collection = OrderedDict()
self.sent_tests = 0
self.log = create_sublogger('master')
self.maxfail = config.getvalue("maxfail")
self._failed_collection_errors = {}
self.terminal = store.terminalreporter
self.trdist = None
self.slaves = SlaveDict()
self.slave_urls = SlaveDict()
self.slave_tests = defaultdict(set)
self.test_groups = self._test_item_generator()
self.failed_slave_test_groups = deque()
self.slave_spawn_count = 0
self.sprout_client = None
self.sprout_timer = None
self.sprout_pool = None
if not self.config.option.use_sprout:
# Without Sprout
self.appliances = self.config.option.appliances
else:
# Using sprout
self.sprout_client = SproutClient.from_config()
self.terminal.write(
"Requesting {} appliances from Sprout at {}\n".format(
self.config.option.sprout_appliances,
self.sprout_client.api_entry))
pool_id = self.sprout_client.request_appliances(
self.config.option.sprout_group,
count=self.config.option.sprout_appliances,
version=self.config.option.sprout_version,
date=self.config.option.sprout_date,
lease_time=self.config.option.sprout_timeout)
self.terminal.write(
"Pool {}. Waiting for fulfillment ...\n".format(pool_id))
self.sprout_pool = pool_id
at_exit(self.sprout_client.destroy_pool, self.sprout_pool)
if self.config.option.sprout_desc is not None:
self.sprout_client.set_pool_description(
pool_id, str(self.config.option.sprout_desc))
try:
result = wait_for(
lambda: self.sprout_client.request_check(self.sprout_pool)[
"fulfilled"],
num_sec=self.config.option.sprout_provision_timeout * 60,
delay=5,
message="requesting appliances was fulfilled")
except:
pool = self.sprout_client.request_check(self.sprout_pool)
dump_pool_info(lambda x: self.terminal.write("{}\n".format(x)),
pool)
self.terminal.write("Destroying the pool on error.\n")
self.sprout_client.destroy_pool(pool_id)
raise
else:
pool = self.sprout_client.request_check(self.sprout_pool)
dump_pool_info(lambda x: self.terminal.write("{}\n".format(x)),
pool)
self.terminal.write("Provisioning took {0:.1f} seconds\n".format(
result.duration))
request = self.sprout_client.request_check(self.sprout_pool)
self.appliances = []
# Push an appliance to the stack to have proper reference for test collection
IPAppliance(address=request["appliances"][0]["ip_address"]).push()
self.terminal.write("Appliances were provided:\n")
for appliance in request["appliances"]:
url = "https://{}/".format(appliance["ip_address"])
self.appliances.append(url)
self.terminal.write("- {} is {}\n".format(
url, appliance['name']))
map(lambda a: "https://{}/".format(a["ip_address"]),
request["appliances"])
self._reset_timer()
# Set the base_url for collection purposes on the first appliance
conf.runtime["env"]["base_url"] = self.appliances[0]
# Retrieve and print the template_name for Jenkins to pick up
template_name = request["appliances"][0]["template_name"]
conf.runtime["cfme_data"]["basic_info"][
"appliance_template"] = template_name
self.terminal.write(
"appliance_template=\"{}\";\n".format(template_name))
with project_path.join('.appliance_template').open(
'w') as template_file:
template_file.write(
'export appliance_template="{}"'.format(template_name))
self.terminal.write("Parallelized Sprout setup finished.\n")
self.slave_appliances_data = {}
for appliance in request["appliances"]:
self.slave_appliances_data[appliance["ip_address"]] = (
appliance["template_name"], appliance["provider"])
# set up the ipc socket
zmq_endpoint = 'tcp://127.0.0.1:{}'.format(random_port())
ctx = zmq.Context.instance()
self.sock = ctx.socket(zmq.ROUTER)
self.sock.bind('%s' % zmq_endpoint)
# clean out old slave config if it exists
slave_config = conf_path.join('slave_config.yaml')
slave_config.check() and slave_config.remove()
# write out the slave config
conf.runtime['slave_config'] = {
'args':
self.config.args,
'options':
self.config.option.__dict__,
'zmq_endpoint':
zmq_endpoint,
'sprout':
self.sprout_client is not None and self.sprout_pool is not None,
}
if hasattr(self, "slave_appliances_data"):
conf.runtime['slave_config'][
"appliance_data"] = self.slave_appliances_data
conf.runtime['slave_config']['options'][
'use_sprout'] = False # Slaves don't use sprout
conf.save('slave_config')
for i, base_url in enumerate(self.appliances):
self.slave_urls.add(base_url)
for slave in sorted(self.slave_urls):
self.print_message("using appliance {}".format(
self.slave_urls[slave]),
slave,
green=True)
# Start the recv queue
self._recv_queue = deque()
recv_queuer = Thread(target=_recv_queue, args=(self, ))
recv_queuer.daemon = True
recv_queuer.start()
def current_appliance(self):
if not self._current_appliance:
from utils.appliance import IPAppliance
self._current_appliance.append(IPAppliance(urlparse(conf.env['base_url'])))
return self._current_appliance[-1]
def test_workload_capacity_and_utilization_rep(appliance, request, scenario, setup_perf_provider):
"""Runs through provider based scenarios enabling C&U and replication, run for a set period of
time. Memory Monitor creates graphs and summary at the end of each scenario."""
from_ts = int(time.time() * 1000)
ssh_client = appliance.ssh_client()
ssh_master_args = {
'hostname': scenario['replication_master']['ip_address'],
'username': scenario['replication_master']['ssh']['username'],
'password': scenario['replication_master']['ssh']['password']}
master_appliance = IPAppliance(address=scenario['replication_master']['ip_address'],
openshift_creds=ssh_master_args)
ssh_client_master = SSHClient(**ssh_master_args)
logger.debug('Scenario: {}'.format(scenario['name']))
is_pglogical = True if scenario['replication'] == 'pglogical' else False
# Turn off master pglogical replication incase rubyrep scenario follows a pglogical scenario
appliance.set_pglogical_replication(replication_type=':none')
# Spawn tail before hand to prevent unncessary waiting on MiqServer starting since applinace
# under test is cleaned first, followed by master appliance
sshtail_evm = SSHTail('/var/www/miq/vmdb/log/evm.log')
sshtail_evm.set_initial_file_end()
logger.info('Clean appliance under test ({})'.format(ssh_client))
appliance.clean_appliance()
logger.info('Clean master appliance ({})'.format(ssh_client_master))
master_appliance.clean_appliance() # Clean Replication master appliance
if is_pglogical:
scenario_data = {'appliance_ip': appliance.hostname,
'appliance_name': cfme_performance['appliance']['appliance_name'],
'test_dir': 'workload-cap-and-util-rep',
'test_name': 'Capacity and Utilization Replication (pgLogical)',
'appliance_roles': ', '.join(roles_cap_and_util_rep),
'scenario': scenario}
else:
scenario_data = {'appliance_ip': cfme_performance['appliance']['ip_address'],
'appliance_name': cfme_performance['appliance']['appliance_name'],
'test_dir': 'workload-cap-and-util-rep',
'test_name': 'Capacity and Utilization Replication (RubyRep)',
'appliance_roles': ', '.join(roles_cap_and_util_rep),
'scenario': scenario}
quantifiers = {}
monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data)
def cleanup_workload(scenario, 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(scenario, from_ts, quantifiers, scenario_data))
monitor_thread.start()
appliance.wait_for_miq_server_workers_started(evm_tail=sshtail_evm, poll_interval=2)
appliance.update_server_roles({role: True for role in roles_cap_and_util_rep})
for provider in scenario['providers']:
get_crud(provider).create_rest()
logger.info('Sleeping for Refresh: {}s'.format(scenario['refresh_sleep_time']))
time.sleep(scenario['refresh_sleep_time'])
appliance.set_cap_and_util_all_via_rails()
# Configure Replication
if is_pglogical:
# Setup appliance under test to :remote
appliance.set_pglogical_replication(replication_type=':remote')
# Setup master appliance to :global
master_appliance.set_pglogical_replication(replication_type=':global')
# Setup master to subscribe:
master_appliance.add_pglogical_replication_subscription(ssh_client_master,
appliance.address)
else:
# Setup local towards Master
appliance.set_rubyrep_replication(scenario['replication_master']['ip_address'])
# Force uninstall rubyrep for this region from master (Unsure if still needed)
# ssh_client.run_rake_command('evm:dbsync:uninstall')
# time.sleep(30) # Wait to quiecse
# Turn on DB Sync role
appliance.update_server_roles({role: True for role in roles_cap_and_util_rep})
# Variable amount of time for C&U collections/processing
total_time = scenario['total_time']
starttime = time.time()
elapsed_time = 0
while (elapsed_time < total_time):
elapsed_time = time.time() - starttime
time_left = total_time - elapsed_time
logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time))
if (time_left > 0 and time_left < 300):
time.sleep(time_left)
elif time_left > 0:
time.sleep(300)
# Turn off replication:
if is_pglogical:
appliance.set_pglogical_replication(replication_type=':none')
else:
appliance.update_server_roles({role: True for role in roles_cap_and_util_rep})
quantifiers['Elapsed_Time'] = round(elapsed_time, 2)
logger.info('Test Ending...')
def get(self, slave):
with self.pool_lock:
if not self._pool:
for test_group in self.test_groups:
self._pool.append(test_group)
for test in test_group:
if '[' in test:
found_prov = []
for pv in self.provs:
if pv in test:
found_prov.append(pv)
break
provs = list(set(found_prov).intersection(self.provs))
if provs:
self.used_prov = self.used_prov.union(set(provs))
if self.used_prov:
self.ratio = float(len(self.slaves)) / float(len(self.used_prov))
else:
self.ratio = 0.0
if not self._pool:
raise StopIteration
current_allocate = self.slave_allocation.get(slave, None)
# num_provs_list = [len(v) for k, v in self.slave_allocation.iteritems()]
# average_num_provs = sum(num_provs_list) / float(len(self.slaves))
appliance_num_limit = 2
for test_group in self._pool:
for test in test_group:
# If the test is parametrized...
if '[' in test:
found_prov = []
for pv in self.provs:
if pv in test:
found_prov.append(pv)
break
# The line below can probably be removed now, since we compare
# providers in the loop above with self.provs, which is a list
# of all providers.
provs = list(set(found_prov).intersection(self.provs))
# If the parametrization contains a provider...
if provs:
prov = provs[0]
# num_slave_with_prov = len([sl for sl, provs_list
# in self.slave_allocation.iteritems()
# if prov in provs_list])
# If this slave/appliance already has providers then...
if current_allocate:
# If the slave has _our_ provider
if prov in current_allocate:
# provider is already with the slave, so just return the tests
self._pool.remove(test_group)
return test_group
# If the slave doesn't have _our_ provider
else:
# Check to see how many slaves there are with this provider
if len(self.slave_allocation[slave]) >= appliance_num_limit:
continue
else:
# Adding provider to slave since there are not too many
self.slave_allocation[slave].append(prov)
self._pool.remove(test_group)
return test_group
# If this slave doesn't have any providers...
else:
# Adding provider to slave
self.slave_allocation[slave].append(prov)
self._pool.remove(test_group)
return test_group
else:
# No providers - ie, not a provider parametrized test
self._pool.remove(test_group)
return test_group
else:
# No params, so no need to think about providers
self._pool.remove(test_group)
return test_group
# Here means no tests were able to be sent
for test_group in self._pool:
for test in test_group:
# If the test is parametrized...
if '[' in test:
found_prov = []
for pv in self.provs:
if pv in test:
found_prov.append(pv)
break
# The line below can probably be removed now, since we compare
# providers in the loop above with self.provs, which is a list
# of all providers.
provs = list(set(found_prov).intersection(self.provs))
# If the parametrization contains a provider...
if provs:
# Already too many slaves with provider
app_url = self.slave_urls[slave]
app_ip = urlparse(app_url).netloc
app = IPAppliance(app_ip)
self.print_message('cleansing appliance', slave,
purple=True)
try:
app.delete_all_providers()
except:
self.print_message('cloud not cleanse', slave,
red=True)
self.slave_allocation[slave] = [prov]
self._pool.remove(test_group)
return test_group
return []
def test_ipappliance_from_url():
address = '1.2.3.4'
url = 'http://%s/' % address
ip_a = IPAppliance.from_url(url)
assert ip_a.url == url
assert ip_a.address == address
def main(**kwargs):
# get_mgmt validates, since it will explode without an existing key or type
if kwargs.get("deploy", None):
kwargs["configure"] = True
kwargs["outfile"] = "appliance_ip_address_1"
provider_data = utils.conf.provider_data
providers = provider_data["management_systems"]
provider_dict = provider_data["management_systems"][kwargs["provider"]]
credentials = {
"username": provider_dict["username"],
"password": provider_dict["password"],
"tenant": provider_dict["template_upload"].get("tenant_admin", "admin"),
"auth_url": provider_dict.get("auth_url", None),
}
provider = get_mgmt(kwargs["provider"], providers=providers, credentials=credentials)
flavors = provider_dict["template_upload"].get("flavors", ["m1.medium"])
provider_type = provider_data["management_systems"][kwargs["provider"]]["type"]
deploy_args = {"vm_name": kwargs["vm_name"], "template": kwargs["template"]}
else:
provider = get_mgmt(kwargs["provider"])
provider_dict = cfme_data["management_systems"][kwargs["provider"]]
provider_type = provider_dict["type"]
flavors = cfme_data["appliance_provisioning"]["default_flavors"].get(provider_type, [])
deploy_args = {"vm_name": kwargs["vm_name"], "template": kwargs["template"]}
logger.info("Connecting to {}".format(kwargs["provider"]))
if kwargs.get("destroy", None):
# TODO: destroy should be its own script
# but it's easy enough to just hijack the parser here
# This returns True if destroy fails to give POSIXy exit codes (0 is good, False is 0, etc)
return not destroy_vm(provider, deploy_args["vm_name"])
# Try to snag defaults from cfme_data here for each provider type
if provider_type == "rhevm":
cluster = provider_dict.get("default_cluster", kwargs.get("cluster", None))
if cluster is None:
raise Exception("--cluster is required for rhev instances and default is not set")
deploy_args["cluster"] = cluster
if kwargs.get("place_policy_host", None) and kwargs.get("place_policy_aff", None):
deploy_args["placement_policy_host"] = kwargs["place_policy_host"]
deploy_args["placement_policy_affinity"] = kwargs["place_policy_aff"]
elif provider_type == "ec2":
# ec2 doesn't have an api to list available flavors, so the first flavor is the default
try:
flavor = kwargs.get("flavor", None) or flavors[0]
except IndexError:
raise Exception("--flavor is required for EC2 instances and default is not set")
deploy_args["instance_type"] = flavor
elif provider_type == "openstack":
# filter openstack flavors based on what's available
available_flavors = provider.list_flavor()
flavors = filter(lambda f: f in available_flavors, flavors)
try:
flavor = kwargs.get("flavor", None) or flavors[0]
except IndexError:
raise Exception(
"--flavor is required for RHOS instances and " "default is not set or unavailable on provider"
)
# flavour? Thanks, psav...
deploy_args["flavour_name"] = flavor
if "network" in provider_dict:
# support rhos4 network names
deploy_args["network_name"] = provider_dict["network"]
provider_pools = [p.name for p in provider.api.floating_ip_pools.list()]
try:
# TODO: If there are multiple pools, have a provider default in cfme_data
floating_ip_pool = kwargs.get("floating_ip_pool", None) or provider_pools[0]
except IndexError:
raise Exception("No floating IP pools available on provider")
if floating_ip_pool is not None:
deploy_args["floating_ip_pool"] = floating_ip_pool
elif provider_type == "virtualcenter":
if "allowed_datastores" in provider_dict:
deploy_args["allowed_datastores"] = provider_dict["allowed_datastores"]
elif provider_type == "scvmm":
deploy_args["host_group"] = provider_dict["provisioning"]["host_group"]
elif provider_type == "gce":
deploy_args["ssh_key"] = "{user_name}:{public_key}".format(
user_name=cred["ssh"]["ssh-user"], public_key=cred["ssh"]["public_key"]
)
# Do it!
try:
logger.info(
"Cloning {} to {} on {}".format(deploy_args["template"], deploy_args["vm_name"], kwargs["provider"])
)
provider.deploy_template(**deploy_args)
except Exception as e:
logger.exception(e)
logger.error("Clone failed")
if kwargs.get("cleanup", None):
logger.info("attempting to destroy {}".format(deploy_args["vm_name"]))
destroy_vm(provider, deploy_args["vm_name"])
return 12
if provider.is_vm_running(deploy_args["vm_name"]):
logger.info("VM {} is running".format(deploy_args["vm_name"]))
else:
logger.error("VM is not running")
return 10
try:
ip, time_taken = wait_for(provider.get_ip_address, [deploy_args["vm_name"]], num_sec=1200, fail_condition=None)
logger.info("IP Address returned is {}".format(ip))
except Exception as e:
logger.exception(e)
logger.error("IP address not returned")
return 10
try:
if kwargs.get("configure", None):
logger.info("Configuring appliance, this can take a while.")
if kwargs.get("deploy", None):
app = IPAppliance(address=ip)
else:
app = Appliance(kwargs["provider"], deploy_args["vm_name"])
if provider_type == "gce":
app.configure_gce()
else:
app.configure()
logger.info("Successfully Configured the appliance.")
except Exception as e:
logger.exception(e)
logger.error("Appliance Configuration Failed")
if not kwargs.get("deploy", None):
app = Appliance(kwargs["provider"], deploy_args["vm_name"])
ssh_client = app.ssh_client()
status, output = ssh_client.run_command("find /root/anaconda-post.log")
if status == 0:
ssh_client.get_file("/root/anaconda-post.log", log_path.join("anaconda-post.log").strpath)
ssh_client.close()
return 10
if kwargs.get("outfile", None) or kwargs.get("deploy", None):
with open(kwargs["outfile"], "w") as outfile:
outfile.write("appliance_ip_address={}\n".format(ip))
# In addition to the outfile, drop the ip address on stdout for easy parsing
print(ip)
def main(**kwargs):
# get_mgmt validates, since it will explode without an existing key or type
if kwargs.get('deploy', None):
kwargs['configure'] = True
provider_data = utils.conf.provider_data
providers = provider_data['management_systems']
provider_dict = provider_data['management_systems'][kwargs['provider']]
credentials =\
{'username': provider_dict['username'],
'password': provider_dict['password'],
'tenant': provider_dict['template_upload'].get('tenant_admin', 'admin'),
'auth_url': provider_dict.get('auth_url', None),
}
provider = get_mgmt(kwargs['provider'], providers=providers, credentials=credentials)
flavors = provider_dict['template_upload'].get('flavors', ['m1.medium'])
provider_type = provider_data['management_systems'][kwargs['provider']]['type']
deploy_args = {
'vm_name': kwargs['vm_name'],
'template': kwargs['template'],
}
else:
provider = get_mgmt(kwargs['provider'])
provider_dict = cfme_data['management_systems'][kwargs['provider']]
provider_type = provider_dict['type']
flavors = cfme_data['appliance_provisioning']['default_flavors'].get(provider_type, [])
deploy_args = {
'vm_name': kwargs['vm_name'],
'template': kwargs['template'],
}
logger.info('Connecting to {}'.format(kwargs['provider']))
if kwargs.get('destroy', None):
# TODO: destroy should be its own script
# but it's easy enough to just hijack the parser here
# This returns True if destroy fails to give POSIXy exit codes (0 is good, False is 0, etc)
return not destroy_vm(provider, deploy_args['vm_name'])
# Try to snag defaults from cfme_data here for each provider type
if provider_type == 'rhevm':
cluster = provider_dict.get('default_cluster', kwargs.get('cluster', None))
if cluster is None:
raise Exception('--cluster is required for rhev instances and default is not set')
deploy_args['cluster'] = cluster
if kwargs.get('place_policy_host', None) and kwargs.get('place_policy_aff', None):
deploy_args['placement_policy_host'] = kwargs['place_policy_host']
deploy_args['placement_policy_affinity'] = kwargs['place_policy_aff']
elif provider_type == 'ec2':
# ec2 doesn't have an api to list available flavors, so the first flavor is the default
try:
flavor = kwargs.get('flavor', None) or flavors[0]
except IndexError:
raise Exception('--flavor is required for EC2 instances and default is not set')
deploy_args['instance_type'] = flavor
elif provider_type == 'openstack':
# filter openstack flavors based on what's available
available_flavors = provider.list_flavor()
flavors = filter(lambda f: f in available_flavors, flavors)
try:
flavor = kwargs.get('flavor', None) or flavors[0]
except IndexError:
raise Exception('--flavor is required for RHOS instances and '
'default is not set or unavailable on provider')
# flavour? Thanks, psav...
deploy_args['flavour_name'] = flavor
if 'network' in provider_dict:
# support rhos4 network names
deploy_args['network_name'] = provider_dict['network']
provider_pools = [p.name for p in provider.api.floating_ip_pools.list()]
try:
# TODO: If there are multiple pools, have a provider default in cfme_data
floating_ip_pool = kwargs.get('floating_ip_pool', None) or provider_pools[0]
except IndexError:
raise Exception('No floating IP pools available on provider')
if floating_ip_pool is not None:
deploy_args['floating_ip_pool'] = floating_ip_pool
elif provider_type == "virtualcenter":
if "allowed_datastores" in provider_dict:
deploy_args["allowed_datastores"] = provider_dict["allowed_datastores"]
elif provider_type == 'scvmm':
deploy_args["host_group"] = provider_dict["provisioning"]['host_group']
# Do it!
try:
logger.info('Cloning {} to {} on {}'.format(deploy_args['template'], deploy_args['vm_name'],
kwargs['provider']))
provider.deploy_template(**deploy_args)
except Exception as e:
logger.exception(e)
logger.error('Clone failed')
if kwargs.get('cleanup', None):
logger.info('attempting to destroy {}'.format(deploy_args['vm_name']))
destroy_vm(provider, deploy_args['vm_name'])
return 12
if provider.is_vm_running(deploy_args['vm_name']):
logger.info("VM {} is running".format(deploy_args['vm_name']))
else:
logger.error("VM is not running")
return 10
try:
ip, time_taken = wait_for(provider.get_ip_address, [deploy_args['vm_name']], num_sec=1200,
fail_condition=None)
logger.info('IP Address returned is {}'.format(ip))
except Exception as e:
logger.exception(e)
logger.error('IP address not returned')
return 10
try:
if kwargs.get('configure', None):
logger.info('Configuring appliance, this can take a while.')
if kwargs.get('deploy', None):
app = IPAppliance(address=ip)
else:
app = Appliance(kwargs['provider'], deploy_args['vm_name'])
app.configure()
logger.info('Successfully Configured the appliance.')
except Exception as e:
logger.exception(e)
logger.error('Appliance Configuration Failed')
if not kwargs.get('deploy', None):
app = Appliance(kwargs['provider'], deploy_args['vm_name'])
ssh_client = app.ssh_client()
status, output = ssh_client.run_command('find /root/anaconda-post.log')
if status == 0:
ssh_client.get_file('/root/anaconda-post.log',
log_path.join('anaconda-post.log').strpath)
ssh_client.close()
return 10
if kwargs.get('outfile', None):
with open(kwargs['outfile'], 'w') as outfile:
outfile.write("appliance_ip_address={}\n".format(ip))
# In addition to the outfile, drop the ip address on stdout for easy parsing
print(ip)
def test_ipappliance_from_url():
address = '1.2.3.4'
url = 'http://%s/' % address
ip_a = IPAppliance.from_url(url)
assert ip_a.url == url
assert ip_a.address == address
for pluginarg in config.option.plugins:
config.pluginmanager.consider_pluginarg(pluginarg)
config.pluginmanager.consider_pluginarg('no:fixtures.parallelizer')
return config
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('slaveid', help='The name of this slave')
parser.add_argument('appliance_json', help='The json data about the used appliance')
parser.add_argument('ts', help='The timestap to use for collections')
args = parser.parse_args()
from utils.appliance import IPAppliance, stack
appliance = IPAppliance.from_json(args.appliance_json)
stack.push(appliance)
# overwrite the default logger before anything else is imported,
# to get our best chance at having everything import the replaced logger
import utils.log
utils.log.setup_for_worker(args.slaveid)
from fixtures import terminalreporter
from fixtures.pytest_store import store
from utils import conf
conf.runtime['env']['slaveid'] = args.slaveid
conf.runtime['env']['ts'] = args.ts
store.parallelizer_role = 'slave'
def test_ipappliance_from_url():
address = '1.2.3.4'
url = 'http://{}/'.format(address)
ip_a = IPAppliance.from_url(url)
assert ip_a.url == url
assert ip_a.address == address
def test_ipappliance_from_url():
address = '1.2.3.4'
url = 'http://{}/'.format(address)
ip_a = IPAppliance.from_url(url)
assert ip_a.url == url
assert ip_a.address == address
def main(**kwargs):
# get_mgmt validates, since it will explode without an existing key or type
if kwargs.get('deploy', None):
kwargs['configure'] = True
kwargs['outfile'] = 'appliance_ip_address_1'
provider_data = utils.conf.provider_data
providers = provider_data['management_systems']
provider_dict = provider_data['management_systems'][kwargs['provider']]
credentials =\
{'username': provider_dict['username'],
'password': provider_dict['password'],
'tenant': provider_dict['template_upload'].get('tenant_admin', 'admin'),
'auth_url': provider_dict.get('auth_url', None),
}
provider = get_mgmt(kwargs['provider'], providers=providers, credentials=credentials)
flavors = provider_dict['template_upload'].get('flavors', ['m1.medium'])
provider_type = provider_data['management_systems'][kwargs['provider']]['type']
deploy_args = {
'vm_name': kwargs['vm_name'],
'template': kwargs['template'],
}
else:
provider = get_mgmt(kwargs['provider'])
provider_dict = cfme_data['management_systems'][kwargs['provider']]
provider_type = provider_dict['type']
flavors = cfme_data['appliance_provisioning']['default_flavors'].get(provider_type, [])
deploy_args = {
'vm_name': kwargs['vm_name'],
'template': kwargs['template'],
}
logger.info('Connecting to {}'.format(kwargs['provider']))
if kwargs.get('destroy', None):
# TODO: destroy should be its own script
# but it's easy enough to just hijack the parser here
# This returns True if destroy fails to give POSIXy exit codes (0 is good, False is 0, etc)
return not destroy_vm(provider, deploy_args['vm_name'])
# Try to snag defaults from cfme_data here for each provider type
if provider_type == 'rhevm':
cluster = provider_dict.get('default_cluster', kwargs.get('cluster', None))
if cluster is None:
raise Exception('--cluster is required for rhev instances and default is not set')
deploy_args['cluster'] = cluster
if kwargs.get('place_policy_host', None) and kwargs.get('place_policy_aff', None):
deploy_args['placement_policy_host'] = kwargs['place_policy_host']
deploy_args['placement_policy_affinity'] = kwargs['place_policy_aff']
elif provider_type == 'ec2':
# ec2 doesn't have an api to list available flavors, so the first flavor is the default
try:
flavor = kwargs.get('flavor', None) or flavors[0]
except IndexError:
raise Exception('--flavor is required for EC2 instances and default is not set')
deploy_args['instance_type'] = flavor
elif provider_type == 'openstack':
# filter openstack flavors based on what's available
available_flavors = provider.list_flavor()
flavors = filter(lambda f: f in available_flavors, flavors)
try:
flavor = kwargs.get('flavor', None) or flavors[0]
except IndexError:
raise Exception('--flavor is required for RHOS instances and '
'default is not set or unavailable on provider')
# flavour? Thanks, psav...
deploy_args['flavour_name'] = flavor
if 'network' in provider_dict:
# support rhos4 network names
deploy_args['network_name'] = provider_dict['network']
provider_pools = [p.name for p in provider.api.floating_ip_pools.list()]
try:
# TODO: If there are multiple pools, have a provider default in cfme_data
floating_ip_pool = kwargs.get('floating_ip_pool', None) or provider_pools[0]
except IndexError:
raise Exception('No floating IP pools available on provider')
if floating_ip_pool is not None:
deploy_args['floating_ip_pool'] = floating_ip_pool
elif provider_type == "virtualcenter":
if "allowed_datastores" in provider_dict:
deploy_args["allowed_datastores"] = provider_dict["allowed_datastores"]
elif provider_type == 'scvmm':
deploy_args["host_group"] = provider_dict["provisioning"]['host_group']
elif provider_type == 'gce':
deploy_args['ssh_key'] = '{user_name}:{public_key}'.format(
user_name=cred['ssh']['ssh-user'],
public_key=cred['ssh']['public_key'])
# Do it!
try:
logger.info('Cloning {} to {} on {}'.format(deploy_args['template'], deploy_args['vm_name'],
kwargs['provider']))
provider.deploy_template(**deploy_args)
except Exception as e:
logger.exception(e)
logger.error('Clone failed')
if kwargs.get('cleanup', None):
logger.info('attempting to destroy {}'.format(deploy_args['vm_name']))
destroy_vm(provider, deploy_args['vm_name'])
return 12
if provider.is_vm_running(deploy_args['vm_name']):
logger.info("VM {} is running".format(deploy_args['vm_name']))
else:
logger.error("VM is not running")
return 10
try:
ip, time_taken = wait_for(provider.get_ip_address, [deploy_args['vm_name']], num_sec=1200,
fail_condition=None)
logger.info('IP Address returned is {}'.format(ip))
except Exception as e:
logger.exception(e)
logger.error('IP address not returned')
return 10
try:
if kwargs.get('configure', None):
logger.info('Configuring appliance, this can take a while.')
if kwargs.get('deploy', None):
app = IPAppliance(address=ip)
else:
app = Appliance(kwargs['provider'], deploy_args['vm_name'])
if provider_type == 'gce':
with app as ipapp:
ipapp.configure_gce()
else:
app.configure()
logger.info('Successfully Configured the appliance.')
except Exception as e:
logger.exception(e)
logger.error('Appliance Configuration Failed')
if not kwargs.get('deploy', None):
app = Appliance(kwargs['provider'], deploy_args['vm_name'])
ssh_client = app.ssh_client()
status, output = ssh_client.run_command('find /root/anaconda-post.log')
if status == 0:
ssh_client.get_file('/root/anaconda-post.log',
log_path.join('anaconda-post.log').strpath)
ssh_client.close()
return 10
if kwargs.get('outfile', None) or kwargs.get('deploy', None):
with open(kwargs['outfile'], 'w') as outfile:
outfile.write("appliance_ip_address={}\n".format(ip))
# In addition to the outfile, drop the ip address on stdout for easy parsing
print(ip)
