def execute_cp(self, cp_data):
try:
identifier = self.check_null(cp_data.get(Constants.CHANGE_PLAN_ID_KEY))
owner = self.check_null(cp_data.get(Constants.OWNER_KEY))
change_plan_actions: List[
ChangePlanAction
] = self.cp_action_table.get_actions_by_change_plan_id(identifier)
# Validate Change Plan
val_actions = ChangePlanActionManager().get_change_plan_actions(identifier)
for cp_action in val_actions:
val_result = self.validator.validate_action(cp_action, val_actions)
if val_result != Constants.API_SUCCESS:
conflict = f"Change plan cannot be executed due to conflict in step {cp_action.step}. "
conflict += val_result
raise InvalidInputsError(conflict)
# Execute actions in change plan
for cp_action in change_plan_actions:
self._execute_action(cp_action, owner)
# Update change plan with executed and timestamp
change_plan: ChangePlan = self.cp_table.get_change_plan(identifier)
change_plan.executed = True
change_plan.timestamp = datetime.datetime.now()
print("TIMESTAMP", change_plan.timestamp)
self.cp_table.edit_change_plan(change_plan)
except InvalidInputsError as e:
print(e.message)
raise InvalidInputsError(e.message)
except Exception as e:
print(str(e))
raise InvalidInputsError(
"An error occurred when attempting to execute the change plan."
)
def delete_model(self, model_data):
vendor = self.check_null(model_data[Constants.VENDOR_KEY])
model_number = self.check_null(model_data[Constants.MODEL_NUMBER_KEY])
print("Got vendor and model_number")
if vendor == "":
raise InvalidInputsError("Must provide a vendor")
if model_number == "":
raise InvalidInputsError("Must provide a model number")
print("Vendor and Model not blank")
try:
delete_validation_result = self.validate.delete_model_validation(
vendor, model_number)
print("Validation complete")
print(delete_validation_result)
if delete_validation_result == Constants.API_SUCCESS:
print("Validation successful")
self.table.delete_model_str(vendor, model_number)
print("Successfully deleted from ModelTable")
else:
print("Validation unsuccessful")
return InvalidInputsError(delete_validation_result)
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
except:
print("SOMETHING BAD HAPPENED")
return InvalidInputsError(
"An error occured while trying to delete the model.")
def make_datacenter(self, dc_data):
try:
print("were1")
abbreviation = self.check_null(
dc_data[Constants.DC_ABRV_KEY]).upper()
print("were2")
name = self.check_null(dc_data[Constants.DC_NAME_KEY])
print("were3")
is_offline_storage = dc_data[Constants.DC_IS_OFFLINE_KEY]
print("were4")
except:
raise InvalidInputsError(
"Could not read data fields correctly. Client-server error occurred."
)
print("were5")
if abbreviation == "":
raise InvalidInputsError(
"Must provide an abbreviation for the datacenter")
print("were6")
if name == "":
raise InvalidInputsError("Must provide a datacenter name")
print("were7")
if type(is_offline_storage) != bool:
raise InvalidInputsError(
"Must provide a boolean value specifying whether or not the datacenter is an offline storage location"
)
return Datacenter(abbreviation, name, is_offline_storage)
def edit_datacenter(self, dc_data):
try:
print("here1")
try:
original_name = self.check_null(
dc_data[Constants.NAME_ORIG_KEY])
print("here2")
updated_datacenter = self.make_datacenter(dc_data)
print("here3")
if type(updated_datacenter) is InvalidInputsError:
return updated_datacenter
print("here4")
except InvalidInputsError as e:
return e.message
try:
print("here5")
edit_validation_result = self.validate.edit_dc_validation(
updated_datacenter, original_name)
except InvalidInputsError as e:
return e.message
print("here6")
if edit_validation_result == Constants.API_SUCCESS:
self.dc_table.edit_datacenter(updated_datacenter,
original_name)
else:
return InvalidInputsError(edit_validation_result)
print("here7")
except:
raise InvalidInputsError(
"An error occurred when attempting to edit the datacenter.")
def edit_model(self, model_data):
try:
updated_model = self.make_model(model_data)
original_vendor = self.check_null(
model_data.get(Constants.VENDOR_ORIG_KEY))
original_model_number = self.check_null(
model_data.get(Constants.MODEL_NUMBER_ORIG_KEY))
original_height = self.check_null(
model_data.get(Constants.HEIGHT_ORIG_KEY))
model_id = self.table.get_model_id_by_vendor_number(
original_vendor, original_model_number)
if original_height != updated_model.height:
if model_id is None:
return InvalidInputsError("Model not found")
deployed_instances = self.instance_table.get_instances_by_model_id(
model_id)
if deployed_instances is not None:
return InvalidInputsError(
"Cannot edit height while instances are deployed")
edit_validation_result = self.validate.edit_model_validation(
self.make_model(model_data), original_vendor,
original_model_number)
if edit_validation_result == Constants.API_SUCCESS:
self.table.edit_model(model_id, updated_model)
else:
return InvalidInputsError(edit_validation_result)
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
except:
raise InvalidInputsError(
"A failure occured while trying to edit the model.")
def from_json(cls, json: JSON) -> "Model":
vendor: str = json[Constants.VENDOR_KEY]
model_number: str = json[Constants.MODEL_NUMBER_KEY]
if vendor == "":
raise InvalidInputsError("Must provide a vendor")
if model_number == "":
raise InvalidInputsError("Must provide a model number")
mount_type: str = json[Constants.MOUNT_TYPE_KEY]
if mount_type == Constants.BLADE_KEY:
height = 1
else:
height = int(json[Constants.HEIGHT_KEY])
if height == "":
raise InvalidInputsError("Must provide a height")
display_color: Optional[str] = json.get(Constants.DISPLAY_COLOR_KEY, None)
display_color = None if display_color == "" else display_color
ethernet_str: Optional[List[str]] = json.get(Constants.ETHERNET_PORT_KEY, None)
ethernet_ports = []
if mount_type != Constants.BLADE_KEY:
if ethernet_str is not None:
for name in ethernet_str:
ethernet_ports.append(name)
power_str: Optional[str] = json.get(Constants.POWER_PORT_KEY, None)
power_ports: Optional[
int
] = None if power_str == "" or power_str is None else int(power_str)
cpu: Optional[str] = json.get(Constants.CPU_KEY, None)
cpu = None if cpu == "" else cpu
memory_str: Optional[str] = json.get(Constants.MEMORY_KEY, None)
memory: Optional[int] = None if memory_str == "" or memory_str is None else int(
memory_str
)
storage: Optional[str] = json.get(Constants.STORAGE_KEY, None)
storage = None if storage == "" else storage
comment: Optional[str] = json.get(Constants.COMMENT_KEY, None)
comment = None if comment == "" else comment
return Model(
vendor=vendor,
model_number=model_number,
mount_type=mount_type,
height=height,
display_color=display_color,
ethernet_ports=ethernet_ports,
power_ports=power_ports,
cpu=cpu,
memory=memory,
storage=storage,
comment=comment,
)
def validate_rack_details(rack_letter, rack_number, side):
if not ("A" <= rack_letter <= "E"):
raise InvalidInputsError(
"Rack letter must be between A and E inclusive")
if not (1 <= rack_number <= 19):
raise InvalidInputsError(
"Rack number must be between 1 and 19 inclusive")
if not (side == "L" or side == "R"):
raise InvalidInputsError("Side must be either 'L' or 'R'")
def create_change_plan(self, cp_data) -> int:
try:
new_change_plan = self.make_cp(cp_data)
return self.cp_table.add_change_plan(new_change_plan)
except InvalidInputsError as e:
print(e.message)
raise InvalidInputsError(e.message)
except Exception as e:
print(str(e))
raise InvalidInputsError(
"An error occurred when attempting to create the change plan."
)
def create_model(self, model_data):
try:
new_model: Model = self.make_model(model_data)
create_validation_result = self.validate.create_model_validation(
new_model)
if create_validation_result == Constants.API_SUCCESS:
self.table.add_model(new_model)
else:
raise InvalidInputsError(create_validation_result)
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
except:
raise InvalidInputsError("Unable to add the new model")
def edit_instance_validation(self, instance, original_asset_number):
basic_val_result = self.basic_validations(instance,
original_asset_number)
if basic_val_result != Constants.API_SUCCESS:
return basic_val_result
model_template = self.model_table.get_model(instance.model_id)
if model_template is None:
return "The model does not exist."
dc_template = self.dc_table.get_datacenter(instance.datacenter_id)
if dc_template is None:
return "The datacenter does not exist."
# Check that connections are only within a single datacenter
net_cons = instance.network_connections
for port in net_cons.keys():
dest_hostname = net_cons[port][Constants.CONNECTION_HOSTNAME]
if dest_hostname != "" and dest_hostname is not None:
dc_id = (InstanceTable().get_instance_by_hostname(
dest_hostname).datacenter_id)
if dc_id != instance.datacenter_id:
raise InvalidInputsError(
"Network connections cannot span multiple datacenters")
if dc_template.is_offline_storage:
return Constants.API_SUCCESS
if instance.mount_type == Constants.BLADE_KEY:
return self.blade_validation(instance, original_asset_number)
else:
return self.rackmount_validation(instance, original_asset_number,
model_template, dc_template)
return Constants.API_SUCCESS
def get_blades_in_chassis(self, asset_data):
try:
chassis_hostname = asset_data.get(Constants.CHASSIS_HOSTNAME_KEY)
if chassis_hostname is None or chassis_hostname == "":
raise InvalidInputsError(
"Must provide a valid blade chassis hostname.")
blade_list = self.table.get_blades_by_chassis_hostname(
chassis_hostname)
if blade_list is None:
return []
return blade_list
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
except:
raise InvalidInputsError(
"An error occurred while trying to retrieve blade chassis.")
def get_all_datacenters(self):
try:
dc_list = self.dc_table.get_all_datacenters()
return dc_list
except:
raise InvalidInputsError(
"A failure occured while retrieving datacenter information.")
def get_change_plans(self, cp_data):
try:
cp_owner = cp_data.get(Constants.OWNER_KEY)
print(cp_owner)
cp_list = self.cp_table.get_change_plan_by_owner(cp_owner)
print("CP LIST")
print(cp_list)
return cp_list
except InvalidInputsError as e:
print(e.message)
raise InvalidInputsError(e.message)
except Exception as e:
print(str(e))
raise InvalidInputsError(
"An error occurred when attempting to retrieve your change plans."
)
def get_dc_from_id(self, dc_id):
datacenter = self.dc_table.get_datacenter(dc_id)
if datacenter is None:
raise InvalidInputsError(
"An error occurred while trying to retrieve datacenter info corresponding to the instance."
)
return datacenter
def create_instance(self, instance_data):
print("INSTANCE DATA")
print(instance_data)
try:
try:
new_instance = self.make_instance(instance_data)
if type(new_instance) is InvalidInputsError:
return new_instance
except InvalidInputsError as e:
return e.message
create_validation_result = Constants.API_SUCCESS
try:
create_validation_result = self.validate.create_instance_validation(
new_instance)
if create_validation_result != Constants.API_SUCCESS:
raise InvalidInputsError(create_validation_result)
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
# try:
is_in_offline_storage = (DatacenterTable().get_datacenter_by_name(
instance_data.get(Constants.DC_NAME_KEY)).is_offline_storage)
self.table.add_instance(new_instance)
if (new_instance.mount_type != Constants.BLADE_KEY
and not is_in_offline_storage):
power_result = self.add_power_connections(new_instance)
print("POWER RESULT")
print(power_result)
if power_result != Constants.API_SUCCESS:
self.table.delete_instance_by_asset_number(
new_instance.asset_number)
raise InvalidInputsError(
"An error occurred when trying to add power connections."
)
connect_result = self.make_corresponding_connections(
new_instance.network_connections, new_instance.hostname)
if connect_result != Constants.API_SUCCESS:
self.table.delete_instance_by_asset_number(
new_instance.asset_number)
raise InvalidInputsError(connect_result)
# except:
# raise InvalidInputsError("Unable to create asset")
except InvalidInputsError as e:
print(e.message)
raise InvalidInputsError(e.message)
def get_model_from_id(self, model_id):
model = self.model_table.get_model(model_id)
if model is None:
raise InvalidInputsError(
"An error occurred while trying to retrieve model info corresponding to the instance."
)
return model
def format_pdu_id(self, rack_letter, rack_number, side):
rack_letter = rack_letter.upper()
side = side.upper()
try:
self.validate_rack_details(rack_letter, rack_number, side)
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
return f"hpdu-rtp1-{rack_letter}{rack_number:02d}{side}"
def get_network_neighborhood(self, asset_number):
if asset_number is None or asset_number == "":
raise InvalidInputsError("No asset number found in the request.")
asset = self.table.get_instance_by_asset_number(asset_number)
if asset is None:
raise InvalidInputsError("The asset requested could not be found.")
connections_dict = {}
if asset.mount_type == Constants.CHASIS_KEY:
blade_list = self.table.get_blades_by_chassis_hostname(
asset.hostname)
if blade_list is not None and len(blade_list) != 0:
for blade in blade_list:
connections_dict[blade.hostname] = []
is_blade = asset.mount_type == Constants.BLADE_KEY
if is_blade:
connected_asset = self.table.get_instance_by_hostname(
asset.chassis_hostname)
if connected_asset is None:
raise InvalidInputsError(
f"Connection to asset with hostname {asset.chassis_hostname} was not found."
)
two_deep_list = self.make_two_deep_list(connected_asset)
connections_dict[connected_asset.hostname] = two_deep_list
else:
for port in asset.network_connections:
hostname = asset.network_connections[port][
"connection_hostname"]
if hostname is None or hostname == "":
continue
connected_asset = self.table.get_instance_by_hostname(hostname)
if connected_asset is None:
raise InvalidInputsError(
f"Connection to asset with hostname {hostname} was not found."
)
two_deep_list = self.make_two_deep_list(connected_asset)
connections_dict[hostname] = two_deep_list
print(connections_dict)
return connections_dict
def get_all_chassis(self):
try:
chassis_list = self.table.get_asset_by_mount_type(
Constants.CHASIS_KEY)
if chassis_list is None:
chassis_list = []
return chassis_list
except:
raise InvalidInputsError(
"An error occurred while trying to retrieve blade chassis.")
def decommission_asset(self, asset_data):
try:
asset_number = self.check_null(
asset_data[Constants.ASSET_NUMBER_KEY])
decommission_user = self.check_null(
asset_data[Constants.DECOM_USER_KEY])
timestamp = datetime.datetime.now()
try:
asset = self.instance_table.get_instance_by_asset_number(
asset_number)
print("got asset")
network_neighborhood = self.instance_manager.get_network_neighborhood(
asset_number)
except:
raise InvalidInputsError(
"An error occurred when retrieving asset data.")
decommission = self.make_decommission(
asset=asset,
timestamp=timestamp,
decommission_user=decommission_user,
network_neighborhood=network_neighborhood,
)
try:
asset_data = {
Constants.ASSET_NUMBER_KEY: asset_number,
}
self.instance_manager.delete_instance(asset_data)
self.decommission_table.add_decommission(decommission)
except:
raise InvalidInputsError(
"An error occurred when attempting to decommission the asset."
)
except InvalidInputsError as e:
print(e.message)
raise InvalidInputsError(e.message)
except Exception as e:
print(str(e))
raise InvalidInputsError(
"An error occurred when attempting to decommission the asset.")
def get_datacenter_id_from_name(self, datacenter_name):
try:
datacenter_id = self.dc_table.get_datacenter_id_by_name(
datacenter_name)
if datacenter_id is None:
return -1
return datacenter_id
except:
raise InvalidInputsError(
"An error occurred while trying to retrieve datacenter info corresponding to the instance."
)
def delete_datacenter(self, dc_data):
try:
dc_name = self.check_null(dc_data[Constants.DC_NAME_KEY])
if dc_name == "":
raise InvalidInputsError(
"Must provide a datacenter name to delete")
try:
delete_validation_result = self.validate.delete_dc_validation(
dc_name)
except InvalidInputsError as e:
return e.message
if delete_validation_result == Constants.API_SUCCESS:
self.dc_table.delete_datacenter_by_name(dc_name)
else:
return InvalidInputsError(delete_validation_result)
except:
raise InvalidInputsError(
"An error occurred when trying to delete the specified asset.")
def get_instances(self, filter, dc_name, limit: int):
model_name = filter.get(Constants.MODEL_KEY)
try:
if model_name is not None and model_name != "":
print("MODEL_NAME")
print(model_name)
model_id = self.get_model_id_from_name(model_name)
else:
model_id = None
except:
raise InvalidInputsError(
"An error occurred while trying to filter by model name. Please input a different model name"
)
try:
if dc_name is not None:
dc_id = self.get_datacenter_id_from_name(dc_name)
if dc_id == -1:
dc_id = None
except:
raise InvalidInputsError(
"An error occurred while trying to filter by datacenter name. Please input a different model name"
)
hostname = filter.get(Constants.HOSTNAME_KEY)
rack_label = filter.get(Constants.RACK_KEY)
rack_position = filter.get(Constants.RACK_POSITION_KEY)
try:
instance_list = self.table.get_instances_with_filters(
model_id=model_id,
hostname=hostname,
rack_label=rack_label,
rack_position=rack_position,
datacenter_id=dc_id,
limit=limit,
)
return instance_list
except:
raise InvalidInputsError(
"An error occurred while trying to retrieve instance data.")
def detail_view(self, instance_data):
print(instance_data)
asset_number = instance_data.get(Constants.ASSET_NUMBER_KEY)
try:
print("Get these things")
print(asset_number)
instance = self.table.get_instance_by_asset_number(asset_number)
return instance
except:
raise InvalidInputsError(
"An error occured while retrieving data for this asset.")
def detail_view(self, model_data):
print("model data")
print(model_data)
vendor = self.check_null(model_data[Constants.VENDOR_KEY])
model_number = self.check_null(model_data[Constants.MODEL_NUMBER_KEY])
try:
model = self.table.get_model_by_vendor_number(vendor, model_number)
return model
except:
raise InvalidInputsError(
"An error occured while trying to retrieve the model data.")
def delete_change_plan(self, cp_data):
try:
identifier = self.check_null(cp_data.get(Constants.CHANGE_PLAN_ID_KEY))
change_plan = self.cp_table.get_change_plan(identifier)
if change_plan is None:
raise InvalidInputsError("Could not find change plan to be deleted.")
if change_plan.executed:
raise InvalidInputsError(
"Cannot delete a change plan that has been executed."
)
self.cp_action_table.delete_all_actions_for_change_plan(identifier)
self.cp_table.delete_change_plan_by_id(identifier)
except InvalidInputsError as e:
print(e.message)
raise InvalidInputsError(e.message)
except Exception as e:
print(str(e))
raise InvalidInputsError(
"An error occurred when attempting to delete the change plan."
)
def create_datacenter(self, dc_data):
try:
try:
new_datacenter = self.make_datacenter(dc_data)
if type(new_datacenter) is InvalidInputsError:
return new_datacenter
except InvalidInputsError as e:
return e.message
try:
create_validation_result = self.validate.create_dc_validation(
new_datacenter)
except InvalidInputsError as e:
return e.message
if create_validation_result == Constants.API_SUCCESS:
self.dc_table.add_datacenter(new_datacenter)
else:
return InvalidInputsError(create_validation_result)
except:
raise InvalidInputsError(
"An error occurred when attempting to create the datacenter.")
def get_distinct_vendors_with_prefix(self, prefix_json):
try:
return_list = []
vendor_list = self.table.get_distinct_vendors()
for vendor in vendor_list:
# if vendor.startswith(prefix):
return_list.append(vendor)
return return_list
except:
raise InvalidInputsError(
"An error occurred when trying to load previous vendors.")
def set_pdu_power(self, rack_letter, rack_number, side, port, state):
state = state.lower()
pdu_id = ""
try:
self.validate_state(state)
self.validate_port(port)
pdu_id = self.format_pdu_id(rack_letter, rack_number, side)
except InvalidInputsError as e:
raise InvalidInputsError(e.message)
url = f"{Constants.PDU_NET_PRO_HOST}:{Constants.PDU_NET_PRO_PORT}/power.php"
data = {
"v": state,
"pdu": pdu_id,
"port": port,
}
response = requests.post(url, data=data)
if response.status_code != 200:
raise InvalidInputsError(
"Could not set PDU power remotely, request failed.")
return response.status_code
def get_possible_models_with_filters(self, prefix_json):
try:
return_list = []
model_list = self.model_table.get_all_models()
for model in model_list:
model_name = model.vendor + " " + model.model_number
# if model_name.startswith(prefix):
return_list.append(model_name)
return return_list
except:
raise InvalidInputsError(
"An error occurred while trying to retrieve model options.")
