def delete_all_records(self, context):
"""
:param ResourceCommandContext context:
:return:
"""
DNS_ATTRIBUTE = "DNS Name"
logger = self._get_logger(context)
logger.info("Starting delete all records")
cs_api = CloudShellAPISession(
host=context.connectivity.server_address,
token_id=context.connectivity.admin_auth_token,
domain="Global")
reservation_details = cs_api.GetReservationDetails(
context.reservation.reservation_id).ReservationDescription
for resource in reservation_details.Resources:
attribute_name = "{}.{}".format(resource.ResourceModelName,
DNS_ATTRIBUTE)
try:
result = cs_api.GetAttributeValue(resource.Name,
attribute_name).Value
if result:
try:
self.delete_host_record(context, result)
except Exception as e:
logger.error(
f"Error deleting record for '{result}'. error: {e}"
)
except Exception as e:
logger.info(
f"Error getting DNS Attribute '{DNS_ATTRIBUTE}' on resource '{resource.Name}'. Error: {e}"
)
def run_parsed_config(self, context):
self._get_logger_with_reservation_id(context)
session = CloudShellAPISession(
host=context.connectivity.server_address,
token_id=context.connectivity.admin_auth_token,
domain=context.reservation.domain)
Reservation_Description = session.GetReservationDetails(
context.reservation.reservation_id).ReservationDescription
parser = parse_config.parse_commands(
session,
res_id=context.reservation.reservation_id,
logger=self.logger)
parsed_commands = parser.replace_placeholders(
file_name=COREVSRXFILENAME,
file_type='txt',
reservation_description=Reservation_Description)
# for command in parsed_commands:
# self._send_command(context, command=command)
result = []
try:
temp_result = self._send_command(context=context,
command=parsed_commands)
except Exception as e:
self.logger.error(e)
temp_result = e
result.append(temp_result)
return result
def f(jj):
k = randint(0, 300)
log('%d: Sleeping %d seconds' % (jj, k))
sleep(k)
while True:
t0 = time()
fail = 'ok'
api = CloudShellAPISession('localhost', 'admin', 'admin', 'Global')
try:
id = api.CreateImmediateTopologyReservation(
reservationName='vmx%d' % jj,
topologyFullPath=toponame,
durationInMinutes=120,
owner='admin').Reservation.Id
for _ in range(100):
rd = api.GetReservationDetails(id).ReservationDescription
log('%d: %s Status=%s SetupStage=%s ProvisioningStatus=%s' %
(jj, id, rd.Status, rd.SetupStage, rd.ProvisioningStatus))
if rd.ProvisioningStatus == 'Error':
fail = 'setup error'
break
if rd.SetupStage == 'Ended':
break
sleep(10)
else:
log('%d: Setup never finished, ending reservation %s' %
(jj, id))
fail = 'setup timeout'
api.EndReservation(id)
for _ in range(100):
rd = api.GetReservationDetails(id).ReservationDescription
if rd.Status == 'Completed':
log('%d: %s Status=%s' % (jj, id, rd.Status))
break
sleep(10)
else:
log('%d: Teardown never finished %s' % (jj, id))
fail = 'teardown fail'
log('%d: Cycle (%s) finished in %d seconds' %
(jj, str(fail), time() - t0))
except Exception as e:
log('Exception: %s' % str(e))
sleep(randint(1, 30))
def end_reservation(session: CloudShellAPISession, reservation_id: str) -> None:
""" End and delete reservation. """
try:
session.EndReservation(reservation_id)
while session.GetReservationDetails(reservation_id).ReservationDescription.Status != 'Completed':
time.sleep(1)
session.DeleteReservation(reservation_id)
except Exception as _:
pass
def wait_for_connectors(
cs_session: CloudShellAPISession, reservation_id: str, aliases: Union[list, str], timeout: int = 4
) -> None:
"""Wait until all connectors show in reservation details."""
if isinstance(aliases, str):
aliases = [aliases]
for _ in range(timeout + 1):
all_connectors = cs_session.GetReservationDetails(reservation_id).ReservationDescription.Connectors
new_connectors = [c for c in all_connectors if c.Alias in aliases]
if len(new_connectors) == len(aliases):
return
time.sleep(1)
raise TimeoutError(f"Connectors {aliases} not in reservation after {timeout} seconds")
def wait_for_resources(
cs_session: CloudShellAPISession, reservation_id: str, resources_names: Union[list, str], timeout: int = 4
) -> None:
"""Wait until all resources show in reservation details."""
if isinstance(resources_names, str):
resources_names = [resources_names]
for _ in range(timeout + 1):
all_resources = cs_session.GetReservationDetails(reservation_id).ReservationDescription.Resources
new_resources = [r for r in all_resources if r.Name in resources_names]
if len(new_resources) == len(resources_names):
return
time.sleep(1)
raise TimeoutError(f"Resources {resources_names} not in reservation after {timeout} seconds")
def wait_for_attribute(
cs_session: CloudShellAPISession,
reservation_id: str,
alias: str,
attribute_name: str,
attribute_value: str,
timeout: int = 4,
) -> None:
"""Wait until an attribute that was set is updated on the sandbox."""
for _ in range(timeout + 1):
all_services = cs_session.GetReservationDetails(reservation_id).ReservationDescription.Services
service = [s for s in all_services if s.Alias == alias][0]
current_attribute_value = [a.Value for a in service.Attributes if a.Name == attribute_name][0]
if current_attribute_value == attribute_value:
return
time.sleep(1)
import sys
from cloudshell.api.cloudshell_api import CloudShellAPISession
server_ip = sys.argv[1]
reservation_id = sys.argv[2]
DEPLOYED_APP_MODEL = 'Generic App Model'
session = CloudShellAPISession(server_ip, sys.argv[3], sys.argv[4],
sys.argv[5])
resources = session.GetReservationDetails(
reservation_id).ReservationDescription.Resources
my_resource = [
resource for resource in resources
if resource.ResourceModelName == DEPLOYED_APP_MODEL
]
if len(my_resource) > 1:
raise Exception('There are more then one app in the sandbox')
if len(my_resource) == 0:
raise Exception('There are no deployed application in the sandbox')
resource_att = session.GetResourceDetails(
my_resource[0].Name).ResourceAttributes
for item in resource_att:
if item.Name == 'Public IP':
sys.stdout.write(item.Value)
return app_request
def change_attribute(edit_app_object, attribute_name, attribute_value):
'''
:param str attribute_name:
:param ApiEditAppRequest edit_app_object:
:return:
'''
for attribute in edit_app_object.AppDetails.Attributes:
if attribute_name == attribute.Name or '{0}.{1}'.format(edit_app_object.AppDetails.ModelName, attribute_name) == attribute.Name:
attribute.Value = attribute_value
print 'replaced password for app {}'.format(edit_app_object.Name)
return edit_app_object
all_apps = session.GetReservationDetails(res_id).ReservationDescription.Apps
app_names = [app.Name for app in all_apps]
all_app_get_objects = session.GetAppsDetailsInReservation(
reservationId=res_id,
appNames=app_names
)
for app in all_app_get_objects.Apps:
converted_object = convert_get_to_set_app(app)
changed_converted_object = change_attribute(converted_object, 'Password', 'abcd12342314')
session.EditAppsInReservation(
reservationId=res_id,
editAppsRequests=[changed_converted_object]
)
qq = session.GetAppsDetailsInReservation(
reservationId=res_id,
appNames=app_names
from time import sleep
from os import environ as parameter
from cloudshell.api.cloudshell_api import CloudShellAPISession
connectivity = json.loads(parameter["QUALICONNECTIVITYCONTEXT"])
reservation = json.loads(parameter["RESERVATIONCONTEXT"])
resource = json.loads(parameter["RESOURCECONTEXT"])
artifactory_server = parameter["artifactory_server_address"]
repo_name = parameter["repository_name"]
playbook_name = parameter["ansible_playbook"]
api = CloudShellAPISession(connectivity["serverAddress"],
connectivity["adminUser"],
connectivity["adminPass"], 'Global')
reservation_details = api.GetReservationDetails(
reservation["id"]).ReservationDescription
build_name = reservation_details.Name.split('_')[-1]
api.WriteMessageToReservationOutput(
reservation["id"],
"Running Ansible playbook \"{1}\" on \"{0}\"\n\n".format(
resource['deployedAppData']["name"], playbook_name))
sleep(3)
api.WriteMessageToReservationOutput(
reservation["id"],
"TASK: [Retrieve package from repository] ***************************************\n"
)
file_name = "index.html"
target_url = "http://{0}:8081/artifactory/{1}/{2}/{3}".format(
artifactory_server, repo_name, build_name, file_name)
save_target = r"C:\Temp\{0}".format(file_name)
from cloudshell.api.cloudshell_api import CloudShellAPISession
# api session details
user = "******"
password = "******"
server = "localhost"
api = CloudShellAPISession(host=server,
username=user,
password=password,
domain="Global")
sandboxes = api.GetScheduledReservations(
fromTime="01/22/2020 00:00", untilTime="01/23/2020 16:00").Reservations
filter = [sb for sb in sandboxes if sb.Name == "MC Test"]
details = api.GetReservationDetails(reservationId=filter[0].Id)
first_reservation_details = api.GetReservationDetails(
reservationId=sandboxes[0].Id)
pass
# 'TARGET_URL': 'https://chat.eggma.org/2.html',
# }
connectivity = {
'serverAddress': 'localhost',
'adminUser': '******',
'adminPass': '******',
}
reservation = {
'domain': 'Global',
}
csapi = CloudShellAPISession(connectivity["serverAddress"],
connectivity["adminUser"],
connectivity["adminPass"], reservation["domain"])
resid = reservation["id"]
res = csapi.GetReservationDetails(resid).ReservationDescription
csapi.WriteMessageToReservationOutput(resid, '1')
a2b = {}
for conn in res.Connectors:
if conn.Source not in a2b:
a2b[conn.Source] = []
a2b[conn.Source].append(conn.Target)
if conn.Target not in a2b:
a2b[conn.Target] = []
a2b[conn.Target].append(conn.Source)
# csapi.WriteMessageToReservationOutput(resid, 'a2b=%s' % str(a2b))
targetname2url = {}
from cloudshell.api.cloudshell_api import InputNameValue, CloudShellAPISession, AppConfiguration, ConfigParam
session = CloudShellAPISession("localhost", "admin", "admin", "Global")
res_id = "260b3f80-14bd-4cc2-975c-6ab21a12ac28"
res_details = session.GetReservationDetails(res_id).ReservationDescription
x = session.GetAppsDetailsInReservation(res_id, ["Linux Ubuntu Tiny"])
params = [ConfigParam("key", "value")]
app_configs = [AppConfiguration(AppName="asdf", ConfigParams=params)]
session.ConfigureApps(reservationId=res_id, appConfigurations=app_configs)
res_details_after_config = session.GetReservationDetails(
res_id).ReservationDescription
api = CloudShellAPISession(host=server,
username=user,
password=password,
domain=domain)
# FIND SANDBOXES
all_sandboxes = api.GetScheduledReservations(
fromTime="01/01/2020 00:00", untilTime="04/02/2021 00:00").Reservations
print("starting operation for {} sandboxes...".format(len(all_sandboxes)))
start = default_timer()
for index, curr_sb in enumerate(all_sandboxes):
print("checking index: {}".format(index))
sb_id = curr_sb.Id
try:
details = api.GetReservationDetails(sb_id).ReservationDescription
except Exception as e:
print("issue getting details for {}".format(sb_id))
continue
sb_services = details.Services
sb_service_names = [service.ServiceName for service in sb_services]
for sb_service_name in sb_service_names:
if TARGET_SERVICE_MODEL == sb_service_name:
try:
print("deleting: {}".format(sb_id))
api.DeleteReservation(sb_id)
except Exception as e:
print("issue deleting {}".format(sb_id))
# raise
from cloudshell.api.cloudshell_api import CloudShellAPISession
user = "******"
password = "******"
server = "localhost"
domain = "Global"
SANDBOX_ID = "b8e1aea9-4d65-43c9-ac0d-227842fe5773"
api = CloudShellAPISession(host=server,
username=user,
password=password,
domain=domain)
sandbox_details = api.GetReservationDetails(
reservationId=SANDBOX_ID, disableCache=True).ReservationDescription
print("setting Live statuses on resources in sandbox '{}'....".format(
sandbox_details.Name))
for resource in sandbox_details.Resources:
print("Setting resource '{}'...".format(resource.Name))
api.SetResourceLiveStatus(resourceFullName=resource.Name,
liveStatusName="Online",
additionalInfo="Resource is online")
print("Done.")
logger.info(
"Deploying apps for sandbox {0}. App names: {1}".format(reservation_id, ", ".join(app_names)))
res = api.DeployAppToCloudProviderBulk(reservation_id, app_names, app_inputs)
return res
resid = 'f87392d2-c934-48e5-8a29-98370d180d3a'
username = '******'
password = '******'
server = '40.91.201.107'
domain = 'Global'
logger = qs_logger.get_qs_logger(
log_group=resid,
log_category='SkyBox_custom_Setup',
log_file_prefix='Skybox_Setup'
)
session = CloudShellAPISession(
username=username,
password=password,
domain=domain,
host=server
)
res_desc = session.GetReservationDetails(resid)
qq = deploy_apps_in_reservation(session, res_desc, resid, logger)
pass
