CRAB/python/GridCatService.py

#!/usr/bin/env python
"""
_GridCatService_

GridCat interface class that wraps the XMLRPC UI

"""

import xmlrpclib
import sys

class GridCatService:
    """
    _GridCatService_

    GridCat interface class generic interface class for no specific site

    """
    def __init__(self, gridCatURL):
        self._URL = gridCatURL
        try:
            self._Server = xmlrpclib.Server(self._URL)
        except StandardError, ex:
            #print ""
            msg = "Unable to connect to GridCat Server:\n"
            msg += "%s\n" % self._URL
            msg += "Error:\n%s\n" % str(ex)
            raise RuntimeError, msg

        
    def hostnames(self):
        """
        _hostnames_

        list hostnames
        """
        hostList = self._Server.hostnames().split()
        return hostList
    

    def sitenames(self):
        """
        _sitenames_

        return a list of sitenames
        """
        siteList = self._Server.sitenames().split()
        return siteList

    def mapSEtoCE(self, se_hostname):
        """
        _mapSEtoCE_
        returns CE(s) for an OSG SE
        Default None
        """
        # special : Multipel SE -> Single CE
        if se_hostname == "spraid.if.usp.br" : se_hostname = "spdc00.if.usp.br"
        ce_hostnames=[]
        try:
           ce_hostnames.append(self._Server.getresult("sites", "ldap_server_hostname", "WHERE ss_gatekeeper_hostname='"+se_hostname+"'").strip())

           # special : Mutiple CE <- Single SE
           if ce_hostnames[0] == 'cithep90.ultralight.org' :
              ce_hostnames=[]
              ce_hostnames.append('cit-gatekeeper.ultralight.org')

           if ce_hostnames[0] == 'ufloridapg.phys.ufl.edu' :
              ce_hostnames.append('ufgrid01.phys.ufl.edu')
              ce_hostnames.append('iogw1.hpc.ufl.edu')

           if ce_hostnames[0] == 'osg.rcac.purdue.edu' :
              ce_hostnames.append('lepton.rcac.purdue.edu')
              
        except StandardError, ex:
           ce_hostnames=None
           
        return ce_hostnames
    

class GridCatHostService(GridCatService):
    """
    _GridCatHostService_

    Specialisation of GridCatService that deals only with a single
    host, provided as a FQDN on instantiation
    
    """
    def __init__(self, serverURL, hostname):
        GridCatService.__init__(self, serverURL)
        self.hostname = hostname
        if hostname not in self.hostnames():
            msg = "GridCatService @ %s\n" % serverURL
            msg += "Does not know about host: %s\n" % hostname
            raise RuntimeError, msg
        sitename= self._Server.getresult("sites","name","WHERE cs_gatekeeper_hostname='"+hostname+"'").strip()
        self.sitename = sitename
        if sitename not in self.sitenames():
            msg = "GridCatService @ %s\n" % serverURL
            msg += "Does not know about site: %s\n" % sitename
            raise RuntimeError, msg

    def batchSystem(self):
        """
        _batchJobmanager_

        Default batch execution job manager 
        """
        #contact = self.gatekeeper()
        #contact += "/jobmanager-"
        #sitename= self._Server.getresult("sites","name","WHERE cs_gatekeeper_hostname='"+self.hostname+"'").strip()
        #    "site_info", "jobcon", self.sitename).strip()
        #return contact 
        #print "sitename ",sitename
        
        batchsystem=self._Server.getresult("site_info", "jobcon", "WHERE host_name='"+self.hostname+"'").strip()
        return batchsystem

class GridCatSiteService(GridCatService):
    """
    _GridCatSiteService_

    Specialisation of GridCatService that deals only with a single
    site, provided as a sitename on instantiation
    
    """
    def __init__(self, serverURL, sitename):
        GridCatService.__init__(self, serverURL)
        self.sitename = sitename
        if sitename not in self.sitenames():
            msg = "GridCatService @ %s\n" % serverURL
            msg += "Does not know about site: %s\n" % sitename
            raise RuntimeError, msg
        
        
    def jobmanagers(self):
        """
        _jobmanagers_

        return a list of jobmanagers for this site
        """
        jobmgrs = self._Server.jobmanagers(self.sitename)
        jobmgrs = jobmgrs.split(",")
        result = []
        for item in jobmgrs:
            result.append(item.strip())
        return result
    
    def gatekeeper(self):
        """
        _gatekeeper_

        return the gatekeeper hostname for the site
        """
        return self._Server.getsiteresult(
            'sites', 'cs_gatekeeper_hostname' , self.sitename).strip()
    

    #def batchSystem(self):
    #    """
    #    _batchJobmanager_

    #    Default batch execution job manager 
    #    """
        #contact = self.gatekeeper()
        #contact += "/jobmanager-"
        #contact += self._Server.getsiteresult(
        #    "site_info", "jobcon", self.sitename).strip()
        #return contact 
    #    self.sitename=
    #    return

    def batchJobmanager(self):
        """
        _batchJobmanager_

        Default batch execution job manager 
        """
        contact = self.gatekeeper()
        contact += "/jobmanager-"
        contact += self._Server.getsiteresult(
            "site_info", "jobcon", self.sitename).strip()
        return contact 

    def utilJobmanager(self):
        """
        _utilJobmanager_

        Default util jobmanager
        
        """
        contact = self.gatekeeper()
        contact += "/jobmanager-"
        contact += self._Server.getsiteresult(
            "site_info", "utilcon", self.sitename).strip()
        return contact 
    
    def sitestatus(self):
        """
        _sitestatus_

        return the site status
        """
        return self._Server.sitestatus(self.sitename)

    def authstatus(self):
        """
        _authstatus_
        """
        return self._Server.teststatus("auth", self.sitename)

    def directories(self):
        """
        _directories_

        return a dictionary of directory paths for the site
        """
        result = {
            "$app" : None,
            "$data" : None,
            "$tmp": None,
            }
        result["$app"] = self._Server.getsiteresult('site_info', 'appdir',
                                                    self.sitename).strip()
        result["$data"] = self._Server.getsiteresult('site_info', 'datadir',
                                                     self.sitename).strip()
        result["$tmp"] = self._Server.getsiteresult('site_info', 'tmpdir',
                                                    self.sitename).strip()

        return result
    

if __name__ == '__main__':

    print GridCatHostService(sys.argv[1],sys.argv[2]).batchSystem()
Revision:	1.4
Committed:	Fri Mar 30 02:33:47 2007 UTC (18 years, 1 month ago) by gutsche
Content type:	text/x-python
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.3:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Retire OSG information system GridCat and move to BDII queries for SE->CE mapping, jobmanager and site status ('Production' or not).
#	User	Rev	Content
1	gutsche	1.1	#!/usr/bin/env python
2			"""
3			_GridCatService_
4
5			GridCat interface class that wraps the XMLRPC UI
6
7			"""
8
9			import xmlrpclib
10			import sys
11
12			class GridCatService:
13			"""
14			_GridCatService_
15
16			GridCat interface class generic interface class for no specific site
17
18			"""
19			def __init__(self, gridCatURL):
20			self._URL = gridCatURL
21			try:
22			self._Server = xmlrpclib.Server(self._URL)
23			except StandardError, ex:
24			#print ""
25			msg = "Unable to connect to GridCat Server:\n"
26			msg += "%s\n" % self._URL
27			msg += "Error:\n%s\n" % str(ex)
28			raise RuntimeError, msg
29
30
31
32			def hostnames(self):
33			"""
34			_hostnames_
35
36			list hostnames
37			"""
38			hostList = self._Server.hostnames().split()
39			return hostList
40
41
42			def sitenames(self):
43			"""
44			_sitenames_
45
46			return a list of sitenames
47			"""
48			siteList = self._Server.sitenames().split()
49			return siteList
50	gutsche	1.3
51			def mapSEtoCE(self, se_hostname):
52			"""
53			_mapSEtoCE_
54			returns CE(s) for an OSG SE
55			Default None
56			"""
57			# special : Multipel SE -> Single CE
58			if se_hostname == "spraid.if.usp.br" : se_hostname = "spdc00.if.usp.br"
59			ce_hostnames=[]
60			try:
61			ce_hostnames.append(self._Server.getresult("sites", "ldap_server_hostname", "WHERE ss_gatekeeper_hostname='"+se_hostname+"'").strip())
62
63			# special : Mutiple CE <- Single SE
64			if ce_hostnames[0] == 'cithep90.ultralight.org' :
65			ce_hostnames=[]
66			ce_hostnames.append('cit-gatekeeper.ultralight.org')
67
68			if ce_hostnames[0] == 'ufloridapg.phys.ufl.edu' :
69			ce_hostnames.append('ufgrid01.phys.ufl.edu')
70			ce_hostnames.append('iogw1.hpc.ufl.edu')
71
72			if ce_hostnames[0] == 'osg.rcac.purdue.edu' :
73			ce_hostnames.append('lepton.rcac.purdue.edu')
74
75			except StandardError, ex:
76			ce_hostnames=None
77
78			return ce_hostnames
79	gutsche	1.1
80
81
82
83
84			class GridCatHostService(GridCatService):
85			"""
86			_GridCatHostService_
87
88			Specialisation of GridCatService that deals only with a single
89			host, provided as a FQDN on instantiation
90
91			"""
92			def __init__(self, serverURL, hostname):
93			GridCatService.__init__(self, serverURL)
94			self.hostname = hostname
95			if hostname not in self.hostnames():
96			msg = "GridCatService @ %s\n" % serverURL
97			msg += "Does not know about host: %s\n" % hostname
98			raise RuntimeError, msg
99			sitename= self._Server.getresult("sites","name","WHERE cs_gatekeeper_hostname='"+hostname+"'").strip()
100			self.sitename = sitename
101			if sitename not in self.sitenames():
102			msg = "GridCatService @ %s\n" % serverURL
103			msg += "Does not know about site: %s\n" % sitename
104			raise RuntimeError, msg
105
106			def batchSystem(self):
107			"""
108			_batchJobmanager_
109
110			Default batch execution job manager
111			"""
112			#contact = self.gatekeeper()
113			#contact += "/jobmanager-"
114			#sitename= self._Server.getresult("sites","name","WHERE cs_gatekeeper_hostname='"+self.hostname+"'").strip()
115			# "site_info", "jobcon", self.sitename).strip()
116			#return contact
117			#print "sitename ",sitename
118
119	gutsche	1.2	batchsystem=self._Server.getresult("site_info", "jobcon", "WHERE host_name='"+self.hostname+"'").strip()
120	gutsche	1.1	return batchsystem
121
122			class GridCatSiteService(GridCatService):
123			"""
124			_GridCatSiteService_
125
126			Specialisation of GridCatService that deals only with a single
127			site, provided as a sitename on instantiation
128
129			"""
130			def __init__(self, serverURL, sitename):
131			GridCatService.__init__(self, serverURL)
132			self.sitename = sitename
133			if sitename not in self.sitenames():
134			msg = "GridCatService @ %s\n" % serverURL
135			msg += "Does not know about site: %s\n" % sitename
136			raise RuntimeError, msg
137
138
139			def jobmanagers(self):
140			"""
141			_jobmanagers_
142
143			return a list of jobmanagers for this site
144			"""
145			jobmgrs = self._Server.jobmanagers(self.sitename)
146			jobmgrs = jobmgrs.split(",")
147			result = []
148			for item in jobmgrs:
149			result.append(item.strip())
150			return result
151
152			def gatekeeper(self):
153			"""
154			_gatekeeper_
155
156			return the gatekeeper hostname for the site
157			"""
158			return self._Server.getsiteresult(
159			'sites', 'cs_gatekeeper_hostname' , self.sitename).strip()
160
161
162			#def batchSystem(self):
163			# """
164			# _batchJobmanager_
165
166			# Default batch execution job manager
167			# """
168			#contact = self.gatekeeper()
169			#contact += "/jobmanager-"
170			#contact += self._Server.getsiteresult(
171			# "site_info", "jobcon", self.sitename).strip()
172			#return contact
173			# self.sitename=
174			# return
175
176			def batchJobmanager(self):
177			"""
178			_batchJobmanager_
179
180			Default batch execution job manager
181			"""
182			contact = self.gatekeeper()
183			contact += "/jobmanager-"
184			contact += self._Server.getsiteresult(
185			"site_info", "jobcon", self.sitename).strip()
186			return contact
187
188			def utilJobmanager(self):
189			"""
190			_utilJobmanager_
191
192			Default util jobmanager
193
194			"""
195			contact = self.gatekeeper()
196			contact += "/jobmanager-"
197			contact += self._Server.getsiteresult(
198			"site_info", "utilcon", self.sitename).strip()
199			return contact
200
201			def sitestatus(self):
202			"""
203			_sitestatus_
204
205			return the site status
206			"""
207			return self._Server.sitestatus(self.sitename)
208
209			def authstatus(self):
210			"""
211			_authstatus_
212			"""
213			return self._Server.teststatus("auth", self.sitename)
214
215			def directories(self):
216			"""
217			_directories_
218
219			return a dictionary of directory paths for the site
220			"""
221			result = {
222			"$app" : None,
223			"$data" : None,
224			"$tmp": None,
225			}
226			result["$app"] = self._Server.getsiteresult('site_info', 'appdir',
227			self.sitename).strip()
228			result["$data"] = self._Server.getsiteresult('site_info', 'datadir',
229			self.sitename).strip()
230			result["$tmp"] = self._Server.getsiteresult('site_info', 'tmpdir',
231			self.sitename).strip()
232
233			return result
234
235
236			if __name__ == '__main__':
237
238			print GridCatHostService(sys.argv[1],sys.argv[2]).batchSystem()