def _sort_out_json(self, json_string, session): # get data from sandbox try: ip = os.environ['Host_IP'] except: raise Exception('No IP was selected to run playbook against') try: playbook_url = os.environ['URL'] except: raise Exception('No URL was selected to run playbook from') attrs = scripthelpers.get_resource_context_details().attributes try: username = os.environ['Username'] except: raise Exception('No Username was selected to run playbook from') try: passwrd = os.environ['Password'] except: raise Exception('No Password was selected to run playbook from') TimeoutMinutes = attrs['Timeout Minutes'] # playbook_url = attrs['URL'] JsonDetails = json.loads(json_string) # fill it up in the Json object JsonDetails['hostsDetails'][0]['username'] = username JsonDetails['hostsDetails'][0]['password'] = passwrd JsonDetails['hostsDetails'][0]['ip'] = ip JsonDetails['hostsDetails'][0]['parameters'] = self._parse_parameters() JsonDetails['timeoutMinutes'] = TimeoutMinutes JsonDetails['repositoryDetails']['url'] = playbook_url JsonDetails['repositoryDetails']['username'] = attrs['repo_username'] JsonDetails['repositoryDetails']['password'] = session.DecryptPassword(attrs['repo_password']).Value json_string = json.dumps(JsonDetails) return json_string
def main(): reservation = helpers.get_reservation_context_details() app = helpers.get_resource_context_details() app_attributes = app.attributes connectivity = helpers.get_connectivity_context_details() cloudshell = helpers.get_api_session() msg = lambda txt: cloudshell.WriteMessageToReservationOutput(reservation.id, txt) resource = helpers.get_resource_context_details_dict() resource['deployedAppData']['attributes'] = {attribute['name']: attribute['value'] for attribute in resource['deployedAppData']['attributes']} resource['deployedAppData']['attributes']['Password'] = cloudshell.DecryptPassword(resource['deployedAppData']['attributes']['Password']).Value repo = cloudshell.GetResourceDetails(app_attributes["Repository Name"]) repo_attributes = {attribute.Name: attribute.Value for attribute in repo.ResourceAttributes} repo_attributes["Host"] = repo.Address repo_attributes["Password"] = cloudshell.DecryptPassword(repo_attributes["Password"]).Value artifactory = Artifactory.from_dict(repo_attributes) build = ArtifactBuild.from_dict(repo_attributes) msg('- Looking for app dependencies') if not build.is_populated(): build = populate_build_from_sandbox(connectivity, reservation, msg) msg('- Found dependencies on Artifactory, associated with build {0} {1}'.format(build.name, build.number)) file_location, file_name = artifactory.download(build.name, build.number) msg('- Downloaded app dependencies to Execution Server at ' + os.path.join(file_location, file_name)) install_package(resource['deployedAppData']['address'], resource['deployedAppData']['attributes']['User'], resource['deployedAppData']['attributes']['Password'], os.path.join(file_location, file_name), app_attributes['Target Directory'] + '/' + file_name) msg('- Copied binaries to app server at ' + app_attributes['Target Directory'] + '/' + file_name)
def first_module_flow(): """ Functions passed into orchestration flow MUST have (sandbox, components) signature :param Sandbox sandbox: :param componentssc :return: """ # script helpers to pull in sandbox details, resource details, and api session sb_context = script_help.get_reservation_context_details() resource_details = script_help.get_resource_context_details() api = script_help.get_api_session() res_id = sb_context.id ip = resource_details.address resource_name = resource_details.name # environment variables not available during dev, we can mock it if DEBUG_MODE: warn_print(api, res_id, "=== DEBUG_MODE Boolean is on ===") custom_param = "my debug param value" else: custom_param = os.environ[INPUT_COMMAND_PARAMETER] sb_print(api, res_id, "resource name is {}".format(resource_name)) sb_print(api, res_id, "resource ip is {}".format(ip)) sb_print(api, res_id, "custom param value: {}".format(custom_param))
def get_res_details_wrapper(): import cloudshell.helpers.scripts.cloudshell_scripts_helpers as script_help try: res_details = script_help.get_resource_context_details() except KeyError as e: print(error_red('KeyError: ' + str(e)) + '\n' + 'Can not find the target Resource.\n' 'Check TARGET_RESOURCE_NAME in control_flow.py.') exit(1) else: return res_details
def executePlaybookScript(self): # AppName = os.environ['App_Name'] session = api.CloudShellAPISession(host=connectivity_details['serverAddress'], token_id=connectivity_details['adminAuthToken'], domain=reservation_details.domain) reservation_details_data = session.GetReservationDetails(reservation_details.id).ReservationDescription JsonDetails = self._sort_out_json(template_json, session) session.WriteMessageToReservationOutput(reservation_details.id, JsonDetails) self._run_ansible_playbook(session, reservation_details.id, JsonDetails, scripthelpers.get_resource_context_details().name) return None
def run(): session = sh.get_api_session() resources = session.GetReservationDetails(sh.get_reservation_context_details().id).ReservationDescription.Resources pcs = [] switch = sh.get_resource_context_details().name for res in resources: if res.ResourceModelName.__contains__('GenericPortChannel'): # pcs.append(res.Name) command = 'show interfaces {}'.format(res.Name.split('/')[-1]) session.ExecuteCommand( reservationId=sh.get_reservation_context_details().id, targetType='Resource', targetName=switch, commandName='run_custom_command', commandInputs=[api.InputNameValue('custom_command', command)], printOutput=True )
from cloudshell.shell.core.driver_context import InitCommandContext, AutoLoadCommandContext, ResourceCommandContext, \ AutoLoadAttribute, AutoLoadDetails, CancellationContext, ResourceRemoteCommandContext from cloudshell.shell.core.resource_driver_interface import ResourceDriverInterface # Debug Script # with open(r'c:\temp\HWC_Debug_creds', 'r') as debug_file: # my_debug_file = debug_file.read() dev_help.attach_to_cloudshell_as( user='******', password='******', domain='Global', reservation_id='c3f09270-58a6-4188-a11d-19239d73a0d8', server_address='192.168.85.15', resource_name='HWC') driver_interface = ResourceDriverInterface context = ResourceCommandContext( connectivity=script_help.get_connectivity_context_details(), reservation=script_help.get_reservation_context_details(), resource=script_help.get_resource_context_details(), connectors=None) with open('request.json', 'r') as file: my_request = json.load(file) my_hwc_driver = driver.HuaweicloudDriver() my_hwc_driver.initialize(context) my_hwc_driver.Deploy(context, request=my_request) pass
import cloudshell_cli_handler def decrypt(password): decypted = session.DecryptPassword(password).Value return decypted debug.get_debug_session() res_id = script_helpers.get_reservation_context_details().id session = script_helpers.get_api_session() resources = session.GetReservationDetails( res_id).ReservationDescription.Resources password = script_helpers.get_resource_context_details().attributes.get( '{0}.Admin Password'.format( script_helpers.get_resource_context_details().model)) i = 0 while i < 5: try: password = decrypt(password) except: i = 1000 i = i + 1 CS_Cli = cloudshell_cli_handler.CreateSession( host=script_helpers.get_resource_context_details().address, username=script_helpers.get_resource_context_details().attributes.get( '{0}.Admin Username'.format( script_helpers.get_resource_context_details().model)),
return rv def _ssh_command(ssh, channel, command, prompt_regex): _ssh_write(ssh, channel, command + '\n') rv = _ssh_read(ssh, channel, prompt_regex) if '\n%' in rv.replace('\r', '\n'): es = 'CLI error message: ' + rv raise Exception(es) return rv resource_context = helper.get_resource_context_details() session = paramiko.SSHClient() session.set_missing_host_key_policy(paramiko.AutoAddPolicy()) session.connect(resource_context.address, 22, 'root', 'amdocs') channel = session.invoke_shell() prompt = '.*]#' _ssh_command(session, channel, 'cd /stage', prompt) _ssh_command(session, channel, 'mkdir -p /var/www/html/cdrom/iso', prompt) _ssh_command( session, channel, 'mount -o loop /stage/rhel-server-5.8-x86_64-dvd.iso /var/www/html/cdrom/iso', prompt) _ssh_command( session, channel, 'rpm --import /var/www/html/cdrom/iso/RPM-GPG-KEY-redhat-release', prompt)
:return: """ resv_det = api.GetReservationDetails(reservation.id) server = None user = None password = None for resource in resv_det.ReservationDescription.Resources: if resource.ResourceModelName.lower() == 'generic tftp server': server = resource.FullAddress res_det = api.GetResourceDetails(resource.Name) for attribute in res_det.ResourceAttributes: if attribute.Name == 'Storage username': user = attribute.Value if attribute.Name == 'Storage password': password = attribute.Value return server, user, password ses = helpers.get_api_session() reservation = helpers.get_reservation_context_details() resource = helpers.get_resource_context_details() filename = os.environ['FileName'] filename_input = InputNameValue('file_path', filename) ftp, user, password = get_ftp(ses, reservation) remote_host_input = InputNameValue('remote_host', ftp) ses.EnqueueCommand(reservation.id, resource.name, 'Resource', 'load_firmware', [filename_input, remote_host_input])
import cloudshell.helpers.scripts.cloudshell_scripts_helpers as script_help import cloudshell.helpers.scripts.cloudshell_dev_helpers as dev dev.attach_to_cloudshell_as( ) script_help.get_api_session() script_help.get_resource_context_details().attributes
"type": "actionTarget" }, "customActionAttributes": [], "type": "setVlan" }] } } ''' import cloudshell.helpers.scripts.cloudshell_scripts_helpers as qs_helper import cloudshell.helpers.scripts.cloudshell_dev_helpers as dev_help from cloudshell.shell.core.driver_context import * res_id = 'f7505eb3-b637-4795-9740-19a56244a33d' dev_help.attach_to_cloudshell_as('admin', 'admin', 'Global', res_id, 'localhost', '8029',resource_name='brocy') resource = qs_helper.get_resource_context_details() reservation = qs_helper.get_reservation_context_details() connectivity = qs_helper.get_connectivity_context_details() my_context = ResourceCommandContext(connectivity,resource,reservation,[]) my_context.reservation.reservation_id = '5695cf87-a4f3-4447-a08a-1a99a936010e' # cont = create_context() driv = BrocadeNOSDriver() driv.ApplyConnectivityChanges(my_context, request) # driv.get_inventory(cont) # driv.command(context=cont, command='conf t') # driv.command(context=cont, command='int fa 0/1') # driv.command(context=cont, command='speed 100')
server_address=server, reservation_id=resId, service_name='UptimeEnforcer') get_debug_session() session = sh.get_api_session() token = session.token_id reservation_context = sh.get_reservation_context_details() reservation_context.reservation_id = reservation_context.id connectivity_context = sh.get_connectivity_context_details() connectivity_context.admin_auth_token = token resource_context = sh.get_resource_context_details() reservation_description = session.GetReservationDetails( reservation_context.id).ReservationDescription services = reservation_description.Services connectors = reservation_description.Connectors context_connectors = [ conn for conn in connectors if resource_context.name in [conn.Source, conn.Target] ] context_connectors_reformatted = [] for conn in context_connectors: temp_connector = Connector(source=conn.Source, target=conn.Target, alias=conn.Alias, attributes=conn.Attributes,
LIVE_SANDBOX_ID = "97bf055e-dddc-46ed-a868-f2946bda9444" RESOURCE_NAME = "compute demo" CS_SERVER = "localhost" attach_to_cloudshell_as(user='******', password='******', domain='Global', server_address=CS_SERVER, reservation_id=LIVE_SANDBOX_ID, resource_name=RESOURCE_NAME) session = sh.get_api_session() token = session.token_id resource_context_details = sh.get_resource_context_details() reservation_context_details = sh.get_reservation_context_details() reservation_context = ReservationContextDetails( environment_name=reservation_context_details.environment_name, environment_path=reservation_context_details.environment_path, domain=reservation_context_details.domain, description=reservation_context_details.description, owner_user=reservation_context_details.owner_user, owner_email="*****@*****.**", reservation_id=reservation_context_details.id, saved_sandbox_name="", saved_sandbox_id="", running_user="") connectivity_context_details = sh.get_connectivity_context_details() cs_api_port = connectivity_context_details.cloudshell_api_port
from cloudshell.helpers.scripts.cloudshell_scripts_helpers import get_reservation_context_details, get_api_session, \ get_resource_context_details api = get_api_session() sb_details = get_reservation_context_details() sb_id = sb_details.id resource_details = get_resource_context_details() name = resource_details.name ip = resource_details.address api.WriteMessageToReservationOutput(reservationId=sb_id, message=f"Resource name: {name}, IP: {ip}") # printing to std_out will be the return value of resource scripts print(f"resource script completed for '{name}'")
def __init__(self): self.session = script_help.get_api_session() self.name = script_help.get_resource_context_details().name self.id = script_help.get_reservation_context_details().id self.suffix = 'westeurope.cloudapp.azure.com'
import json import requests from cloudshell.core.logger.qs_logger import get_qs_logger from cloudshell.helpers.scripts import cloudshell_scripts_helpers as helpers api = helpers.get_api_session() resid = helpers.get_reservation_context_details().id logger = get_qs_logger(log_group=resid, log_file_prefix='VNF') delete_resources = helpers.get_resource_context_details( ).attributes['Resources to Delete'].split(',') if delete_resources and delete_resources[0]: api.DeleteResources(delete_resources) delete_networks = helpers.get_resource_context_details( ).attributes['Cloud Provider Objects to Delete'].split(',') cpname = helpers.get_resource_context_details( ).attributes['Cloud Provider Name'] class OpenStack(object): def openstack_rest(self, method, url, headers=None, data=None): self.logger.info('Sending POST %s headers=%s data=%s' % (url, headers, data)) rv = requests.request(method, url, headers=headers, data=data) self.logger.info('Received %s: headers=%s body=%s' % (str(rv.status_code), str(rv.headers), rv.text))
import json import os import cloudshell.api.cloudshell_api as api import cloudshell.helpers.scripts.cloudshell_scripts_helpers as scripthelpers # Production reservation_details = scripthelpers.get_reservation_context_details() resource_context = scripthelpers.get_resource_context_details() connectivity_details = scripthelpers.get_connectivity_context_details_dict() template_json = ''' { "additionalArgs": "", "timeoutMinutes": "10", "repositoryDetails" : { "url": "", "username": "", "password": "" }, "hostsDetails": [ { "ip": "", "username": "", "password": "", "accessKey": "", "connectionMethod": "ssh", "connectionSecured": "true", "groups": [], "parameters": [] }] }
domain='Global', reservation_id='e03d8f4b-a233-490f-b3d4-5088b3aaf9be', server_address='localhost', resource_name='Centos VM_3432-f9be') def _decrypt(session, password): decypted = session.DecryptPassword(password).Value return decypted session = script_help.get_api_session() resid = script_help.get_reservation_context_details().id # resource_details = session address = script_help.get_resource_context_details().address username = script_help.get_resource_context_details().attributes.get('User') enc_cs_password = script_help.get_resource_context_details().attributes.get( 'Password') cleartext_password = session.DecryptPassword(enc_cs_password).Value pass_enc = os.popen("cryptRDP5.exe {}".format(cleartext_password)).read() rdp_text = rdp_populator(username=username, password=pass_enc, ip=address) FILEPATH = r'c:\temp\{}.rdp'.format( script_help.get_resource_context_details().name) with open(FILEPATH, 'w') as upload_file: upload_file.write(rdp_text) attach_to_reservation.attachFile( serverMachine=script_help.get_connectivity_context_details(
import cloudshell.api.cloudshell_api as api import cloudshell.helpers.scripts.cloudshell_scripts_helpers as script_helpers import cloudshell.helpers.scripts.cloudshell_dev_helpers as dev_helpers import license_ssh_handler # res_dets = session.GetResourceDetails(script_helpers.get_resource_context_details().name) # import debug # debug.get_debug_session() # hostname = '192.168.42.161' # username = '******' # password = '******' port = 22 session = script_helpers.get_api_session() reservation_details = session.GetReservationDetails( script_helpers.get_reservation_context_details().id) lic_handler = license_ssh_handler.configure_license( hostname=script_helpers.get_resource_context_details().address, user=script_helpers.get_resource_context_details().attributes.get('User'), password=session.DecryptPassword( script_helpers.get_resource_context_details().attributes.get( 'Password')).Value, port=port, lic_server_address=script_helpers.get_resource_context_details( ).attributes.get('License Server')) lic_handler.config_license() pass