1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93 """
94 An XML-RPC client interface for Python.
95
96 The marshalling and response parser code can also be used to
97 implement XML-RPC servers.
98
99 Exported exceptions:
100
101 Error Base class for client errors
102 ProtocolError Indicates an HTTP protocol error
103 ResponseError Indicates a broken response package
104 Fault Indicates an XML-RPC fault package
105
106 Exported classes:
107
108 ServerProxy Represents a logical connection to an XML-RPC server
109
110 MultiCall Executor of boxcared xmlrpc requests
111 Boolean boolean wrapper to generate a "boolean" XML-RPC value
112 DateTime dateTime wrapper for an ISO 8601 string or time tuple or
113 localtime integer value to generate a "dateTime.iso8601"
114 XML-RPC value
115 Binary binary data wrapper
116
117 SlowParser Slow but safe standard parser (based on xmllib)
118 Marshaller Generate an XML-RPC params chunk from a Python data structure
119 Unmarshaller Unmarshal an XML-RPC response from incoming XML event message
120 Transport Handles an HTTP transaction to an XML-RPC server
121 SafeTransport Handles an HTTPS transaction to an XML-RPC server
122
123 Exported constants:
124
125 True
126 False
127
128 Exported functions:
129
130 boolean Convert any Python value to an XML-RPC boolean
131 getparser Create instance of the fastest available parser & attach
132 to an unmarshalling object
133 dumps Convert an argument tuple or a Fault instance to an XML-RPC
134 request (or response, if the methodresponse option is used).
135 loads Convert an XML-RPC packet to unmarshalled data plus a method
136 name (None if not present).
137 """
138
139 import re, string, time, operator
140
141 from types import *
142
143
144
145
146 try:
147 unicode
148 except NameError:
149 unicode = None
150
151 try:
152 import datetime
153 except ImportError:
154 datetime = None
155
156 try:
157 _bool_is_builtin = False.__class__.__name__ == "bool"
158 except NameError:
159 _bool_is_builtin = 0
160
161 -def _decode(data, encoding, is8bit=re.compile("[\x80-\xff]").search):
162
163 if unicode and encoding and is8bit(data):
164 data = unicode(data, encoding)
165 return data
166
167 -def escape(s, replace=string.replace):
168 s = replace(s, "&", "&")
169 s = replace(s, "<", "<")
170 return replace(s, ">", ">",)
171
172 if unicode:
174
175 try:
176 return string.encode("ascii")
177 except UnicodeError:
178 return string
179 else:
182
183 __version__ = "1.0.1"
184
185
186 MAXINT = 2L**31-1
187 MININT = -2L**31
188
189
190
191
192
193
194 PARSE_ERROR = -32700
195 SERVER_ERROR = -32600
196 APPLICATION_ERROR = -32500
197 SYSTEM_ERROR = -32400
198 TRANSPORT_ERROR = -32300
199
200
201 NOT_WELLFORMED_ERROR = -32700
202 UNSUPPORTED_ENCODING = -32701
203 INVALID_ENCODING_CHAR = -32702
204 INVALID_XMLRPC = -32600
205 METHOD_NOT_FOUND = -32601
206 INVALID_METHOD_PARAMS = -32602
207 INTERNAL_ERROR = -32603
208
209
210
211
212
213
214
216 """Base class for client errors."""
219
220
221
222
223
224
225
226
227
228
229
231 """Indicates an HTTP protocol error."""
232 - def __init__(self, url, errcode, errmsg, headers):
233 Error.__init__(self)
234 self.url = url
235 self.errcode = errcode
236 self.errmsg = errmsg
237 self.headers = headers
239 return (
240 "<ProtocolError for %s: %s %s>" %
241 (self.url, self.errcode, self.errmsg)
242 )
243
244
245
246
247
248
250 """Indicates a broken response package."""
251 pass
252
253
254
255
256
257
258
259
260
261
263 """Indicates an XML-RPC fault package."""
264 - def __init__(self, faultCode, faultString, **extra):
265 Error.__init__(self)
266 self.faultCode = faultCode
267 self.faultString = faultString
269 return (
270 "<Fault %s: %s>" %
271 (self.faultCode, repr(self.faultString))
272 )
273
274
275
276
277
278
279
280
281
282
283
284
285 if _bool_is_builtin:
286 boolean = Boolean = bool
287
288 True, False = True, False
289 else:
291 """Boolean-value wrapper.
292
293 Use True or False to generate a "boolean" XML-RPC value.
294 """
295
297 self.value = operator.truth(value)
298
300 out.write("<value><boolean>%d</boolean></value>\n" % self.value)
301
303 if isinstance(other, Boolean):
304 other = other.value
305 return cmp(self.value, other)
306
308 if self.value:
309 return "<Boolean True at %x>" % id(self)
310 else:
311 return "<Boolean False at %x>" % id(self)
312
315
318
319 True, False = Boolean(1), Boolean(0)
320
321
322
323
324
325
326
327
328
329
330
331
333 """Convert any Python value to XML-RPC 'boolean'."""
334 return _truefalse[operator.truth(value)]
335
336
337
338
339
340
341
342
343
344
345
346
347
348
350 """DateTime wrapper for an ISO 8601 string or time tuple or
351 localtime integer value to generate 'dateTime.iso8601' XML-RPC
352 value.
353 """
354
356 if not isinstance(value, StringType):
357 if datetime and isinstance(value, datetime.datetime):
358 self.value = value.strftime("%Y%m%dT%H:%M:%S")
359 return
360 if datetime and isinstance(value, datetime.date):
361 self.value = value.strftime("%Y%m%dT%H:%M:%S")
362 return
363 if datetime and isinstance(value, datetime.time):
364 today = datetime.datetime.now().strftime("%Y%m%d")
365 self.value = value.strftime(today+"T%H:%M:%S")
366 return
367 if not isinstance(value, (TupleType, time.struct_time)):
368 if value == 0:
369 value = time.time()
370 value = time.localtime(value)
371 value = time.strftime("%Y%m%dT%H:%M:%S", value)
372 self.value = value
373
375 if isinstance(other, DateTime):
376 other = other.value
377 return cmp(self.value, other)
378
379
380
381
382
383
386
388 return "<DateTime %s at %x>" % (repr(self.value), id(self))
389
393
395 out.write("<value><dateTime.iso8601>")
396 out.write(self.value)
397 out.write("</dateTime.iso8601></value>\n")
398
400
401 value = DateTime()
402 value.decode(data)
403 return value
404
408
409
410
411
412
413
414
415 import base64
416 try:
417 import cStringIO as StringIO
418 except ImportError:
419 import StringIO
420
422 """Wrapper for binary data."""
423
426
427
428
429
430
431
433 return self.data or ""
434
436 if isinstance(other, Binary):
437 other = other.data
438 return cmp(self.data, other)
439
441 self.data = base64.decodestring(data)
442
444 out.write("<value><base64>\n")
445 base64.encode(StringIO.StringIO(self.data), out)
446 out.write("</base64></value>\n")
447
449
450 value = Binary()
451 value.decode(data)
452 return value
453
454 WRAPPERS = (DateTime, Binary)
455 if not _bool_is_builtin:
456 WRAPPERS = WRAPPERS + (Boolean,)
457
458
459
460
461 try:
462
463 import _xmlrpclib
464 FastParser = _xmlrpclib.Parser
465 FastUnmarshaller = _xmlrpclib.Unmarshaller
466 except (AttributeError, ImportError):
467 FastParser = FastUnmarshaller = None
468
469 try:
470 import _xmlrpclib
471 FastMarshaller = _xmlrpclib.Marshaller
472 except (AttributeError, ImportError):
473 FastMarshaller = None
474
475
476
477
478
479
480
481
482 try:
483 import sgmlop
484 if not hasattr(sgmlop, "XMLParser"):
485 raise ImportError
486 except ImportError:
487 SgmlopParser = None
488 else:
491
492
493 self.finish_starttag = target.start
494 self.finish_endtag = target.end
495 self.handle_data = target.data
496 self.handle_xml = target.xml
497
498
499 self.parser = sgmlop.XMLParser()
500 self.parser.register(self)
501 self.feed = self.parser.feed
502 self.entity = {
503 "amp": "&", "gt": ">", "lt": "<",
504 "apos": "'", "quot": '"'
505 }
506
508 try:
509 self.parser.close()
510 finally:
511 self.parser = self.feed = None
512
514 m = re.search("encoding\s*=\s*['\"]([^\"']+)[\"']", attr)
515 if m:
516 self.handle_xml(m.group(1), 1)
517
519
520 try:
521 self.handle_data(self.entity[entity])
522 except KeyError:
523 self.handle_data("&%s;" % entity)
524
525 try:
526 from xml.parsers import expat
527 if not hasattr(expat, "ParserCreate"):
528 raise ImportError
529 except ImportError:
530 ExpatParser = None
531 else:
533
534
536 self._parser = parser = expat.ParserCreate(None, None)
537 self._target = target
538 parser.StartElementHandler = target.start
539 parser.EndElementHandler = target.end
540 parser.CharacterDataHandler = target.data
541 encoding = None
542 if not parser.returns_unicode:
543 encoding = "utf-8"
544 target.xml(encoding, None)
545
546 - def feed(self, data):
547 self._parser.Parse(data, 0)
548
550 self._parser.Parse("", 1)
551 del self._target, self._parser
552
554 """Default XML parser (based on xmllib.XMLParser)."""
555
556
558 import xmllib
559 if xmllib.XMLParser not in SlowParser.__bases__:
560 SlowParser.__bases__ = (xmllib.XMLParser,)
561 self.handle_xml = target.xml
562 self.unknown_starttag = target.start
563 self.handle_data = target.data
564 self.handle_cdata = target.data
565 self.unknown_endtag = target.end
566 try:
567 xmllib.XMLParser.__init__(self, accept_utf8=1)
568 except TypeError:
569 xmllib.XMLParser.__init__(self)
570
571
572
573
574
575
576
577
578
579
580
582 """Generate an XML-RPC params chunk from a Python data structure.
583
584 Create a Marshaller instance for each set of parameters, and use
585 the "dumps" method to convert your data (represented as a tuple)
586 to an XML-RPC params chunk. To write a fault response, pass a
587 Fault instance instead. You may prefer to use the "dumps" module
588 function for this purpose.
589 """
590
591
592
593
594 - def __init__(self, encoding=None, allow_none=0):
595 self.memo = {}
596 self.data = None
597 self.encoding = encoding
598 self.allow_none = allow_none
599
600 dispatch = {}
601
602 - def dumps(self, values):
603 out = []
604 write = out.append
605 dump = self.__dump
606 if isinstance(values, Fault):
607
608 write("<fault>\n")
609 dump({'faultCode': values.faultCode,
610 'faultString': values.faultString},
611 write)
612 write("</fault>\n")
613 else:
614
615
616
617
618
619
620 write("<params>\n")
621 for v in values:
622 write("<param>\n")
623 dump(v, write)
624 write("</param>\n")
625 write("</params>\n")
626 result = string.join(out, "")
627 return result
628
629 - def __dump(self, value, write):
630 try:
631 f = self.dispatch[type(value)]
632 except KeyError:
633 raise TypeError, "cannot marshal %s objects" % type(value)
634 else:
635 f(self, value, write)
636
638 if not self.allow_none:
639 raise TypeError, "cannot marshal None unless allow_none is enabled"
640 write("<value><nil/></value>")
641 dispatch[NoneType] = dump_nil
642
644
645 if value > MAXINT or value < MININT:
646 raise OverflowError, "int exceeds XML-RPC limits"
647 write("<value><int>")
648 write(str(value))
649 write("</int></value>\n")
650 dispatch[IntType] = dump_int
651
652 if _bool_is_builtin:
654 write("<value><boolean>")
655 write(value and "1" or "0")
656 write("</boolean></value>\n")
657 dispatch[bool] = dump_bool
658
660 if value > MAXINT or value < MININT:
661 raise OverflowError, "long int exceeds XML-RPC limits"
662 write("<value><int>")
663 write(str(int(value)))
664 write("</int></value>\n")
665 dispatch[LongType] = dump_long
666
668 write("<value><double>")
669 write(repr(value))
670 write("</double></value>\n")
671 dispatch[FloatType] = dump_double
672
674 write("<value><string>")
675 write(escape(value))
676 write("</string></value>\n")
677 dispatch[StringType] = dump_string
678
679 if unicode:
681 value = value.encode(self.encoding)
682 write("<value><string>")
683 write(escape(value))
684 write("</string></value>\n")
685 dispatch[UnicodeType] = dump_unicode
686
688 i = id(value)
689 if self.memo.has_key(i):
690 raise TypeError, "cannot marshal recursive sequences"
691 self.memo[i] = None
692 dump = self.__dump
693 write("<value><array><data>\n")
694 for v in value:
695 dump(v, write)
696 write("</data></array></value>\n")
697 del self.memo[i]
698 dispatch[TupleType] = dump_array
699 dispatch[ListType] = dump_array
700
702 i = id(value)
703 if self.memo.has_key(i):
704 raise TypeError, "cannot marshal recursive dictionaries"
705 self.memo[i] = None
706 dump = self.__dump
707 write("<value><struct>\n")
708 for k, v in value.items():
709 write("<member>\n")
710 if type(k) is not StringType:
711 if unicode and type(k) is UnicodeType:
712 k = k.encode(self.encoding)
713 else:
714 raise TypeError, "dictionary key must be string"
715 write("<name>%s</name>\n" % escape(k))
716 dump(v, write)
717 write("</member>\n")
718 write("</struct></value>\n")
719 del self.memo[i]
720 dispatch[DictType] = dump_struct
721
722 if datetime:
724 write("<value><dateTime.iso8601>")
725 write(value.strftime("%Y%m%dT%H:%M:%S"))
726 write("</dateTime.iso8601></value>\n")
727 dispatch[datetime.datetime] = dump_datetime
728
730 write("<value><dateTime.iso8601>")
731 write(value.strftime("%Y%m%dT00:00:00"))
732 write("</dateTime.iso8601></value>\n")
733 dispatch[datetime.date] = dump_date
734
740 dispatch[datetime.time] = dump_time
741
743
744 if value.__class__ in WRAPPERS:
745 self.write = write
746 value.encode(self)
747 del self.write
748 else:
749
750 self.dump_struct(value.__dict__, write)
751 dispatch[InstanceType] = dump_instance
752
753
754
755
756
757
759 """Unmarshal an XML-RPC response, based on incoming XML event
760 messages (start, data, end). Call close() to get the resulting
761 data structure.
762
763 Note that this reader is fairly tolerant, and gladly accepts bogus
764 XML-RPC data without complaining (but not bogus XML).
765 """
766
767
768
769
771 self._type = None
772 self._stack = []
773 self._marks = []
774 self._data = []
775 self._methodname = None
776 self._encoding = "utf-8"
777 self.append = self._stack.append
778 self._use_datetime = use_datetime
779 if use_datetime and not datetime:
780 raise ValueError, "the datetime module is not available"
781
783
784 if self._type is None or self._marks:
785 raise ResponseError()
786 if self._type == "fault":
787 raise Fault(**self._stack[0])
788 return tuple(self._stack)
789
791 return self._methodname
792
793
794
795
796 - def xml(self, encoding, standalone):
797 self._encoding = encoding
798
799
800 - def start(self, tag, attrs):
801
802 if tag == "array" or tag == "struct":
803 self._marks.append(len(self._stack))
804 self._data = []
805 self._value = (tag == "value")
806
807 - def data(self, text):
808 self._data.append(text)
809
810 - def end(self, tag, join=string.join):
811
812 try:
813 f = self.dispatch[tag]
814 except KeyError:
815 pass
816 else:
817 return f(self, join(self._data, ""))
818
819
820
821
823
824 try:
825 f = self.dispatch[tag]
826 except KeyError:
827 pass
828 else:
829 return f(self, data)
830
831
832
833
834 dispatch = {}
835
837 self.append(None)
838 self._value = 0
839 dispatch["nil"] = end_nil
840
842 if data == "0":
843 self.append(False)
844 elif data == "1":
845 self.append(True)
846 else:
847 raise TypeError, "bad boolean value"
848 self._value = 0
849 dispatch["boolean"] = end_boolean
850
852 self.append(int(data))
853 self._value = 0
854 dispatch["i4"] = end_int
855 dispatch["int"] = end_int
856
858 self.append(float(data))
859 self._value = 0
860 dispatch["double"] = end_double
861
863 if self._encoding:
864 data = _decode(data, self._encoding)
865 self.append(_stringify(data))
866 self._value = 0
867 dispatch["string"] = end_string
868 dispatch["name"] = end_string
869
871 mark = self._marks.pop()
872
873 self._stack[mark:] = [self._stack[mark:]]
874 self._value = 0
875 dispatch["array"] = end_array
876
878 mark = self._marks.pop()
879
880 dict = {}
881 items = self._stack[mark:]
882 for i in range(0, len(items), 2):
883 dict[_stringify(items[i])] = items[i+1]
884 self._stack[mark:] = [dict]
885 self._value = 0
886 dispatch["struct"] = end_struct
887
889 value = Binary()
890 value.decode(data)
891 self.append(value)
892 self._value = 0
893 dispatch["base64"] = end_base64
894
896 value = DateTime()
897 value.decode(data)
898 if self._use_datetime:
899 value = _datetime_type(data)
900 self.append(value)
901 dispatch["dateTime.iso8601"] = end_dateTime
902
904
905
906 if self._value:
907 self.end_string(data)
908 dispatch["value"] = end_value
909
911 self._type = "params"
912 dispatch["params"] = end_params
913
916 dispatch["fault"] = end_fault
917
919 if self._encoding:
920 data = _decode(data, self._encoding)
921 self._methodname = data
922 self._type = "methodName"
923 dispatch["methodName"] = end_methodName
924
925
926
927
929
930
932 self.__call_list = call_list
933 self.__name = name
937 self.__call_list.append((self.__name, args))
938
940 """Iterates over the results of a multicall. Exceptions are
941 thrown in response to xmlrpc faults."""
942
944 self.results = results
945
947 item = self.results[i]
948 if type(item) == type({}):
949 raise Fault(item['faultCode'], item['faultString'])
950 elif type(item) == type([]):
951 return item[0]
952 else:
953 raise ValueError,\
954 "unexpected type in multicall result"
955
957 """server -> a object used to boxcar method calls
958
959 server should be a ServerProxy object.
960
961 Methods can be added to the MultiCall using normal
962 method call syntax e.g.:
963
964 multicall = MultiCall(server_proxy)
965 multicall.add(2,3)
966 multicall.get_address("Guido")
967
968 To execute the multicall, call the MultiCall object e.g.:
969
970 add_result, address = multicall()
971 """
972
974 self.__server = server
975 self.__call_list = []
976
978 return "<MultiCall at %x>" % id(self)
979
980 __str__ = __repr__
981
984
986 marshalled_list = []
987 for name, args in self.__call_list:
988 marshalled_list.append({'methodName' : name, 'params' : args})
989
990 return MultiCallIterator(self.__server.system.multicall(marshalled_list))
991
992
993
994
995
996
997
998
999
1000
1002 """getparser() -> parser, unmarshaller
1003
1004 Create an instance of the fastest available parser, and attach it
1005 to an unmarshalling object. Return both objects.
1006 """
1007 if use_datetime and not datetime:
1008 raise ValueError, "the datetime module is not available"
1009 if FastParser and FastUnmarshaller:
1010 if use_datetime:
1011 mkdatetime = _datetime_type
1012 else:
1013 mkdatetime = _datetime
1014 target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
1015 parser = FastParser(target)
1016 else:
1017 target = Unmarshaller(use_datetime=use_datetime)
1018 if FastParser:
1019 parser = FastParser(target)
1020 elif SgmlopParser:
1021 parser = SgmlopParser(target)
1022 elif ExpatParser:
1023 parser = ExpatParser(target)
1024 else:
1025 parser = SlowParser(target)
1026 return parser, target
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041 -def dumps(params, methodname=None, methodresponse=None, encoding=None,
1042 allow_none=0):
1043 """data [,options] -> marshalled data
1044
1045 Convert an argument tuple or a Fault instance to an XML-RPC
1046 request (or response, if the methodresponse option is used).
1047
1048 In addition to the data object, the following options can be given
1049 as keyword arguments:
1050
1051 methodname: the method name for a methodCall packet
1052
1053 methodresponse: true to create a methodResponse packet.
1054 If this option is used with a tuple, the tuple must be
1055 a singleton (i.e. it can contain only one element).
1056
1057 encoding: the packet encoding (default is UTF-8)
1058
1059 All 8-bit strings in the data structure are assumed to use the
1060 packet encoding. Unicode strings are automatically converted,
1061 where necessary.
1062 """
1063
1064 assert isinstance(params, TupleType) or isinstance(params, Fault),\
1065 "argument must be tuple or Fault instance"
1066
1067 if isinstance(params, Fault):
1068 methodresponse = 1
1069 elif methodresponse and isinstance(params, TupleType):
1070 assert len(params) == 1, "response tuple must be a singleton"
1071
1072 if not encoding:
1073 encoding = "utf-8"
1074
1075 if FastMarshaller:
1076 m = FastMarshaller(encoding)
1077 else:
1078 m = Marshaller(encoding, allow_none)
1079
1080 data = m.dumps(params)
1081
1082 if encoding != "utf-8":
1083 xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
1084 else:
1085 xmlheader = "<?xml version='1.0'?>\n"
1086
1087
1088 if methodname:
1089
1090 if not isinstance(methodname, StringType):
1091 methodname = methodname.encode(encoding)
1092 data = (
1093 xmlheader,
1094 "<methodCall>\n"
1095 "<methodName>", methodname, "</methodName>\n",
1096 data,
1097 "</methodCall>\n"
1098 )
1099 elif methodresponse:
1100
1101 data = (
1102 xmlheader,
1103 "<methodResponse>\n",
1104 data,
1105 "</methodResponse>\n"
1106 )
1107 else:
1108 return data
1109 return string.join(data, "")
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120 -def loads(data, use_datetime=0):
1121 """data -> unmarshalled data, method name
1122
1123 Convert an XML-RPC packet to unmarshalled data plus a method
1124 name (None if not present).
1125
1126 If the XML-RPC packet represents a fault condition, this function
1127 raises a Fault exception.
1128 """
1129 p, u = getparser(use_datetime=use_datetime)
1130 p.feed(data)
1131 p.close()
1132 return u.close(), u.getmethodname()
1133
1134
1135
1136
1137
1139
1140
1142 self.__send = send
1143 self.__name = name
1145 return _Method(self.__send, "%s.%s" % (self.__name, name))
1147 return self.__send(self.__name, args)
1148
1149
1150
1151
1152
1153
1154
1156 """Handles an HTTP transaction to an XML-RPC server."""
1157
1158
1159 user_agent = "xmlrpclib.py/%s (by www.pythonware.com)" % __version__
1160
1162 self._use_datetime = use_datetime
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173 - def request(self, host, handler, request_body, verbose=0):
1174
1175
1176 h = self.make_connection(host)
1177 if verbose:
1178 h.set_debuglevel(1)
1179
1180 self.send_request(h, handler, request_body)
1181 self.send_host(h, host)
1182 self.send_user_agent(h)
1183 self.send_content(h, request_body)
1184
1185 errcode, errmsg, headers = h.getreply()
1186
1187 if errcode != 200:
1188 raise ProtocolError(
1189 host + handler,
1190 errcode, errmsg,
1191 headers
1192 )
1193
1194 self.verbose = verbose
1195
1196 try:
1197 sock = h._conn.sock
1198 except AttributeError:
1199 sock = None
1200
1201 return self._parse_response(h.getfile(), sock)
1202
1203
1204
1205
1206
1207
1209
1210 return getparser(use_datetime=self._use_datetime)
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1223
1224 x509 = {}
1225 if isinstance(host, TupleType):
1226 host, x509 = host
1227
1228 import urllib
1229 auth, host = urllib.splituser(host)
1230
1231 if auth:
1232 import base64
1233 auth = base64.encodestring(urllib.unquote(auth))
1234 auth = string.join(string.split(auth), "")
1235 extra_headers = [
1236 ("Authorization", "Basic " + auth)
1237 ]
1238 else:
1239 extra_headers = None
1240
1241 return host, extra_headers, x509
1242
1243
1244
1245
1246
1247
1248
1250
1251 import httplib
1252 host, extra_headers, x509 = self.get_host_info(host)
1253 return httplib.HTTP(host)
1254
1255
1256
1257
1258
1259
1260
1261
1262 - def send_request(self, connection, handler, request_body):
1263 connection.putrequest("POST", handler)
1264
1265
1266
1267
1268
1269
1270
1272 host, extra_headers, x509 = self.get_host_info(host)
1273 connection.putheader("Host", host)
1274 if extra_headers:
1275 if isinstance(extra_headers, DictType):
1276 extra_headers = extra_headers.items()
1277 for key, value in extra_headers:
1278 connection.putheader(key, value)
1279
1280
1281
1282
1283
1284
1286 connection.putheader("User-Agent", self.user_agent)
1287
1288
1289
1290
1291
1292
1293
1294 - def send_content(self, connection, request_body):
1295 connection.putheader("Content-Type", "text/xml")
1296 connection.putheader("Content-Length", str(len(request_body)))
1297 connection.endheaders()
1298 if request_body:
1299 connection.send(request_body)
1300
1301
1302
1303
1304
1305
1306
1308
1309 return self._parse_response(file, None)
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1322
1323
1324 p, u = self.getparser()
1325
1326 while 1:
1327 if sock:
1328 response = sock.recv(1024)
1329 else:
1330 response = file.read(1024)
1331 if not response:
1332 break
1333 if self.verbose:
1334 print "body:", repr(response)
1335 p.feed(response)
1336
1337 file.close()
1338 p.close()
1339
1340 return u.close()
1341
1342
1343
1344
1346 """Handles an HTTPS transaction to an XML-RPC server."""
1347
1348
1349
1351
1352
1353 import httplib
1354 host, extra_headers, x509 = self.get_host_info(host)
1355 try:
1356 HTTPS = httplib.HTTPS
1357 except AttributeError:
1358 raise NotImplementedError(
1359 "your version of httplib doesn't support HTTPS"
1360 )
1361 else:
1362 return HTTPS(host, None, **(x509 or {}))
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1382 """uri [,options] -> a logical connection to an XML-RPC server
1383
1384 uri is the connection point on the server, given as
1385 scheme://host/target.
1386
1387 The standard implementation always supports the "http" scheme. If
1388 SSL socket support is available (Python 2.0), it also supports
1389 "https".
1390
1391 If the target part and the slash preceding it are both omitted,
1392 "/RPC2" is assumed.
1393
1394 The following options can be given as keyword arguments:
1395
1396 transport: a transport factory
1397 encoding: the request encoding (default is UTF-8)
1398
1399 All 8-bit strings passed to the server proxy are assumed to use
1400 the given encoding.
1401 """
1402
1403 - def __init__(self, uri, transport=None, encoding=None, verbose=0,
1404 allow_none=0, use_datetime=0):
1405
1406
1407
1408 import urllib
1409 type, uri = urllib.splittype(uri)
1410 if type not in ("http", "https"):
1411 raise IOError, "unsupported XML-RPC protocol"
1412 self.__host, self.__handler = urllib.splithost(uri)
1413 if not self.__handler:
1414 self.__handler = "/RPC2"
1415
1416 if transport is None:
1417 if type == "https":
1418 transport = SafeTransport(use_datetime=use_datetime)
1419 else:
1420 transport = Transport(use_datetime=use_datetime)
1421 self.__transport = transport
1422
1423 self.__encoding = encoding
1424 self.__verbose = verbose
1425 self.__allow_none = allow_none
1426
1428
1429
1430 request = dumps(params, methodname, encoding=self.__encoding,
1431 allow_none=self.__allow_none)
1432
1433 response = self.__transport.request(
1434 self.__host,
1435 self.__handler,
1436 request,
1437 verbose=self.__verbose
1438 )
1439
1440 if len(response) == 1:
1441 response = response[0]
1442
1443 return response
1444
1446 return (
1447 "<ServerProxy for %s%s>" %
1448 (self.__host, self.__handler)
1449 )
1450
1451 __str__ = __repr__
1452
1454
1455 return _Method(self.__request, name)
1456
1457
1458
1459
1460
1461
1462 Server = ServerProxy
1463
1464
1465
1466
1467 if __name__ == "__main__":
1468
1469
1470
1471
1472 server = ServerProxy("http://time.xmlrpc.com/RPC2")
1473
1474 print server
1475
1476 try:
1477 print server.currentTime.getCurrentTime()
1478 except Error, v:
1479 print "ERROR", v
1480
1481 multi = MultiCall(server)
1482 multi.currentTime.getCurrentTime()
1483 multi.currentTime.getCurrentTime()
1484 try:
1485 for response in multi():
1486 print response
1487 except Error, v:
1488 print "ERROR", v
1489