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)
