resolve circular import
[sfa.git] / sfa / util / api.py
1 #
2 # SFA XML-RPC and SOAP interfaces
3 #
4 ### $Id$
5 ### $URL$
6 #
7
8 import sys
9 import os
10 import traceback
11 import string
12 import xmlrpclib
13
14 from sfa.trust.auth import Auth
15 from sfa.util.config import *
16 from sfa.util.faults import *
17 from sfa.util.debug import *
18 from sfa.trust.credential import *
19 from sfa.trust.certificate import *
20 from sfa.util.namespace import *
21 from sfa.util.sfalogging import *
22
23 # See "2.2 Characters" in the XML specification:
24 #
25 # #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
26 # avoiding
27 # [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF]
28
29 invalid_xml_ascii = map(chr, range(0x0, 0x8) + [0xB, 0xC] + range(0xE, 0x1F))
30 xml_escape_table = string.maketrans("".join(invalid_xml_ascii), "?" * len(invalid_xml_ascii))
31
32 def xmlrpclib_escape(s, replace = string.replace):
33     """
34     xmlrpclib does not handle invalid 7-bit control characters. This
35     function augments xmlrpclib.escape, which by default only replaces
36     '&', '<', and '>' with entities.
37     """
38
39     # This is the standard xmlrpclib.escape function
40     s = replace(s, "&", "&amp;")
41     s = replace(s, "<", "&lt;")
42     s = replace(s, ">", "&gt;",)
43
44     # Replace invalid 7-bit control characters with '?'
45     return s.translate(xml_escape_table)
46
47 def xmlrpclib_dump(self, value, write):
48     """
49     xmlrpclib cannot marshal instances of subclasses of built-in
50     types. This function overrides xmlrpclib.Marshaller.__dump so that
51     any value that is an instance of one of its acceptable types is
52     marshalled as that type.
53
54     xmlrpclib also cannot handle invalid 7-bit control characters. See
55     above.
56     """
57
58     # Use our escape function
59     args = [self, value, write]
60     if isinstance(value, (str, unicode)):
61         args.append(xmlrpclib_escape)
62
63     try:
64         # Try for an exact match first
65         f = self.dispatch[type(value)]
66     except KeyError:
67         raise
68         # Try for an isinstance() match
69         for Type, f in self.dispatch.iteritems():
70             if isinstance(value, Type):
71                 f(*args)
72                 return
73         raise TypeError, "cannot marshal %s objects" % type(value)
74     else:
75         f(*args)
76
77 # You can't hide from me!
78 xmlrpclib.Marshaller._Marshaller__dump = xmlrpclib_dump
79
80 # SOAP support is optional
81 try:
82     import SOAPpy
83     from SOAPpy.Parser import parseSOAPRPC
84     from SOAPpy.Types import faultType
85     from SOAPpy.NS import NS
86     from SOAPpy.SOAPBuilder import buildSOAP
87 except ImportError:
88     SOAPpy = None
89
90
91 def import_deep(name):
92     mod = __import__(name)
93     components = name.split('.')
94     for comp in components[1:]:
95         mod = getattr(mod, comp)
96     return mod
97
98 class BaseAPI:
99
100     def __init__(self, config = "/etc/sfa/sfa_config.py", encoding = "utf-8", methods='sfa.methods',
101
102                  peer_cert = None, interface = None, key_file = None, cert_file = None):
103
104         self.encoding = encoding
105         
106         # flat list of method names
107          
108         self.methods_module = methods_module = __import__(methods, fromlist=[methods])
109         self.methods = methods_module.all
110
111         # Better just be documenting the API
112         if config is None:
113             return
114         
115         # Load configuration
116         self.config = Config(config)
117         self.auth = Auth(peer_cert)
118         self.hrn = self.config.SFA_INTERFACE_HRN
119         self.interface = interface
120         self.key_file = key_file
121         self.key = Keypair(filename=self.key_file)
122         self.cert_file = cert_file
123         self.cert = Certificate(filename=self.cert_file)
124         self.credential = None
125         self.source = None 
126         self.time_format = "%Y-%m-%d %H:%M:%S"
127         self.logger=get_sfa_logger()
128         
129         # load registries
130         from sfa.server.registry import Registries
131         self.registries = Registries(self) 
132
133         # load aggregates
134         from sfa.server.aggregate import Aggregates
135         self.aggregates = Aggregates(self)
136
137
138     def callable(self, method):
139         """
140         Return a new instance of the specified method.
141         """
142         # Look up method
143         if method not in self.methods:
144             raise SfaInvalidAPIMethod, method
145         
146         # Get new instance of method
147         try:
148             classname = method.split(".")[-1]
149             module = __import__(self.methods_module.__name__ + "." + method, globals(), locals(), [classname])
150             callablemethod = getattr(module, classname)(self)
151             return getattr(module, classname)(self)
152         except ImportError, AttributeError:
153             raise SfaInvalidAPIMethod, method
154
155     def call(self, source, method, *args):
156         """
157         Call the named method from the specified source with the
158         specified arguments.
159         """
160         function = self.callable(method)
161         function.source = source
162         self.source = source
163         return function(*args)
164
165     def handle(self, source, data):
166         """
167         Handle an XML-RPC or SOAP request from the specified source.
168         """
169         # Parse request into method name and arguments
170         try:
171             interface = xmlrpclib
172             (args, method) = xmlrpclib.loads(data)
173             methodresponse = True
174         except Exception, e:
175             if SOAPpy is not None:
176                 interface = SOAPpy
177                 (r, header, body, attrs) = parseSOAPRPC(data, header = 1, body = 1, attrs = 1)
178                 method = r._name
179                 args = r._aslist()
180                 # XXX Support named arguments
181             else:
182                 raise e
183
184         try:
185             result = self.call(source, method, *args)
186         except Exception, fault:
187             traceback.print_exc(file = log)
188             # Handle expected faults
189             if interface == xmlrpclib:
190                 result = fault
191                 methodresponse = None
192             elif interface == SOAPpy:
193                 result = faultParameter(NS.ENV_T + ":Server", "Method Failed", method)
194                 result._setDetail("Fault %d: %s" % (fault.faultCode, fault.faultString))
195             else:
196                 raise
197
198         # Return result
199         if interface == xmlrpclib:
200             if not isinstance(result, SfaFault):
201                 result = (result,)
202
203             data = xmlrpclib.dumps(result, methodresponse = True, encoding = self.encoding, allow_none = 1)
204         elif interface == SOAPpy:
205             data = buildSOAP(kw = {'%sResponse' % method: {'Result': result}}, encoding = self.encoding)
206
207         return data
208