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
