def getIpFabric(self, ipFabricId): report = ResourceAllocationReport(dao = self.dao) ipFabric = report.getIpFabric(ipFabricId) if ipFabric is not None: devices = ipFabric.devices #Detaching the object from session session = Session.object_session(ipFabric) session.expunge(ipFabric) ipFabric.__dict__.pop('_sa_instance_state') ipFabric.__dict__.pop('spineJunosImage') ipFabric.__dict__.pop('leafJunosImage') ipFabric.__dict__.pop('inventoryData') ipFabric.__dict__['devices'] = {'uri': bottle.request.url + '/devices', 'total':len(devices)} ipFabric.__dict__['cablingPlan'] = {'uri': bottle.request.url + '/cabling-plan'} ipFabric.__dict__['deviceConfiguration'] = {'uri': bottle.request.url + '/device-configuration'} ipFabric.__dict__['ztpConfiguration'] = {'uri': bottle.request.url + '/ztp-configuration'} logger.debug('getIpFabric: %s' % (ipFabricId)) #return json.dumps(ipFabric.__dict__) return {'ipFabric': ipFabric.__dict__} else: logger.debug("IpFabric with id: %s not found" % (ipFabricId)) raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId))
def deleteIpFabric(self, ipFabricId): report = ResourceAllocationReport(dao = self.dao) ipFabric = report.getIpFabric(ipFabricId) if ipFabric is not None: report.dao.deleteObject(ipFabric) logger.debug("IpFabric with id: %s deleted" % (ipFabricId)) else: logger.debug("IpFabric with id: %s not found" % (ipFabricId)) raise bottle.HTTPError(204, "IpFabric with id: %s not found" % (ipFabricId)) return bottle.HTTPResponse(status=200)
def deleteIpFabric(self, ipFabricId): report = ResourceAllocationReport(dao=self.dao) ipFabric = report.getIpFabric(ipFabricId) if ipFabric is not None: report.dao.deleteObject(ipFabric) logger.debug("IpFabric with id: %s deleted" % (ipFabricId)) else: logger.debug("IpFabric with id: %s not found" % (ipFabricId)) raise bottle.HTTPError( 204, "IpFabric with id: %s not found" % (ipFabricId)) return bottle.HTTPResponse(status=200)
def getIpFabric(self, ipFabricId): report = ResourceAllocationReport(dao=self.dao) ipFabric = report.getIpFabric(ipFabricId) if ipFabric is not None: devices = ipFabric.devices #Detaching the object from session session = Session.object_session(ipFabric) session.expunge(ipFabric) ipFabric.__dict__.pop('_sa_instance_state') ipFabric.__dict__.pop('spineJunosImage') ipFabric.__dict__.pop('leafJunosImage') ipFabric.__dict__.pop('inventoryData') ipFabric.__dict__['devices'] = { 'uri': bottle.request.url + '/devices', 'total': len(devices) } ipFabric.__dict__['cablingPlan'] = { 'uri': bottle.request.url + '/cabling-plan' } ipFabric.__dict__['deviceConfiguration'] = { 'uri': bottle.request.url + '/device-configuration' } ipFabric.__dict__['ztpConfiguration'] = { 'uri': bottle.request.url + '/ztp-configuration' } logger.debug('getIpFabric: %s' % (ipFabricId)) #return json.dumps(ipFabric.__dict__) return {'ipFabric': ipFabric.__dict__} else: logger.debug("IpFabric with id: %s not found" % (ipFabricId)) raise bottle.HTTPError( 404, "IpFabric with id: %s not found" % (ipFabricId))
class RestServer(): def __init__(self, conf = {}, daoClass = Dao): global logger if any(conf) == False: self.__conf = util.loadConfig(appName = moduleName) global webServerRoot webServerRoot = self.__conf['outputDir'] else: self.__conf = conf logger = logging.getLogger(moduleName) self.__daoClass = daoClass self.__dao = daoClass.getInstance() self.openclosDbSessionPlugin = OpenclosDbSessionPlugin(daoClass) if 'httpServer' in self.__conf and 'ipAddr' in self.__conf['httpServer'] and self.__conf['httpServer']['ipAddr'] is not None: self.host = self.__conf['httpServer']['ipAddr'] else: self.host = 'localhost' if 'httpServer' in self.__conf and 'port' in self.__conf['httpServer']: self.port = self.__conf['httpServer']['port'] else: self.port = 8080 self.baseUrl = 'http://%s:%d' % (self.host, self.port) self.report = ResourceAllocationReport(self.__conf, daoClass) # Create a single instance of l2Report as it holds thread-pool # for device connection. Don't create l2Report multiple times self.l2Report = L2Report(self.__conf, daoClass) # Create a single instance of l3Report as it holds thread-pool # for device connection. Don't create l3Report multiple times self.l3Report = L3Report(self.__conf, daoClass) def initRest(self): self.addRoutes(self.baseUrl) self.app = bottle.app() self.app.install(loggingPlugin) self.app.install(self.openclosDbSessionPlugin) logger.info('RestServer initRest() done') def _reset(self): """ Resets the state of the rest server and application Used for Test only """ self.app.uninstall(loggingPlugin) self.app.uninstall(OpenclosDbSessionPlugin) def start(self): logger.info('REST server starting at %s:%d' % (self.host, self.port)) debugRest = False if logger.isEnabledFor(logging.DEBUG): debugRest = True if util.isSqliteUsed(self.__conf): bottle.run(self.app, host=self.host, port=self.port, debug=debugRest) else: bottle.run(self.app, host=self.host, port=self.port, debug=debugRest, server='paste') @staticmethod @error(400) def error400(error): bottle.response.headers['Content-Type'] = 'application/json' if error.exception is not None: return json.dumps({'errorCode': error.exception.errorId , 'errorMessage' : error.exception.errorMessage}) else: return json.dumps({'errorCode': 0, 'errorMessage' : 'A generic error occurred'}) def addRoutes(self, baseUrl): self.indexLinks = [] # GET APIs bottle.route('/', 'GET', self.getIndex) bottle.route('/openclos', 'GET', self.getIndex) bottle.route('/openclos/conf', 'GET', self.getOpenClosConfigParams) bottle.route('/openclos/ip-fabrics', 'GET', self.getIpFabrics) bottle.route('/openclos/images/<junosImageName>', 'GET', self.getJunosImage) bottle.route('/openclos/ip-fabrics/<ipFabricId>', 'GET', self.getIpFabric) bottle.route('/openclos/ip-fabrics/<ipFabricId>/cabling-plan', 'GET', self.getCablingPlan) bottle.route('/openclos/ip-fabrics/<ipFabricId>/ztp-configuration','GET', self.getZtpConfig) bottle.route('/openclos/ip-fabrics/<ipFabricId>/device-configuration', 'GET', self.getDeviceConfigsInZip) bottle.route('/openclos/ip-fabrics/<ipFabricId>/leaf-generic-configurations/<deviceModel>', 'GET', self.getLeafGenericConfiguration) bottle.route('/openclos/ip-fabrics/<ipFabricId>/l2-report', 'GET', self.getL2Report) bottle.route('/openclos/ip-fabrics/<ipFabricId>/l3-report', 'GET', self.getL3Report) bottle.route('/openclos/ip-fabrics/<ipFabricId>/devices', 'GET', self.getDevices) bottle.route('/openclos/ip-fabrics/<ipFabricId>/devices/<deviceId>', 'GET', self.getDevice) bottle.route('/openclos/ip-fabrics/<ipFabricId>/devices/<deviceId>/config', 'GET', self.getDeviceConfig) # POST/PUT APIs bottle.route('/openclos/ip-fabrics', 'POST', self.createIpFabric) bottle.route('/openclos/ip-fabrics/<ipFabricId>/cabling-plan', 'PUT', self.createCablingPlan) bottle.route('/openclos/ip-fabrics/<ipFabricId>/device-configuration', 'PUT', self.createDeviceConfiguration) bottle.route('/openclos/ip-fabrics/<ipFabricId>/ztp-configuration', 'PUT', self.createZtpConfiguration) bottle.route('/openclos/ip-fabrics/<ipFabricId>', 'PUT', self.reconfigIpFabric) bottle.route('/openclos/conf/', 'PUT', self.setOpenClosConfigParams) # DELETE APIs bottle.route('/openclos/ip-fabrics/<ipFabricId>', 'DELETE', self.deleteIpFabric) self.createLinkForConfigs() def createLinkForConfigs(self): # index page should show all top level URLs # users whould be able to drill down through navigation self.indexLinks.append(ResourceLink(self.baseUrl, '/openclos/ip-fabrics')) self.indexLinks.append(ResourceLink(self.baseUrl, '/openclos/conf')) def getIndex(self, dbSession=None): if 'openclos' not in bottle.request.url: bottle.redirect(bottle.request.url + 'openclos') jsonLinks = [] for link in self.indexLinks: jsonLinks.append({'link': link.toDict()}) jsonBody = \ {'href': bottle.request.url, 'links': jsonLinks } return jsonBody def getIpFabrics(self, dbSession): url = bottle.request.url ipFabricsData = {} listOfIpFbarics = [] IpFabrics = self.report.getPods(dbSession) logger.debug("count of ipFabrics: %d", len(IpFabrics)) if not IpFabrics : logger.debug("There are no ipFabrics in the system ") for i in range(len(IpFabrics)): ipFabric = {} ipFabric['uri'] = url +'/'+ IpFabrics[i]['id'] ipFabric['id'] = IpFabrics[i]['id'] ipFabric['name'] = IpFabrics[i]['name'] ipFabric['spineDeviceType'] = IpFabrics[i]['spineDeviceType'] ipFabric['spineCount'] = IpFabrics[i]['spineCount'] ipFabric['leafSettings'] = IpFabrics[i]['leafSettings'] ipFabric['leafCount'] = IpFabrics[i]['leafCount'] ipFabric['devicePassword'] = IpFabrics[i]['devicePassword'] listOfIpFbarics.append(ipFabric) ipFabricsData['ipFabric'] = listOfIpFbarics ipFabricsData['total'] = len(listOfIpFbarics) ipFabricsData['uri'] = url return {'ipFabrics' : ipFabricsData} def getIpFabric(self, dbSession, ipFabricId, requestUrl = None): if requestUrl is None: requestUrl = bottle.request.url ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is not None: outputDict = {} devices = ipFabric.devices outputDict['id'] = ipFabric.id outputDict['name'] = ipFabric.name outputDict['description'] = ipFabric.description outputDict['spineAS'] = ipFabric.spineAS outputDict['spineDeviceType'] = ipFabric.spineDeviceType outputDict['spineCount'] = ipFabric.spineCount outputDict['leafAS'] = ipFabric.leafAS outputDict['leafSettings'] = [] for leafSetting in ipFabric.leafSettings: outputDict['leafSettings'].append({'deviceType': leafSetting.deviceFamily, 'junosImage': leafSetting.junosImage}) outputDict['leafCount'] = ipFabric.leafCount outputDict['loopbackPrefix'] = ipFabric.loopbackPrefix outputDict['vlanPrefix'] = ipFabric.vlanPrefix outputDict['interConnectPrefix'] = ipFabric.interConnectPrefix outputDict['managementPrefix'] = ipFabric.managementPrefix outputDict['outOfBandAddressList'] = ipFabric.outOfBandAddressList outputDict['outOfBandGateway'] = ipFabric.outOfBandGateway outputDict['topologyType'] = ipFabric.topologyType outputDict['spineJunosImage'] = ipFabric.spineJunosImage outputDict['devicePassword'] = ipFabric.getCleartextPassword() outputDict['uri'] = requestUrl outputDict['devices'] = {'uri': requestUrl + '/devices', 'total':len(devices)} outputDict['cablingPlan'] = {'uri': requestUrl + '/cabling-plan'} outputDict['deviceConfiguration'] = {'uri': requestUrl + '/device-configuration'} outputDict['ztpConfiguration'] = {'uri': requestUrl + '/ztp-configuration'} outputDict['l2Report'] = {'uri': requestUrl + '/l2-report'} outputDict['l3Report'] = {'uri': requestUrl + '/l3-report'} logger.debug('getIpFabric: %s' % (ipFabricId)) return {'ipFabric': outputDict} else: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) def getCablingPlan(self, dbSession, ipFabricId): header = bottle.request.get_header('Accept') logger.debug('Accept header: %s' % (header)) ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is not None: logger.debug('IpFabric name: %s' % (ipFabric.name)) if header == 'application/json': cablingPlan = ipFabric.cablingPlan if cablingPlan is not None and cablingPlan.json is not None: logger.debug('CablingPlan found in DB') return cablingPlan.json else: raise bottle.HTTPError(404, "IpFabric: %s exists but no CablingPlan found in DB" % (ipFabric.id)) else: ipFabricFolder = ipFabric.id + '-' + ipFabric.name fileName = os.path.join(ipFabricFolder, 'cablingPlan.dot') logger.debug('webServerRoot: %s, fileName: %s, exists: %s' % (webServerRoot, fileName, os.path.exists(os.path.join(webServerRoot, fileName)))) logger.debug('Cabling file name: %s' % (fileName)) cablingPlan = bottle.static_file(fileName, root=webServerRoot) if isinstance(cablingPlan, bottle.HTTPError): raise bottle.HTTPError(404, "IpFabric exists but no CablingPlan found. IpFabric: '%s " % (ipFabricFolder)) return cablingPlan else: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) def getLeafGenericConfiguration(self, dbSession, ipFabricId, deviceModel): ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is None: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) logger.debug('IpFabric name: %s, id: %s' % (ipFabric.name, ipFabricId)) leafSetting = self.__dao.getLeafSetting(dbSession, ipFabricId, deviceModel) if leafSetting is None or leafSetting.config is None: raise bottle.HTTPError(404, "IpFabric exists but no leaf generic config found, probably configuration \ was not created. deviceModel: %s, ipFabric name: '%s', id: '%s'" % (deviceModel, ipFabric.name, ipFabricId)) bottle.response.headers['Content-Type'] = 'application/json' return leafSetting.config def getDeviceConfigsInZip(self, dbSession, ipFabricId): ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is None: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) logger.debug('IpFabric name: %s' % (ipFabric.name)) zippedConfigFiles = self.createZipArchive(ipFabric) if zippedConfigFiles is not None: bottle.response.headers['Content-Type'] = 'application/zip' return zippedConfigFiles else: raise bottle.HTTPError(404, "IpFabric exists but no configs for devices.'%s " % (ipFabric.name)) def createZipArchive(self, ipFabric): buff = StringIO.StringIO() zipArchive = zipfile.ZipFile(buff, mode='w') for device in ipFabric.devices: fileName = device.id + '__' + device.name + '.conf' if device.config is not None: zipArchive.writestr(fileName, device.config.config) if ipFabric.leafSettings is not None: for leafSetting in ipFabric.leafSettings: if leafSetting.config is not None: zipArchive.writestr(leafSetting.deviceFamily + '.conf', leafSetting.config) zipArchive.close() logger.debug('zip file content:\n' + str(zipArchive.namelist())) return buff.getvalue() def getDevices(self, dbSession, ipFabricId): devices = {} listOfDevices = [] ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is not None: for device in ipFabric.devices: outputDict = {} outputDict['id'] = device.id outputDict['name'] = device.name outputDict['role'] = device.role outputDict['family'] = device.family outputDict['macAddress'] = device.macAddress outputDict['managementIp'] = device.managementIp outputDict['serialNumber'] = device.serialNumber outputDict['deployStatus'] = device.deployStatus outputDict['configStatus'] = device.configStatus outputDict['l2Status'] = device.l2Status outputDict['l3Status'] = device.l3Status outputDict['uri'] = bottle.request.url + '/' +device.id listOfDevices.append(outputDict) devices['device'] = listOfDevices devices['uri'] = bottle.request.url devices['total'] = len(ipFabric.devices) return {'devices' : devices} else: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) def getDevice(self, dbSession, ipFabricId, deviceId): device = self.isDeviceExists(dbSession, ipFabricId, deviceId) #ipFabricUri is constructed from url url = bottle.request.url uri = url.split("/") uri.pop() uri.pop() ipFbaricUri = "/".join(uri) if device is not None: outputDict = {} outputDict['id'] = device.id outputDict['name'] = device.name outputDict['role'] = device.role outputDict['family'] = device.family outputDict['username'] = device.username outputDict['password'] = device.getCleartextPassword() outputDict['macAddress'] = device.macAddress outputDict['managementIp'] = device.managementIp outputDict['asn'] = device.asn outputDict['configStatus'] = device.configStatus outputDict['configStatusReason'] = device.configStatusReason outputDict['l2Status'] = device.l2Status outputDict['l2StatusReason'] = device.l2StatusReason outputDict['l3Status'] = device.l3Status outputDict['l3StatusReason'] = device.l3StatusReason outputDict['serialNumber'] = device.serialNumber outputDict['deployStatus'] = device.deployStatus outputDict['uri'] = bottle.request.url outputDict['pod'] = {'uri': ipFbaricUri } outputDict['config'] = {'uri': bottle.request.url + '/config' } return {'device': outputDict} else: raise bottle.HTTPError(404, "device with id: %s not found" % (deviceId)) def getDeviceConfig(self, dbSession, ipFabricId, deviceId): device = self.isDeviceExists(dbSession, ipFabricId, deviceId) if device is None: raise bottle.HTTPError(404, "No device found with ipFabricId: '%s', deviceId: '%s'" % (ipFabricId, deviceId)) config = device.config if config is None: raise bottle.HTTPError(404, "Device exists but no config found, probably fabric script is not ran. ipFabricId: '%s', deviceId: '%s'" % (ipFabricId, deviceId)) bottle.response.headers['Content-Type'] = 'application/json' return config.config def getZtpConfig(self, dbSession, ipFabricId): ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is not None: logger.debug('Fabric name: %s' % (ipFabric.name)) ipFabricFolder = ipFabric.id + '-' + ipFabric.name fileName = os.path.join(ipFabricFolder, "dhcpd.conf") logger.debug('webServerRoot: %s, fileName: %s, exists: %s' % (webServerRoot, fileName, os.path.exists(os.path.join(webServerRoot, fileName)))) ztpConf = bottle.static_file(fileName, root=webServerRoot) if isinstance(ztpConf, bottle.HTTPError): raise bottle.HTTPError(404, "Pod exists but no ztp Config found. Pod name: '%s " % (ipFabric.name)) return ztpConf else: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) def isDeviceExists(self, dbSession, ipFabricId, deviceId): try: device = dbSession.query(Device).join(Pod).filter(Device.id == deviceId).filter(Pod.id == ipFabricId).one() return device except (exc.NoResultFound): raise bottle.HTTPError(404, "No device found with ipFabricId: '%s', deviceId: '%s'" % (ipFabricId, deviceId)) def getJunosImage(self, dbSession, junosImageName): fileName = os.path.join(junosImageRoot, junosImageName) logger.debug('junosImageRoot: %s, image: %s, exists: %s' % (junosImageRoot, junosImageName, os.path.exists(fileName))) config = bottle.static_file(junosImageName, root=junosImageRoot) if isinstance(config, bottle.HTTPError): raise bottle.HTTPError(404, "Junos image file not found. name: '%s'" % (junosImageName)) return config def getOpenClosConfigParams(self, dbSession): supportedDevices = [] for device in self.__conf['deviceFamily']: port = util.getPortNamesForDeviceFamily(device, self.__conf['deviceFamily']) deviceDetail = {} if len(port['uplinkPorts']) > 0: deviceDetail['family'] = device deviceDetail['uplinkStart'] = port['uplinkPorts'][0] deviceDetail['uplinkEnd'] = port['uplinkPorts'][len(port['uplinkPorts'])-1] deviceDetail['role'] = 'leaf' if len(port['downlinkPorts']) > 0: deviceDetail['downlinkStart'] = port['uplinkPorts'][0] deviceDetail['downlinkEnd'] = port['uplinkPorts'][len(port['uplinkPorts'])-1] deviceDetail['role'] = 'leaf' if len(port['uplinkPorts'])==0 and len(port['downlinkPorts']) == 0: if device == 'qfx5100-24q-2p': deviceDetail['role'] = 'spine' deviceDetail['family'] = device deviceDetail['downlinkStart'] = port['ports'][0] deviceDetail['downlinkEnd'] = port['ports'][len(port['ports'])-1] deviceDetail['uplinkStart'] = '' deviceDetail['uplinkEnd'] = '' supportedDevices.append(deviceDetail) confValues = {} confValues.update({'dbUrl': self.__conf['dbUrl']}) confValues.update({'supportedDevices' : supportedDevices }) confValues.update({'dotColors': self.__conf['DOT']['colors'] }) confValues.update({'httpServer' : self.__conf['httpServer']}) confValues.update({'snmpTrap' : self.__conf['snmpTrap']}) return {'OpenClosConf' : confValues } def createIpFabric(self, dbSession): if bottle.request.json is None: raise bottle.HTTPError(400, exception = RestError(0, "No json in request object")) else: pod = bottle.request.json.get('ipFabric') if pod is None: raise bottle.HTTPError(400, exception = RestError(0, "POST body can not be empty")) l3ClosMediation = L3ClosMediation(self.__conf, self.__daoClass) ipFabric = self.getPodFromDict(pod) ipFabricName = ipFabric.pop('name') fabricDevices = self.getDevDictFromDict(pod) try: fabric = l3ClosMediation.createPod(ipFabricName, ipFabric, fabricDevices) url = bottle.request.url + '/' + fabric.id ipFabric = self.getIpFabric(dbSession, fabric.id, url) except ValueError as e: logger.debug('StackTrace: %s' % (traceback.format_exc())) raise bottle.HTTPError(400, exception = RestError(0, e.message)) bottle.response.set_header('Location', url) bottle.response.status = 201 return ipFabric def createCablingPlan(self, dbSession, ipFabricId): try: l3ClosMediation = L3ClosMediation(self.__conf, self.__daoClass) if l3ClosMediation.createCablingPlan(ipFabricId) is True: return bottle.HTTPResponse(status=200) except ValueError: raise bottle.HTTPError(404, "Fabric with id[%s] not found" % (ipFabricId)) def createDeviceConfiguration(self, dbSession, ipFabricId): try: l3ClosMediation = L3ClosMediation(self.__conf, self.__daoClass) if l3ClosMediation.createDeviceConfig(ipFabricId) is True: return bottle.HTTPResponse(status=200) except ValueError: raise bottle.HTTPError(404, "Fabric with id[%s] not found" % (ipFabricId)) def createZtpConfiguration(self, dbSession, ipFabricId): try: ZtpServer.createPodSpecificDhcpConfFile(self, ipFabricId) except ValueError: raise bottle.HTTPError(404, "Fabric with id[%s] not found" % (ipFabricId)) def reconfigIpFabric(self, dbSession, ipFabricId): if bottle.request.json is None: raise bottle.HTTPError(400, exception = RestError(0, "No json in request object")) else: inPod = bottle.request.json.get('ipFabric') if inPod is None: raise bottle.HTTPError(400, exception = RestError(0, "POST body can not be empty")) l3ClosMediation = L3ClosMediation(self.__conf, self.__daoClass) ipFabric = self.getPodFromDict(inPod) #ipFabric['id'] = ipFabricId #ipFabric['uri'] = bottle.request.url fabricDevices = self.getDevDictFromDict(inPod) # Pass the ipFabric and fabricDevices dictionaries to config/update API, then return try: updatedFabric = l3ClosMediation.updatePod(ipFabricId, ipFabric, fabricDevices) url = bottle.request.url + '/' + updatedFabric.id return self.getIpFabric(dbSession, ipFabricId, url) except ValueError as e: raise bottle.HTTPError(400, exception = RestError(0, e.message)) def setOpenClosConfigParams(self): return bottle.HTTPResponse(status=200) def deleteIpFabric(self, dbSession, ipFabricId): ipFabric = self.report.getIpFabric(dbSession, ipFabricId) if ipFabric is not None: self.__dao.deleteObject(dbSession, ipFabric) util.deleteOutFolder(self.__conf, ipFabric) logger.debug("IpFabric with id: %s deleted" % (ipFabricId)) else: raise bottle.HTTPError(404, "IpFabric with id: %s not found" % (ipFabricId)) return bottle.HTTPResponse(status=204) def getPodFromDict(self, podDict): ipFabric = {} ''' # Need to revisit later on to make thing works as below. podDict.pop('devices') ipFabric = Pod(**inPod) ''' if podDict is None: raise bottle.HTTPError(400, exception = RestError(0, "Invalid value in POST/PUT body.")) ipFabric['name'] = podDict.get('name') ipFabric['fabricDeviceType'] = podDict.get('fabricDeviceType') ipFabric['fabricDeviceCount'] = podDict.get('fabricDeviceCount') ipFabric['spineCount'] = podDict.get('spineCount') ipFabric['spineDeviceType'] = podDict.get('spineDeviceType') ipFabric['leafCount'] = podDict.get('leafCount') ipFabric['leafSettings'] = podDict.get('leafSettings') ipFabric['leafUplinkcountMustBeUp'] = podDict.get('leafUplinkcountMustBeUp') ipFabric['interConnectPrefix'] = podDict.get('interConnectPrefix') ipFabric['vlanPrefix'] = podDict.get('vlanPrefix') ipFabric['loopbackPrefix'] = podDict.get('loopbackPrefix') ipFabric['spineAS'] = podDict.get('spineAS') ipFabric['leafAS'] = podDict.get('leafAS') ipFabric['topologyType'] = podDict.get('topologyType') ipFabric['outOfBandAddressList'] = podDict.get('outOfBandAddressList') ipFabric['outOfBandGateway'] = podDict.get('outOfBandGateway') ipFabric['managementPrefix'] = podDict.get('managementPrefix') ipFabric['hostOrVmCountPerLeaf'] = podDict.get('hostOrVmCountPerLeaf') ipFabric['description'] = podDict.get('description') ipFabric['devicePassword'] = podDict.get('devicePassword') return ipFabric def getDevDictFromDict(self, podDict): if podDict is not None: devices = podDict.get('devices') else: raise bottle.HTTPError(400, exception = RestError(0, "Invalid value in POST body.")) fabricDevices = {} spines = [] leaves = [] for device in devices: temp = {} temp['name'] = device.get('name') temp['macAddress'] = device.get('macAddress') temp['role'] = device.get('role') temp['username'] = device.get('username') temp['password'] = device.get('password') temp['family'] = device.get('family') temp['serialNumber'] = device.get('serialNumber') temp['deployStatus'] = device.get('deployStatus') if temp['role'] == 'spine': spines.append(temp) elif temp['role'] == 'leaf': leaves.append(temp) else: raise bottle.HTTPError(400, exception = RestError(0, "Unexpected role value in device inventory list")) fabricDevices['spines'] = spines fabricDevices['leafs'] = leaves return fabricDevices def getL2Report(self, dbSession, ipFabricId): try: cached = bottle.request.query.get('cached', '1') if cached == '1': cachedData = True else: cachedData = False bottle.response.headers['Content-Type'] = 'application/json' return self.l2Report.generateReport(ipFabricId, cachedData) except ValueError: raise bottle.HTTPError(404, "Fabric with id: %s not found" % (ipFabricId)) def getL3Report(self, dbSession, ipFabricId): try: cached = bottle.request.query.get('cached', '1') if cached == '1': cachedData = True else: cachedData = False bottle.response.headers['Content-Type'] = 'application/json' return self.l3Report.generateReport(ipFabricId, cachedData) except ValueError: raise bottle.HTTPError(404, "Fabric with id: %s not found" % (ipFabricId))