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.")