def __findServiceURL( self ):
if not self.__initStatus[ 'OK' ]:
return self.__initStatus
gatewayURL = False
if self.KW_IGNORE_GATEWAYS not in self.kwargs or not self.kwargs[ self.KW_IGNORE_GATEWAYS ]:
dRetVal = gConfig.getOption( "/DIRAC/Gateways/%s" % DIRAC.siteName() )
if dRetVal[ 'OK' ]:
rawGatewayURL = List.randomize( List.fromChar( dRetVal[ 'Value'], "," ) )[0]
gatewayURL = "/".join( rawGatewayURL.split( "/" )[:3] )
for protocol in gProtocolDict.keys():
if self._destinationSrv.find( "%s://" % protocol ) == 0:
gLogger.debug( "Already given a valid url", self._destinationSrv )
if not gatewayURL:
return S_OK( self._destinationSrv )
gLogger.debug( "Reconstructing given URL to pass through gateway" )
path = "/".join( self._destinationSrv.split( "/" )[3:] )
finalURL = "%s/%s" % ( gatewayURL, path )
gLogger.debug( "Gateway URL conversion:\n %s -> %s" % ( self._destinationSrv, finalURL ) )
return S_OK( finalURL )
if gatewayURL:
gLogger.debug( "Using gateway", gatewayURL )
return S_OK( "%s/%s" % ( gatewayURL, self._destinationSrv ) )
try:
urls = getServiceURL( self._destinationSrv, setup = self.setup )
except Exception, e:
return S_ERROR( "Cannot get URL for %s in setup %s: %s" % ( self._destinationSrv, self.setup, str( e ) ) )
def ClientSelector(disetClient, *args,
**kwargs): # We use same interface as RPCClient
"""
Select the correct Client (either RPC or Transfer ), instantiate it, and return it.
The selection is based on the URL:
* either it contains the protocol, in which case we make a choice
* or it is in the form <Component/Service>, in which case we resolve first
This is a generic function. You should rather use :py:class:`.RPCClientSelector`
or :py:class:`.TransferClientSelector`
In principle, the only place for this class to be used is in
:py:class:`DIRAC.Core.Base.Client.Client`, since it is the only
one supposed to instantiate an :py:class:`DIRAC.Core.Base.DISET.RPCClient.RPCClient`
:params disetClient: the DISET class to be instantiated, so either
:py:class:`DIRAC.Core.Base.DISET.RPCClient.RPCClient`
or :py:class:`DIRAC.Core.Base.DISET.TransferClient.TransferClient`
:param args: Whatever ``disetClient`` takes as args, but the first one is
always the URL we want to rely on.
It can be either "system/service" or "dips://domain:port/system/service"
:param kwargs: This can contain:
* Whatever ``disetClient`` takes.
* httpsClient: specific class inheriting from TornadoClient
"""
# We detect if we need to use a specific class for the HTTPS client
tornadoClient = kwargs.pop("httpsClient", TornadoClient)
# We have to make URL resolution BEFORE the RPCClient or TornadoClient to determine which one we want to use
# URL is defined as first argument (called serviceName) in RPCClient
try:
serviceName = args[0]
sLog.debug("Trying to autodetect client for %s" % serviceName)
# If we are not already given a URL, resolve it
if serviceName.startswith(("http", "dip")):
completeUrl = serviceName
else:
completeUrl = getServiceURL(serviceName)
sLog.debug("URL resolved: %s" % completeUrl)
if completeUrl.startswith("http"):
sLog.debug("Using HTTPS for service %s" % serviceName)
rpc = tornadoClient(*args, **kwargs)
else:
rpc = disetClient(*args, **kwargs)
except Exception as e: # pylint: disable=broad-except
# If anything went wrong in the resolution, we return default RPCClient
# So the behaviour is exactly the same as before implementation of Tornado
sLog.warn("Could not select DISET or Tornado client", "%s" % repr(e))
rpc = disetClient(*args, **kwargs)
return rpc
def __removeNonExistingResourcesFromRM(self):
"""
Remove resources from DowntimeCache table that no longer exist in the CS.
"""
if not getServiceURL("ResourceStatus/ResourceManagement"):
gLogger.verbose(
"ResourceManagement is not installed, skipping removal of non existing resources..."
)
return S_OK()
sesHosts = getStorageElementsHosts()
if not sesHosts["OK"]:
return sesHosts
sesHosts = sesHosts["Value"]
resources = sesHosts
ftsServer = getFTS3Servers(hostOnly=True)
if ftsServer["OK"]:
resources.extend(ftsServer["Value"])
res = getCESiteMapping()
if res["OK"]:
resources.extend(list(res["Value"]))
downtimes = self.rManagement.selectDowntimeCache()
if not downtimes["OK"]:
return downtimes
# Remove hosts that no longer exist in the CS
for host in downtimes["Value"]:
gLogger.verbose("Checking if %s is still in the CS" % host[0])
if host[0] not in resources:
gLogger.verbose("%s is no longer in CS, removing entry..." %
host[0])
result = self.rManagement.deleteDowntimeCache(name=host[0])
if not result["OK"]:
return result
return S_OK()
def __removeNonExistingResourcesFromRM(self):
'''
Remove resources from DowntimeCache table that no longer exist in the CS.
'''
if not getServiceURL("ResourceStatus/ResourceManagement"):
gLogger.verbose(
'ResourceManagement is not installed, skipping removal of non existing resources...'
)
return S_OK()
sesHosts = getStorageElementsHosts()
if not sesHosts['OK']:
return sesHosts
sesHosts = sesHosts['Value']
resources = sesHosts
ftsServer = getFTS3Servers(hostOnly=True)
if ftsServer['OK']:
resources.extend(ftsServer['Value'])
ce = CSHelpers.getComputingElements()
if ce['OK']:
resources.extend(ce['Value'])
downtimes = self.rManagement.selectDowntimeCache()
if not downtimes['OK']:
return downtimes
# Remove hosts that no longer exist in the CS
for host in downtimes['Value']:
gLogger.verbose('Checking if %s is still in the CS' % host[0])
if host[0] not in resources:
gLogger.verbose('%s is no longer in CS, removing entry...' %
host[0])
result = self.rManagement.deleteDowntimeCache(name=host[0])
if not result['OK']:
return result
return S_OK()
def __removeNonExistingResourcesFromRM(self):
'''
Remove resources from DowntimeCache table that no longer exist in the CS.
'''
if not getServiceURL("ResourceStatus/ResourceManagement"):
gLogger.verbose(
'ResourceManagement is not installed, skipping removal of non existing resources...')
return S_OK()
sesHosts = CSHelpers.getStorageElementsHosts()
if not sesHosts['OK']:
return sesHosts
sesHosts = sesHosts['Value']
resources = sesHosts
ftsServer = getFTS3Servers()
if ftsServer['OK']:
resources.extend(ftsServer['Value'])
ce = CSHelpers.getComputingElements()
if ce['OK']:
resources.extend(ce['Value'])
downtimes = self.rManagement.selectDowntimeCache()
if not downtimes['OK']:
return downtimes
# Remove hosts that no longer exist in the CS
for host in downtimes['Value']:
gLogger.verbose('Checking if %s is still in the CS' % host[0])
if host[0] not in resources:
gLogger.verbose(
'%s is no longer in CS, removing entry...' % host[0])
result = self.rManagement.deleteDowntimeCache(name=host[0])
if not result['OK']:
return result
return S_OK()
def __findServiceURL(self):
""" Discovers the URL of a service, taking into account gateways, multiple URLs, banned URLs
If the site on which we run is configured to use gateways (/DIRAC/Gateways/<siteName>),
these URLs will be used. To ignore the gateway, it is possible to set KW_IGNORE_GATEWAYS
to False in kwargs.
If self._destinationSrv (given as constructor attribute) is a properly formed URL,
we just return this one. If we have to use a gateway, we just replace the server name in the url.
The list of URLs defined in the CS (<System>/URLs/<Component>) is randomized
This method also sets some attributes:
* self.__nbOfUrls = number of URLs
* self.__nbOfRetry = 2 if we have more than 2 urls, otherwise 3
* self.__bannedUrls is reinitialized if all the URLs are banned
:return: S_OK(str)/S_ERROR() -- the selected URL
"""
if not self.__initStatus['OK']:
return self.__initStatus
# Load the Gateways URLs for the current site Name
gatewayURL = False
if not self.kwargs.get(self.KW_IGNORE_GATEWAYS):
dRetVal = gConfig.getOption("/DIRAC/Gateways/%s" % DIRAC.siteName())
if dRetVal['OK']:
rawGatewayURL = List.randomize(List.fromChar(dRetVal['Value'], ","))[0]
gatewayURL = "/".join(rawGatewayURL.split("/")[:3])
# If what was given as constructor attribute is a properly formed URL,
# we just return this one.
# If we have to use a gateway, we just replace the server name in it
for protocol in gProtocolDict:
if self._destinationSrv.find("%s://" % protocol) == 0:
gLogger.debug("Already given a valid url", self._destinationSrv)
if not gatewayURL:
return S_OK(self._destinationSrv)
gLogger.debug("Reconstructing given URL to pass through gateway")
path = "/".join(self._destinationSrv.split("/")[3:])
finalURL = "%s/%s" % (gatewayURL, path)
gLogger.debug("Gateway URL conversion:\n %s -> %s" % (self._destinationSrv, finalURL))
return S_OK(finalURL)
if gatewayURL:
gLogger.debug("Using gateway", gatewayURL)
return S_OK("%s/%s" % (gatewayURL, self._destinationSrv))
# We extract the list of URLs from the CS (System/URLs/Component)
try:
urls = getServiceURL(self._destinationSrv, setup=self.setup)
except Exception as e:
return S_ERROR("Cannot get URL for %s in setup %s: %s" % (self._destinationSrv, self.setup, repr(e)))
if not urls:
return S_ERROR("URL for service %s not found" % self._destinationSrv)
failoverUrls = []
# Try if there are some failover URLs to use as last resort
try:
failoverUrlsStr = getServiceFailoverURL(self._destinationSrv, setup=self.setup)
if failoverUrlsStr:
failoverUrls = failoverUrlsStr.split(',')
except Exception as e:
pass
# We randomize the list, and add at the end the failover URLs (System/FailoverURLs/Component)
urlsList = List.randomize(List.fromChar(urls, ",")) + failoverUrls
self.__nbOfUrls = len(urlsList)
self.__nbOfRetry = 2 if self.__nbOfUrls > 2 else 3 # we retry 2 times all services, if we run more than 2 services
if self.__nbOfUrls == len(self.__bannedUrls):
self.__bannedUrls = [] # retry all urls
gLogger.debug("Retrying again all URLs")
if len(self.__bannedUrls) > 0 and len(urlsList) > 1:
# we have host which is not accessible. We remove that host from the list.
# We only remove if we have more than one instance
for i in self.__bannedUrls:
gLogger.debug("Removing banned URL", "%s" % i)
urlsList.remove(i)
# Take the first URL from the list
# randUrls = List.randomize( urlsList ) + failoverUrls
sURL = urlsList[0]
# If we have banned URLs, and several URLs at disposals, we make sure that the selected sURL
# is not on a host which is banned. If it is, we take the next one in the list using __selectUrl
# If we have banned URLs, and several URLs at disposals, we make sure that the selected sURL
# is not on a host which is banned. If it is, we take the next one in the list using __selectUrl
if len(self.__bannedUrls) > 0 and self.__nbOfUrls > 2: # when we have multiple services then we can
# have a situation when two services are running on the same machine with different ports...
retVal = Network.splitURL(sURL)
nexturl = None
if retVal['OK']:
nexturl = retVal['Value']
found = False
for i in self.__bannedUrls:
retVal = Network.splitURL(i)
if retVal['OK']:
bannedurl = retVal['Value']
else:
break
# We found a banned URL on the same host as the one we are running on
if nexturl[1] == bannedurl[1]:
found = True
break
if found:
nexturl = self.__selectUrl(nexturl, urlsList[1:])
if nexturl: # an url found which is in different host
sURL = nexturl
gLogger.debug("Discovering URL for service", "%s -> %s" % (self._destinationSrv, sURL))
return S_OK(sURL)
def __findServiceURL(self):
if not self.__initStatus['OK']:
return self.__initStatus
gatewayURL = False
if self.KW_IGNORE_GATEWAYS not in self.kwargs or not self.kwargs[
self.KW_IGNORE_GATEWAYS]:
dRetVal = gConfig.getOption("/DIRAC/Gateways/%s" %
DIRAC.siteName())
if dRetVal['OK']:
rawGatewayURL = List.randomize(
List.fromChar(dRetVal['Value'], ","))[0]
gatewayURL = "/".join(rawGatewayURL.split("/")[:3])
for protocol in gProtocolDict.keys():
if self._destinationSrv.find("%s://" % protocol) == 0:
gLogger.debug("Already given a valid url",
self._destinationSrv)
if not gatewayURL:
return S_OK(self._destinationSrv)
gLogger.debug(
"Reconstructing given URL to pass through gateway")
path = "/".join(self._destinationSrv.split("/")[3:])
finalURL = "%s/%s" % (gatewayURL, path)
gLogger.debug("Gateway URL conversion:\n %s -> %s" %
(self._destinationSrv, finalURL))
return S_OK(finalURL)
if gatewayURL:
gLogger.debug("Using gateway", gatewayURL)
return S_OK("%s/%s" % (gatewayURL, self._destinationSrv))
try:
urls = getServiceURL(self._destinationSrv, setup=self.setup)
except Exception as e:
return S_ERROR("Cannot get URL for %s in setup %s: %s" %
(self._destinationSrv, self.setup, repr(e)))
if not urls:
return S_ERROR("URL for service %s not found" %
self._destinationSrv)
urlsList = List.fromChar(urls, ",")
self.__nbOfUrls = len(urlsList)
self.__nbOfRetry = 2 if self.__nbOfUrls > 2 else 3 # we retry 2 times all services, if we run more than 2 services
if len(urlsList) == len(self.__bannedUrls):
self.__bannedUrls = [] # retry all urls
gLogger.debug("Retrying again all URLs")
if len(self.__bannedUrls) > 0 and len(urlsList) > 1:
# we have host which is not accessible. We remove that host from the list.
# We only remove if we have more than one instance
for i in self.__bannedUrls:
gLogger.debug("Removing banned URL", "%s" % i)
urlsList.remove(i)
randUrls = List.randomize(urlsList)
sURL = randUrls[0]
if len(
self.__bannedUrls
) > 0 and self.__nbOfUrls > 2: # when we have multiple services then we can have a situation
# when two service are running on the same machine with different port...
retVal = Network.splitURL(sURL)
nexturl = None
if retVal['OK']:
nexturl = retVal['Value']
found = False
for i in self.__bannedUrls:
retVal = Network.splitURL(i)
if retVal['OK']:
bannedurl = retVal['Value']
else:
break
if nexturl[1] == bannedurl[1]:
found = True
break
if found:
nexturl = self.__selectUrl(nexturl, randUrls[1:])
if nexturl: # an url found which is in different host
sURL = nexturl
gLogger.debug("Discovering URL for service",
"%s -> %s" % (self._destinationSrv, sURL))
return S_OK(sURL)
def test_getServiceMainURL(self):
"""Fetching a URL referencing the MainServers"""
result = getServiceURL('WorkloadManagement/Service2')
correctResult = 'dips://gw1:5678/WorkloadManagement/Service2,dips://gw2:5678/WorkloadManagement/Service2'
self.assertEqual(result, correctResult)
def test_getServiceURLSimple(self):
"""Fetching a URL defined normally"""
result = getServiceURL('WorkloadManagement/Service1')
correctResult = 'dips://server1:1234/WorkloadManagement/Service1'
self.assertEqual(result, correctResult)
def __findServiceURL(self):
"""
Discovers the URL of a service, taking into account gateways, multiple URLs, banned URLs
If the site on which we run is configured to use gateways (/DIRAC/Gateways/<siteName>),
these URLs will be used. To ignore the gateway, it is possible to set KW_IGNORE_GATEWAYS
to False in kwargs.
If self._destinationSrv (given as constructor attribute) is a properly formed URL,
we just return this one. If we have to use a gateway, we just replace the server name in the url.
The list of URLs defined in the CS (<System>/URLs/<Component>) is randomized
This method also sets some attributes:
* self.__nbOfUrls = number of URLs
* self.__nbOfRetry = 2 if we have more than 2 urls, otherwise 3
* self.__bannedUrls is reinitialized if all the URLs are banned
:return: the selected URL
"""
if not self.__initStatus['OK']:
return self.__initStatus
# Load the Gateways URLs for the current site Name
gatewayURL = False
if self.KW_IGNORE_GATEWAYS not in self.kwargs or not self.kwargs[self.KW_IGNORE_GATEWAYS]:
dRetVal = gConfig.getOption("/DIRAC/Gateways/%s" % DIRAC.siteName())
if dRetVal['OK']:
rawGatewayURL = List.randomize(List.fromChar(dRetVal['Value'], ","))[0]
gatewayURL = "/".join(rawGatewayURL.split("/")[:3])
# If what was given as constructor attribute is a properly formed URL,
# we just return this one.
# If we have to use a gateway, we just replace the server name in it
for protocol in gProtocolDict:
if self._destinationSrv.find("%s://" % protocol) == 0:
gLogger.debug("Already given a valid url", self._destinationSrv)
if not gatewayURL:
return S_OK(self._destinationSrv)
gLogger.debug("Reconstructing given URL to pass through gateway")
path = "/".join(self._destinationSrv.split("/")[3:])
finalURL = "%s/%s" % (gatewayURL, path)
gLogger.debug("Gateway URL conversion:\n %s -> %s" % (self._destinationSrv, finalURL))
return S_OK(finalURL)
if gatewayURL:
gLogger.debug("Using gateway", gatewayURL)
return S_OK("%s/%s" % (gatewayURL, self._destinationSrv))
# We extract the list of URLs from the CS (System/URLs/Component)
try:
urls = getServiceURL(self._destinationSrv, setup=self.setup)
except Exception as e:
return S_ERROR("Cannot get URL for %s in setup %s: %s" % (self._destinationSrv, self.setup, repr(e)))
if not urls:
return S_ERROR("URL for service %s not found" % self._destinationSrv)
failoverUrls = []
# Try if there are some failover URLs to use as last resort
try:
failoverUrlsStr = getServiceFailoverURL(self._destinationSrv, setup=self.setup)
if failoverUrlsStr:
failoverUrls = failoverUrlsStr.split(',')
except Exception as e:
pass
# We randomize the list, and add at the end the failover URLs (System/FailoverURLs/Component)
urlsList = List.randomize(List.fromChar(urls, ",")) + failoverUrls
self.__nbOfUrls = len(urlsList)
self.__nbOfRetry = 2 if self.__nbOfUrls > 2 else 3 # we retry 2 times all services, if we run more than 2 services
if self.__nbOfUrls == len(self.__bannedUrls):
self.__bannedUrls = [] # retry all urls
gLogger.debug("Retrying again all URLs")
if len(self.__bannedUrls) > 0 and len(urlsList) > 1:
# we have host which is not accessible. We remove that host from the list.
# We only remove if we have more than one instance
for i in self.__bannedUrls:
gLogger.debug("Removing banned URL", "%s" % i)
urlsList.remove(i)
# Take the first URL from the list
#randUrls = List.randomize( urlsList ) + failoverUrls
sURL = urlsList[0]
# If we have banned URLs, and several URLs at disposals, we make sure that the selected sURL
# is not on a host which is banned. If it is, we take the next one in the list using __selectUrl
# If we have banned URLs, and several URLs at disposals, we make sure that the selected sURL
# is not on a host which is banned. If it is, we take the next one in the list using __selectUrl
if len(self.__bannedUrls) > 0 and self.__nbOfUrls > 2: # when we have multiple services then we can
# have a situation when two services are running on the same machine with different ports...
retVal = Network.splitURL(sURL)
nexturl = None
if retVal['OK']:
nexturl = retVal['Value']
found = False
for i in self.__bannedUrls:
retVal = Network.splitURL(i)
if retVal['OK']:
bannedurl = retVal['Value']
else:
break
# We found a banned URL on the same host as the one we are running on
if nexturl[1] == bannedurl[1]:
found = True
break
if found:
nexturl = self.__selectUrl(nexturl, urlsList[1:])
if nexturl: # an url found which is in different host
sURL = nexturl
gLogger.debug("Discovering URL for service", "%s -> %s" % (self._destinationSrv, sURL))
return S_OK(sURL)
def test_getServiceMainURL( self ):
"""Fetching a URL referencing the MainServers"""
result = getServiceURL('WorkloadManagement/Service2')
correctResult = 'dips://gw1:5678/WorkloadManagement/Service2,dips://gw2:5678/WorkloadManagement/Service2'
self.assertEqual(result, correctResult)
def test_getServiceURLSimple( self ):
"""Fetching a URL defined normally"""
result = getServiceURL('WorkloadManagement/Service1')
correctResult = 'dips://server1:1234/WorkloadManagement/Service1'
self.assertEqual(result, correctResult)
def __findServiceURL( self ):
if not self.__initStatus[ 'OK' ]:
return self.__initStatus
gatewayURL = False
if self.KW_IGNORE_GATEWAYS not in self.kwargs or not self.kwargs[ self.KW_IGNORE_GATEWAYS ]:
dRetVal = gConfig.getOption( "/DIRAC/Gateways/%s" % DIRAC.siteName() )
if dRetVal[ 'OK' ]:
rawGatewayURL = List.randomize( List.fromChar( dRetVal[ 'Value'], "," ) )[0]
gatewayURL = "/".join( rawGatewayURL.split( "/" )[:3] )
for protocol in gProtocolDict.keys():
if self._destinationSrv.find( "%s://" % protocol ) == 0:
gLogger.debug( "Already given a valid url", self._destinationSrv )
if not gatewayURL:
return S_OK( self._destinationSrv )
gLogger.debug( "Reconstructing given URL to pass through gateway" )
path = "/".join( self._destinationSrv.split( "/" )[3:] )
finalURL = "%s/%s" % ( gatewayURL, path )
gLogger.debug( "Gateway URL conversion:\n %s -> %s" % ( self._destinationSrv, finalURL ) )
return S_OK( finalURL )
if gatewayURL:
gLogger.debug( "Using gateway", gatewayURL )
return S_OK( "%s/%s" % ( gatewayURL, self._destinationSrv ) )
try:
urls = getServiceURL( self._destinationSrv, setup = self.setup )
except Exception as e:
return S_ERROR( "Cannot get URL for %s in setup %s: %s" % ( self._destinationSrv, self.setup, repr( e ) ) )
if not urls:
return S_ERROR( "URL for service %s not found" % self._destinationSrv )
urlsList = List.fromChar( urls, "," )
self.__nbOfUrls = len( urlsList )
self.__nbOfRetry = 2 if self.__nbOfUrls > 2 else 3 # we retry 2 times all services, if we run more than 2 services
if len( urlsList ) == len( self.__bannedUrls ):
self.__bannedUrls = [] # retry all urls
gLogger.debug( "Retrying again all URLs" )
if len( self.__bannedUrls ) > 0 and len( urlsList ) > 1 :
# we have host which is not accessible. We remove that host from the list.
# We only remove if we have more than one instance
for i in self.__bannedUrls:
gLogger.debug( "Removing banned URL", "%s" % i )
urlsList.remove( i )
randUrls = List.randomize( urlsList )
sURL = randUrls[0]
if len( self.__bannedUrls ) > 0 and self.__nbOfUrls > 2: # when we have multiple services then we can have a situation
# when two service are running on the same machine with different port...
retVal = Network.splitURL( sURL )
nexturl = None
if retVal['OK']:
nexturl = retVal['Value']
found = False
for i in self.__bannedUrls:
retVal = Network.splitURL( i )
if retVal['OK']:
bannedurl = retVal['Value']
else:
break
if nexturl[1] == bannedurl[1]:
found = True
break
if found:
nexturl = self.__selectUrl( nexturl, randUrls[1:] )
if nexturl: # an url found which is in different host
sURL = nexturl
gLogger.debug( "Discovering URL for service", "%s -> %s" % ( self._destinationSrv, sURL ) )
return S_OK( sURL )
def getDestinationService(self):
"""
Returns the url the service.
"""
return getServiceURL(self._serviceName)
