def parse(self, url): r''' Parse oracle JDBC url Styles of records used in url: old, new, tns, TNS name only @types: str -> tuple[db.DatabaseServer] @raise MalformedUrl: url cannot be parsed ''' partialUrl = self.trimUrlPrefix(url) if not partialUrl: raise MalformedUrl("Wrong url prefix") try: # TNS record as part of URL if partialUrl.startswith('('): server = self.parsePartialUrlTnsStyle(partialUrl) # new style elif partialUrl.startswith('//'): server = self.parsePartialUrlNewStyle(partialUrl) # old style elif partialUrl.find(':') != -1: server = self.parsePartialUrlOldStyle(partialUrl) # service name specified only else: server = db.DatabaseServer(instance=partialUrl) except: server = db.DatabaseServer() server.vendor = self.getPlatform().vendor return (server,)
def triggered_on_ipse_only(client, framework, dns_resolver, cred_id, ip, dbname, port, ipse_id): db_oshs, oshs, warnings = _discover(client, framework, dns_resolver, cred_id, dbname, port) config = DiscoveryConfig(framework, cred_id) reporter = db2_topology.Reporter() link_reporter = db2_topology.LinkReporter() node_osh = modeling.createOshByCmdbId('node', config.host_id) oshs.append(node_osh) instance = db.DatabaseServer(ip, port) inst_osh, _, _, vector = reporter.reportServerAndDatabases( instance, node_osh) oshs.extend(vector) alias_osh = reporter.reportDbAlias(dbname, inst_osh) db2_topology.Builder.update_credential_id(alias_osh, cred_id) oshs.append(alias_osh) if db_oshs: db_osh = db_oshs.pop() realization_osh = link_reporter.report_realization(alias_osh, db_osh) oshs.append(realization_osh) return oshs, warnings
def _buildGenericDatabaseServerPdo(type_, db_name, address, port, platform): db_server = db.DatabaseServer(address=address, port=port, platform=platform) if db_name: db_server.instance = db_name return db_server
def _buildDb2DatabaseServerPdo(type_, db_name, address, port, platform): db_server = db.DatabaseServer(address=address, port=port, platform=platform) if db_name: db_server.addDatabases(db.Database(db_name)) return db_server
def _buildDatabaseServer(self, addressItem, sid=None): r'@types: OracleTnsRecordParser._Item -> db.DatabaseServer' address, port = self._decomposeAddressPort(addressItem) databaseServer = db.DatabaseServer(address, port, platform=self.getPlatform()) databaseServer.addEndpoint(netutils.createTcpEndpoint(address, port)) if sid: databaseServer.instance = sid return databaseServer
def parse(self, url): ''' jdbc(:.*)?:sqlserver://<HOST>:<PORT>[;DatabaseName=<DB>] ''' url = self.trimUrlPrefix(url) tokens = url.split(';') hostPortPair = tokens[0] server = (hostPortPair and ParserHelper().parseHostBasedDatabaseUrl(hostPortPair) or db.DatabaseServer(vendor=self.getPlatform().vendor)) return (server,)
def parseResultItem(result): ''' Parse name, vendor, hostname and information version for server @types: ResultSet -> db.DatabaseServer ''' name = result.getString("DBNAME") vendor = result.getString("DBVENDOR") hostname = result.getString("DBHOSTNAME") version = result.getString("DBRELEASE") return db.DatabaseServer(hostname, instance=name, vendor=vendor, version=version)
def parse(self, url): r'''@types: str -> db.DatabaseServer @raise MalformedUrl: url cannot be parsed''' mo = self.__PATTERN.match(url) if not mo: raise MalformedUrl(url) address, databaseName = mo.groups() platform = db_platform.MaxDb() return db.DatabaseServer(address, databases=(databaseName,), vendor=platform.vendor, platform=platform)
def __parsePartialUrlByStyleTypePattern(self, pattern, partialUrl): r''' Dedicated to process similar patterns for old/new JDBC URL style @types: str, str -> db.DatabaseServer @raise MalformedUrl: Url cannot be parsed ''' matchObj = re.match(pattern, partialUrl, re.VERBOSE) if matchObj: host = matchObj.group(1) port = matchObj.group(3) sid = matchObj.group(4) return db.DatabaseServer(host, port, sid) raise MalformedUrl("Url cannot be parsed")
def parse(self, url): trimmedUrl = self.trimUrlPrefix(url) trimmedUrl, properties = self.parseProperties(trimmedUrl) dbName = trimmedUrl if not dbName and properties: for dbNamePropertyName in self._DB_NAME_PROP_NAMES: dbName = properties.get(dbNamePropertyName) if dbName: break return (db.DatabaseServer(databases=[db.Database(dbName)], vendor=self.getPlatform().vendor),)
def parse(self, url): r''' @types: str -> tuple[db.DatabaseServer] ''' trimmedUrl = self.trimUrlPrefix(url) tokens = trimmedUrl.split(';') locationCoordinates = tokens[0] coordinateTokens = locationCoordinates.split(':') address = port = None if len(coordinateTokens) == 2: address, port = coordinateTokens else: address = coordinateTokens[0] return (db.DatabaseServer(address, port, vendor=self.getPlatform().vendor),)
def __mergeDatabaseServers(self, prefferedSource, anotherSource): r'@types: db.DatabaseServer, db.DatabaseServer -> db.DatabaseServer or None' if prefferedSource and not anotherSource: return prefferedSource elif anotherSource and not prefferedSource: return anotherSource elif not anotherSource and not prefferedSource: return None address = prefferedSource.address or anotherSource.address port = prefferedSource.getPort() or anotherSource.getPort() instance = prefferedSource.instance or anotherSource.instance databases = prefferedSource.getDatabases( ) or anotherSource.getDatabases() vendor = prefferedSource.vendor or anotherSource.vendor return db.DatabaseServer(address, port, instance, databases, vendor)
def parse(self, url): ''' jdbc:HypersonicSQL:<DB> ''' url = self.trimUrlPrefix(url).strip() isInMemoryDatabase = url == '.' isClientServerMode = re.match('http://', url, re.I) # all servers except of one in client-server mode have address address = (not isClientServerMode and 'localhost' or None) # server in mode "in-memory" doesn't have database databases = (not isInMemoryDatabase and (db.Database(url.strip()),) or ()) return (db.DatabaseServer(address=address, databases=databases, vendor=self.getPlatform().vendor),)
def _converttoDbInstance(self, item): r'''@types: com.amazonaws.services.rds.model.DBInstance -> aws_rds.Instance getDBParameterGroups()#rovides the list of DB Parameter Groups applied to this DB Instance. com.amazonaws.services.rds.model.DBParameterGroupStatus getDBParameterGroupName() # The name of the DP Parameter Group. getParameterApplyStatus() # The status of parameter updates. getDBSecurityGroups() # Provides List of DB Security Group elements containing only DBSecurityGroup.Name and DBSecurityGroup.Status subelements. com.amazonaws.services.rds.model.DBSecurityGroupMembership getDBSecurityGroupName() getStatus() ''' dbName = item.getDBName() platform = db_platform.findPlatformBySignature(item.getEngine()) vendor = platform and platform.vendor databases = dbName and [db.Database(dbName)] endpoint = self._convertToTcpEndpoint(item.getEndpoint()) server = db.DatabaseServer(endpoint.getAddress(), endpoint.getPort(), databases=databases, vendor=vendor, version=item.getEngineVersion(), platform=platform) sizeInGb = item.getAllocatedStorage() sizeInMb = ((sizeInGb and str(sizeInGb).isnumeric) and sizeInGb * 1024 or None) return aws_rds.Instance( item.getDBInstanceIdentifier(), server, type=item.getDBInstanceClass(), status=item.getDBInstanceStatus(), licenseModel=item.getLicenseModel(), sizeInMb=sizeInMb, availabilityZoneName=item.getAvailabilityZone(), creationTime=item.getInstanceCreateTime(), engineName=item.getEngine(), parameterGroups=map(self._convertToParameterGroupStatus, item.getDBParameterGroups()), securityGroups=map(self._convertToSecurityGroupMembership, item.getDBSecurityGroups()))
def _report_instance(config, instance_name, version, db_osh, node_osh, endpoint_osh=None): instance_osh = None oshs = [] if config.db2_id: instance_osh = modeling.createOshByCmdbIdString('db2_instance', config.db2_id) oshs.append(instance_osh) elif instance_name: db2_builder = db2_topology.Builder() db2_reporter = db2_topology.Reporter(db2_builder) db2 = db.DatabaseServer(instance=instance_name, version=version) instance_osh, _, oshs_ = db2_reporter.reportServer(db2, node_osh) oshs.extend(oshs_) link_reporter = db2_topology.LinkReporter() oshs.append(link_reporter.report_lifecycle(db_osh, instance_osh)) if endpoint_osh: oshs.append(link_reporter.report_usage(instance_osh, endpoint_osh)) return instance_osh, oshs
def _parsePartialUrl(self, url): r'''@types: str -> db.DatabaseServer @raise MalformedUrl: url cannot be parsed ''' tokens = url.split(';', 1) endpointStr, propertiesSet = (len(tokens) == 2 and tokens or (tokens[0], None)) server = (endpointStr and ParserHelper().parseHostBasedUrl(endpointStr) or db.DatabaseServer()) server.vendor = self.getPlatform().vendor if propertiesSet: propertiesDefinitions = [p for p in propertiesSet.split(';') if p.find('=') != 1] for definition in propertiesDefinitions: name, value = definition.split('=', 1) name = name.lower() if name == 'servicename' and value: server.instance = value elif name == 'databasename' and value: server.addDatabases(db.Database(value)) return server
def _convertToDbSnapshot(self, item): r'@types: com.amazonaws.services.rds.model.DBSnapshot -> aws_rds.Snapshot' sizeInGb = item.getAllocatedStorage() sizeInMb = ((sizeInGb and str(sizeInGb).isnumeric) and sizeInGb * 1024 or None) # create database server platform = db_platform.findPlatformBySignature(item.getEngine()) vendor = platform and platform.vendor server = db.DatabaseServer(port=item.getPort(), vendor=vendor, versionDescription=item.getEngineVersion()) # create DB Instance based on server instance = aws_rds.Instance( item.getDBInstanceIdentifier(), server, licenseModel=item.getLicenseModel(), sizeInMb=sizeInMb, availabilityZoneName=item.getAvailabilityZone(), creationTime=item.getInstanceCreateTime()) # create DB Snapshot based on instance return aws_rds.Snapshot(item.getDBSnapshotIdentifier(), instance, creationTime=item.getSnapshotCreateTime(), status=item.getStatus())
def _report(node_osh, ip, svcename, instance_name=None, version=None, dbname=None): oshs = [] db2_builder = db2_topology.Builder() db2_reporter = db2_topology.Reporter(db2_builder) port = resolve_svcename_to_port_nr(svcename) db2 = db.DatabaseServer(address=ip, port=port, instance=instance_name, version=version) if dbname: database = db2_model.Database(dbname) database_pdo = db2_topology.build_database_pdo(db2, database) db2.addDatabases(database_pdo) _, _, db_oshs, oshs_ = db2_reporter.reportServerAndDatabases(db2, node_osh) oshs.extend(oshs_) return oshs, db_oshs
# _reportDbInstance = _partialFunc(reportDbInstance, _, awsReporter, accountOsh) # map(vector.addAll, map(_reportDbInstance, instances)) for instance in instances: dbServer = instance.getServer() # get more information about server using engine information # we get engine by its name and version for engine in engines: if (engine.getName() == instance.getEngineName() and engine.getVersion() == dbServer.getVersion()): # recreate server with additional information dbServer = db.DatabaseServer(dbServer.address, dbServer.getPort(), dbServer.instance, dbServer.getDatabases(), dbServer.vendor, engine.getVersionDescription(), dbServer.getPlatform(), dbServer.getVersion(), engine.getDescription()) break # determine builder using vendor of instance DB software platform = (dbServer.getPlatform() or db_platform.findPlatformBySignature(dbServer.vendor)) dbReporter = db.TopologyReporter( db_builder.getBuilderByPlatform(platform)) rdsReporter = aws_rds.Reporter(aws_rds.Builder()) # report instance node nodeOsh = rdsReporter.reportInstanceNode(instance)
def parseHostBasedUrl(self, partialUrl): r'@types: str -> db.DatabaseServer' matchObj = re.match(r'(.*?):(\d*)', partialUrl) address, port = matchObj and matchObj.groups() or (None, None) return db.DatabaseServer(address, port)
def parseHostBasedDatabaseUrl(self, partialUrl): ''' HOST:PORT/DB''' host, port, databasePart = self._parseHostBasedUrl(partialUrl) databases = databasePart and (db.Database(databasePart),) or () return db.DatabaseServer(host, port, databases=databases)
def parseHostBasedInstanceUrl(self, parialUrl): ''' HOST:PORT/Instance''' host, port, instancePart = self._parseHostBasedUrl(parialUrl) return db.DatabaseServer(host, port, instance=instancePart)