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).
#	Content
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
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
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	batchsystem=self._Server.getresult("site_info", "jobcon", "WHERE host_name='"+self.hostname+"'").strip()
120	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()