def main(): result = True try: params = {} envs_dir = os.path.join(os.getcwd(), 'cf-smoke-tests', 'environments') global_params_file = os.path.join(envs_dir, 'global-pipeline-vars.yml') params = yaml.full_load(open(global_params_file, 'r')) dirs = os.listdir(envs_dir) for d in dirs: foundation_dir = os.path.join(envs_dir, d) if os.path.isdir(foundation_dir): params_file = os.path.join(foundation_dir, 'pipeline-vars.yml') params.update(yaml.full_load(open(params_file, 'r'))) print("Deploying smoke-test-pipline for foundation {}".format( params['FOUNDATION'])) login_cmd = "fly --target ci-{} login --concourse-url {} -k --username {} --password {} --team-name {}".format( params['FOUNDATION'], params['CONCOURSE_URL'], params['CONCOURSE_USERNAME'], os.environ['CONCOURSE_PASSWORD_FOR_{}'.format( params['FOUNDATION'])], params['FOUNDATION']) if not utils.run_cmd(login_cmd, False): print("Fly login failed for {}".format( params['FOUNDATION'])) continue cmd = "fly --target ci-{} login --concourse-url {} -k --username {} --password {} --team-name {}".format( params['FOUNDATION'], params['CONCOURSE_URL'], params['CONCOURSE_USERNAME'], "[Redacted Password]", params['FOUNDATION']) print(cmd) sync_cmd = "fly -t ci-{} sync".format(params['FOUNDATION']) if not utils.run_cmd(sync_cmd): print("Fly sync failed for {}".format( params['FOUNDATION'])) continue smoke_test_pipeline = os.path.join(os.getcwd(), 'cf-smoke-tests', 'ci', 'pipelines', 'pipeline.yml') set_pipeline_cmd = "fly --target ci-{} set-pipeline -c {} -p {} -l {} -l {} --non-interactive".format( params['FOUNDATION'], smoke_test_pipeline, params['PIPELINE_NAME'], global_params_file, params_file) if not utils.run_cmd(set_pipeline_cmd): print("Fly set-pipeline failed for {}".format( params['FOUNDATION'])) continue unpause_pipeline_cmd = "fly --target ci-{} unpause-pipeline -p {}".format( params['FOUNDATION'], params['PIPELINE_NAME']) if not utils.run_cmd(unpause_pipeline_cmd): print("Fly unpause-pipeline failed for {}".format( params['FOUNDATION'])) continue except Exception as e: print(str(e)) result = False return not result
def gemfire_write_helper(gfsh_cli, connect_cmd, region, key, value): write_cmd = "\"put --region=/{} --key={} --value='{}'\"".format( region, key, value) cmd = "{} -e {} -e {}".format(gfsh_cli, connect_cmd, write_cmd) if not utils.run_cmd(cmd, False): return False return True
def get_osx_platform_path(): cmd = "xcodebuild -showsdks" (stdout, stderr) = utils.run_cmd(cmd) if stderr != "": print(stderr) sys.exit(1) match = re.search(r"(-sdk macosx\d+.\d+)", stdout, flags=re.MULTILINE) if not match: print("coundn't parse output of:\n", cmd, "\naborting!") sys.exit(1) sdkparam = match.group(0) cmd = "xcodebuild -version " + sdkparam + " Path" (sdkPath, stderr) = utils.run_cmd(cmd) if stderr != "": print(stderr) sys.exit(1) print("using sdk path:", sdkPath.rstrip()) return sdkPath.rstrip()
def extract_gemfire_tar(): cmd = "tar -xzf {}-{}.tgz".format(gemfire_product, gemfire_product_version) if utils.run_cmd(cmd): os.environ['GEMFIRE_HOME'] = os.path.join( os.getcwd(), "{}-{}".format(gemfire_product, gemfire_product_version)) if not os.listdir(os.environ['GEMFIRE_HOME']): return False os.environ['GFSH_CLI'] = os.path.join(os.environ['GEMFIRE_HOME'], 'bin', 'gfsh') return True else: return False
def check_autoscaling_app_state(appname): if not common_tests.login(os.environ["SMOKE_USER"], os.environ["SMOKE_PASSWORD"], "system", "autoscaling"): return False cmd = "cf curl /v2/apps?q=name:{}".format(appname) status, out = utils.run_cmd(cmd, True, False, True) if status and json.loads(out)['total_results'] > 0: if json.loads(out)['resources'][0]['entity']['state'] == 'STARTED': return True else: print("Going to start the {} app...".format(appname)) if not common_tests.start_app(appname): raise Exception( 'Attempt to start the {} app failed'.format(appname)) elif status and json.loads(out)['total_results'] == 0: raise Exception('{} app was not found'.format(appname)) else: return False
def gemfire_create_regions(): if 'GFSH_CLI' not in os.environ or \ 'GEMFIRE_URL' not in os.environ or \ 'GEMFIRE_USER' not in os.environ or \ 'GEMFIRE_PASSWORD' not in os.environ: return False print('>>> Creating regions in gemfire cluster using gfsh cli...') connect_cmd = "\"connect --use-http --url={} --user={} --password={}\"".format( os.environ['GEMFIRE_URL'], os.environ['GEMFIRE_USER'], os.environ['GEMFIRE_PASSWORD']) create_test_region_cmd = "\"create region --name=test --type=PARTITION_REDUNDANT --redundant-copies=1\"" create_partitioned_region_cmd = "\"create region --name=partitioned --type=PARTITION_REDUNDANT --redundant-copies=1\"" create_replicated_region_cmd = "\"create region --name=replicated --type=REPLICATE\"" cmd = "{} -e {} -e {} -e {} -e {}".format(os.environ['GFSH_CLI'], connect_cmd, create_test_region_cmd, create_partitioned_region_cmd, create_replicated_region_cmd) return utils.run_cmd(cmd, False)
def main(): result = True results = {} print("Starting AUTO-SCALING smoke-test...") start = time.time() try: os.environ['CF_DIAL_TIMEOUT'] = "30" print(os.environ['CF_DIAL_TIMEOUT']) results['autoscale_state'] = check_autoscaling_app_state('autoscale') if not results['autoscale_state']: raise Exception('autoscale app is down') results['autoscale_api_state'] = check_autoscaling_app_state( 'autoscale-api') if not results['autoscale_api_state']: raise Exception('autoscale-api app is down') results['set_api'] = common_tests.set_api() if not results['set_api']: raise Exception('set_api failed') results['authenticate'] = common_tests.authenticate() if not results['authenticate']: raise Exception('authenticate failed') results['set_target'] = common_tests.set_target() if not results['set_target']: raise Exception('set_target failed') results['pivnet_login'] = common_tests.pivnet_login() if not results['pivnet_login']: raise Exception('pivnet_login failed') results[ 'pivnet_get_product_id'], product_id = common_tests.pivnet_get_product_id( autoscaler_product, autoscaler_product_version, 'linux64') if not results['pivnet_get_product_id']: raise Exception('pivnet_get_product_id failed') results['pivnet_accept_eula'] = common_tests.pivnet_accept_eula( autoscaler_product, autoscaler_product_version) if not results['pivnet_accept_eula']: raise Exception('pivnet_accept_eula failed') results[ 'pivnet_download_product_files'] = common_tests.pivnet_download_product_files( autoscaler_product, autoscaler_product_version, product_id) if not results['pivnet_download_product_files']: raise Exception('pivnet_download_product_files failed') results['pivnet_logout'] = common_tests.pivnet_logout() if not results['pivnet_logout']: raise Exception('pivnet_logout failed') results['install_autoscaler_plugin'] = utils.run_cmd( "cf install-plugin -f {}".format( os.path.join(os.getcwd(), glob.glob('autoscaler-for-pcf-*')[0]))) if not results['install_autoscaler_plugin']: raise Exception('install_autoscaler_plugin failed') results['create_service'] = common_tests.create_service( autoscaler_service_name, autoscaler_service_plan, autoscaler_service_instance) if not results['create_service']: raise Exception('create_service failed') manifest_path = os.path.join(autoscaler_sample_app_path, 'manifest.yml') params = "{} -f {} -p {} --no-start".format( autoscaler_sample_app, manifest_path, autoscaler_sample_app_path) results['push_app'] = common_tests.push_app(params) if not results['push_app']: results['get_app_logs'] = common_tests.get_app_logs( autoscaler_sample_app) raise Exception('push_app failed') results['bind_service'] = common_tests.bind_service( autoscaler_sample_app, autoscaler_service_instance) if not results['bind_service']: raise Exception('bind_service failed') results['start_app'] = common_tests.start_app(autoscaler_sample_app) if not results['start_app']: results['get_app_logs'] = common_tests.get_app_logs( autoscaler_sample_app) raise Exception('start_app failed') min_instances = 3 max_instances = 5 results['update_autoscaling_limits'] = utils.run_cmd( "cf update-autoscaling-limits {} {} {}".format( autoscaler_sample_app, min_instances, max_instances)) if not results['update_autoscaling_limits']: raise Exception('update_autoscaling_limits failed') results['enable_autoscaling'] = utils.run_cmd( "cf enable-autoscaling {}".format(autoscaler_sample_app)) if not results['enable_autoscaling']: raise Exception('enable_autoscaling failed') results['autoscaling_apps'] = utils.run_cmd("cf autoscaling-apps") if not results['autoscaling_apps']: raise Exception('autoscaling_apps failed') results['autoscaling_rules'] = utils.run_cmd( "cf autoscaling-rules {}".format(autoscaler_sample_app)) if not results['autoscaling_rules']: raise Exception('autoscaling_rules failed') results['create_rule_http_throughput'] = utils.run_cmd( "cf create-autoscaling-rule {} http_throughput 10 50".format( autoscaler_sample_app)) if not results['create_rule_http_throughput']: raise Exception('create_rule_http_throughput failed') results['create_rule_http_latency'] = utils.run_cmd( "cf create-autoscaling-rule {} http_latency 10 20 -s avg_99th". format(autoscaler_sample_app)) if not results['create_rule_http_latency']: raise Exception('create_rule_http_latency failed') results['create_rule_cpu'] = utils.run_cmd( "cf create-autoscaling-rule {} cpu 10 60".format( autoscaler_sample_app)) if not results['create_rule_cpu']: raise Exception('create_rule_cpu failed') results['create_rule_memory'] = utils.run_cmd( "cf create-autoscaling-rule {} memory 20 80".format( autoscaler_sample_app)) if not results['create_rule_memory']: raise Exception('create_rule_memory failed') results['autoscaling_rules'] = utils.run_cmd( "cf autoscaling-rules {}".format(autoscaler_sample_app)) if not results['autoscaling_rules']: raise Exception('autoscaling_rules failed') generate_http_traffic() results['autoscaling_events'] = utils.run_cmd( "cf autoscaling-events {}".format(autoscaler_sample_app)) if not results['autoscaling_events']: raise Exception('autoscaling_events failed') except Exception as e: print(str(e)) result = False finally: try: results['delete_autoscaling_rules'] = utils.run_cmd( "cf delete-autoscaling-rules -f {}".format( autoscaler_sample_app)) if not results['delete_autoscaling_rules']: print('delete_autoscaling_rules failed') except Exception as e: print(str(e)) result = False try: results['disable_autoscaling'] = utils.run_cmd( 'cf disable-autoscaling {}'.format(autoscaler_sample_app)) if not results['disable_autoscaling']: print('disable_autoscaling failed') except Exception as e: print(str(e)) result = False try: results['unbind_service'] = common_tests.unbind_service( autoscaler_sample_app, autoscaler_service_instance) if not results['unbind_service']: print('unbind_service failed') except Exception as e: print(str(e)) result = False try: results['delete_app'] = common_tests.delete_app( autoscaler_sample_app) if not results['delete_app']: print('delete_app failed') except Exception as e: print(str(e)) result = False try: results['delete_service'] = common_tests.delete_service( autoscaler_service_instance) if not results['delete_service']: print('delete_service failed') except Exception as e: print(str(e)) result = False if result and not all(value == True for value in results.values()): result = False print("Finished AUTO-SCALING smoke-test...") print(json.dumps(results, indent=1)) print("Overall result: {}".format("Passed" if result else "Failed")) end = time.time() minutes_taken = (end - start) / 60 print("Total time taken: {} minutes".format(minutes_taken)) results['overall_result'] = result results['minutes_taken'] = minutes_taken report_results.send_metric_to_influxdb('auto-scaler', results) return not result
# PxPhysicsWithExtensions # ############################### print("PxPhysicsWithExtensions:") srcPath = "PxPhysicsWithExtensionsAPI.h" metaDataDir = os.path.join(sdkRoot, os.path.normpath("source/physxmetadata")) targetDir = setup_targetdir(metaDataDir, args.test) cmd = " ".join([ "", clangExe, commonFlags, "", platformFlags, includes, srcPath, "-o", '"' + targetDir + '"' ]) print(cmd, file=debugFile) (stdout, stderr) = utils.run_cmd(cmd) if (stderr != "" or stdout != ""): print(stderr, "\n", stdout) print("wrote meta data files in", targetDir) test_targetdir(targetDir, metaDataDir, args.test) ############################### # PxVehicleExtension # ############################### print("PxVehicleExtension:") srcPath = "PxVehicleExtensionAPI.h" metaDataDir = os.path.join( sdkRoot, os.path.normpath("source/physxvehicle/src/physxmetadata"))
def main(): result = True results = {} print("Starting PCC smoke-test...") start = time.time() try: results['set_api'] = common_tests.set_api() if not results['set_api']: raise Exception('set_api failed') results['authenticate'] = common_tests.authenticate() if not results['authenticate']: raise Exception('authenticate failed') results['set_target'] = common_tests.set_target() if not results['set_target']: raise Exception('set_target failed') results[ 'list_marketplace_service'] = common_tests.list_marketplace_service( pcc_service_name) if not results['list_marketplace_service']: raise Exception('list_marketplace_service failed') results['create_service'] = common_tests.create_service( pcc_service_name, pcc_service_plan, pcc_service_instance) if not results['create_service']: raise Exception('create_service failed') results['show_service_info'] = common_tests.show_service_info( pcc_service_instance) if not results['show_service_info']: raise Exception('show_service_info failed') results['create_service_key'] = common_tests.create_service_key( pcc_service_instance, pcc_service_key) if not results['create_service_key']: raise Exception('create_service_key failed') results[ 'show_service_key_info'], service_key = common_tests.show_service_key_info( pcc_service_instance, pcc_service_key) if not results['show_service_key_info']: raise Exception('show_service_key_info failed') else: os.environ['GEMFIRE_URL'] = str(service_key['urls']['gfsh']) for user in service_key['users']: if user['username'].startswith('cluster_operator'): os.environ['GEMFIRE_USER'] = str(user["username"]) os.environ['GEMFIRE_PASSWORD'] = str(user["password"]) break results['pivnet_login'] = common_tests.pivnet_login() if not results['pivnet_login']: raise Exception('pivnet_login failed') results[ 'pivnet_get_product_id'], product_id = common_tests.pivnet_get_product_id( gemfire_product, gemfire_product_version, 'Tar') if not results['pivnet_get_product_id']: raise Exception('pivnet_get_product_id failed') results['pivnet_accept_eula'] = common_tests.pivnet_accept_eula( gemfire_product, gemfire_product_version) if not results['pivnet_accept_eula']: raise Exception('pivnet_accept_eula failed') results[ 'pivnet_download_product_files'] = common_tests.pivnet_download_product_files( gemfire_product, gemfire_product_version, product_id) if not results['pivnet_download_product_files']: raise Exception('pivnet_download_product_files failed') results['pivnet_logout'] = common_tests.pivnet_logout() if not results['pivnet_logout']: raise Exception('pivnet_logout failed') results['extract_gemfire_tar'] = extract_gemfire_tar() if not results['extract_gemfire_tar']: raise Exception('extract_gemfire_tar failed') results['gemfire_create_regions'] = gemfire_create_regions() if not results['gemfire_create_regions']: raise Exception('gemfire_create_regions failed') results['gemfire_write'] = gemfire_write() if not results['gemfire_write']: raise Exception('gemfire_write failed') print(">>> Updating the sample-app manifest...") cmd = "cd {} && sed -i -e \'s/service0/{}/g\' manifest.yml".format( pcc_sample_app_path, pcc_service_instance) utils.run_cmd(cmd) print( ">>> Updating username, password and gemfire-version in sample-app config..." ) cmd = "cd {} && \ sed -i -e \'s/SAMPLE_USERNAME/{}/g\' gradle.properties && \ sed -i -e \'s/SAMPLE_PASSWORD/{}/g\' gradle.properties && \ sed -i -e \'s/9.0.2/{}/g\' build.gradle".format( pcc_sample_app_path, os.environ['SMOKE_USER'], os.environ['SMOKE_PASSWORD'].replace("&", "\&"), gemfire_product_version) utils.run_cmd(cmd, False, False) print(">>> Building the sample-app...") cmd = "cd {} && ./gradlew clean build".format(pcc_sample_app_path) utils.run_cmd(cmd) manifest_path = os.path.join(pcc_sample_app_path, 'manifest.yml') params = "{} -f {} -p {} --no-start".format(pcc_sample_app, manifest_path, pcc_sample_app_path) results['push_app'] = common_tests.push_app(params) if not results['push_app']: results['get_app_logs'] = common_tests.get_app_logs(pcc_sample_app) raise Exception('push_app failed') results['bind_service'] = common_tests.bind_service( pcc_sample_app, pcc_service_instance) if not results['bind_service']: raise Exception('bind_service failed') results['gemfire_read'] = gemfire_read() if not results['gemfire_read']: raise Exception('gemfire_read failed') except Exception as e: print(str(e)) result = False finally: try: results['unbind_service'] = common_tests.unbind_service( pcc_sample_app, pcc_service_instance) if not results['unbind_service']: print('unbind_service failed') except Exception as e: print(str(e)) result = False try: results['delete_service_key'] = common_tests.delete_service_key( pcc_service_instance, pcc_service_key) if not results['delete_service_key']: print('delete_service_key failed') except Exception as e: print(str(e)) result = False try: results['delete_app'] = common_tests.delete_app(pcc_sample_app) if not results['delete_app']: print('delete_app failed') except Exception as e: print(str(e)) result = False try: results['delete_service'] = common_tests.delete_service( pcc_service_instance) if not results['delete_service']: print('delete_service failed') except Exception as e: print(str(e)) result = False if result and not all(value == True for value in results.values()): result = False print("Finished PCC smoke-test...") print(json.dumps(results, indent=1)) print("Overall result: {}".format("Passed" if result else "Failed")) end = time.time() minutes_taken = (end - start) / 60 print("Total time taken: {} minutes".format(minutes_taken)) results['overall_result'] = result results['minutes_taken'] = minutes_taken report_results.send_metric_to_influxdb('pcc', results) return not result
def gemfire_read_helper(gfsh_cli, connect_cmd, region): desc_cmd = "\"describe region --name={}\"".format(region) read_cmd = "\"query --query='select * from /{}'\"".format(region) cmd = "{} -e {} -e {} -e {}".format(gfsh_cli, connect_cmd, desc_cmd, read_cmd) return utils.run_cmd(cmd, False)