try: turn_off_server_verify = { 'context' : ssl._create_unverified_context() }
except: turn_off_server_verify = {}
-import xmlrpclib
import getpass
+from sfa.util.py23 import xmlrpc_client
+
class ManifoldUploader:
"""A utility class for uploading delegated credentials to a manifold/MySlice infrastructure"""
# if not self._proxy:
# url=self.url()
# self.logger.info("Connecting manifold url %s"%url)
-# self._proxy = xmlrpclib.ServerProxy(url, allow_none = True)
+# self._proxy = xmlrpc_client.ServerProxy(url, allow_none = True)
# return self._proxy
url=self.url()
self.logger.debug("Connecting manifold url %s"%url)
- proxy = xmlrpclib.ServerProxy(url, allow_none = True,
- **turn_off_server_verify)
+ proxy = xmlrpc_client.ServerProxy(url, allow_none = True,
+ **turn_off_server_verify)
return proxy
try: turn_off_server_verify = { 'context' : ssl._create_unverified_context() }
except: turn_off_server_verify = {}
-import xmlrpclib
from httplib import HTTPS, HTTPSConnection
+from sfa.util.py23 import xmlrpc_client
+
try:
from sfa.util.sfalogging import logger
except:
class ServerException(Exception):
pass
-class ExceptionUnmarshaller(xmlrpclib.Unmarshaller):
+class ExceptionUnmarshaller(xmlrpc_client.Unmarshaller):
def close(self):
try:
- return xmlrpclib.Unmarshaller.close(self)
- except xmlrpclib.Fault as e:
+ return xmlrpc_client.Unmarshaller.close(self)
+ except xmlrpc_client.Fault as e:
raise ServerException(e.faultString)
##
# targetting only python-2.7 we can get rid of some older code
-class XMLRPCTransport(xmlrpclib.Transport):
+class XMLRPCTransport(xmlrpc_client.Transport):
def __init__(self, key_file = None, cert_file = None, timeout = None):
- xmlrpclib.Transport.__init__(self)
+ xmlrpc_client.Transport.__init__(self)
self.timeout=timeout
self.key_file = key_file
self.cert_file = cert_file
def getparser(self):
unmarshaller = ExceptionUnmarshaller()
- parser = xmlrpclib.ExpatParser(unmarshaller)
+ parser = xmlrpc_client.ExpatParser(unmarshaller)
return parser, unmarshaller
-class XMLRPCServerProxy(xmlrpclib.ServerProxy):
+class XMLRPCServerProxy(xmlrpc_client.ServerProxy):
def __init__(self, url, transport, allow_none=True, verbose=False):
# remember url for GetVersion
# xxx not sure this is still needed as SfaServerProxy has this too
- self.url=url
- xmlrpclib.ServerProxy.__init__(self, url, transport, allow_none=allow_none,
- verbose=verbose,
+ self.url = url
+ xmlrpc_client.ServerProxy.__init__(self, url, transport, allow_none=allow_none,
+ verbose=verbose,
**turn_off_server_verify)
def __getattr__(self, attr):
logger.debug ("xml-rpc %s method:%s" % (self.url, attr))
- return xmlrpclib.ServerProxy.__getattr__(self, attr)
+ return xmlrpc_client.ServerProxy.__getattr__(self, attr)
########## the object on which we can send methods that get sent over xmlrpc
class SfaServerProxy:
self.certfile = certfile
self.verbose = verbose
self.timeout = timeout
- # an instance of xmlrpclib.ServerProxy
+ # an instance of xmlrpc_client.ServerProxy
transport = XMLRPCTransport(keyfile, certfile, timeout)
self.serverproxy = XMLRPCServerProxy(url, transport, allow_none=True, verbose=verbose)
from __future__ import print_function
-import xmlrpclib
from datetime import datetime
import time
+from sfa.util.py23 import xmlrpc_client
dummy_url = "http://localhost:8080"
-dummy_api = xmlrpclib.ServerProxy(dummy_url)
+dummy_api = xmlrpc_client.ServerProxy(dummy_url)
# Add a user:
my_user_id = dummy_api.AddUser({'email': 'john.doe@test.net', 'user_name': 'john.doe', 'keys': ['copy here your ssh-rsa public key']})
import sys
-import xmlrpclib
import socket
from urlparse import urlparse
from sfa.util.sfalogging import logger
+from sfa.util.py23 import xmlrpc_client
class DummyShell:
"""
def __init__ ( self, config ) :
url = config.SFA_DUMMY_URL
- self.proxy = xmlrpclib.Server(url, verbose = False, allow_none = True)
+ self.proxy = xmlrpc_client.ServerProxy(url, verbose = False, allow_none = True)
def __getattr__(self, name):
def func(*args, **kwds):
-import xmlrpclib
-
from sfa.util.sfalogging import logger
+from sfa.util.py23 import xmlrpc_client
class FdShell:
"""
def __init__ ( self, config ) :
url=config.SFA_FEDERICA_URL
# xxx not sure if java xmlrpc has support for None
- # self.proxy = xmlrpclib.Server(url, verbose = False, allow_none = True)
+ # self.proxy = xmlrpc_client.ServerProxy(url, verbose = False, allow_none = True)
# xxx turn on verbosity
- self.proxy = xmlrpclib.Server(url, verbose = True)
+ self.proxy = xmlrpc_client.ServerProxy(url, verbose = True)
# xxx get credentials from the config ?
# right now basic auth data goes into the URL
-import xmlrpclib
-
from sfa.util.faults import SliverDoesNotExist
from sfa.util.version import version_core
+from sfa.util.py23 import xmlrpc_client
from sfa.trust.sfaticket import SfaTicket
raise SliverDoesNotExist(slicename)
# convert ticket to format nm is used to
- nm_ticket = xmlrpclib.dumps((ticket.attributes,), methodresponse=True)
+ nm_ticket = xmlrpc_client.dumps((ticket.attributes,), methodresponse=True)
api.driver.nodemanager.AdminTicket(nm_ticket)
import sys
-import xmlrpclib
import socket
from urlparse import urlparse
from sfa.util.sfalogging import logger
+from sfa.util.py23 import xmlrpc_client
class NitosShell:
"""
# use the 'capability' auth mechanism for higher performance when the PLC db is local
def __init__ ( self, config ) :
url = config.SFA_NITOS_URL
- self.proxy = xmlrpclib.Server(url, verbose = False, allow_none = True)
+ self.proxy = xmlrpc_client.ServerProxy(url, verbose = False, allow_none = True)
def __getattr__(self, name):
def func(*args, **kwds):
import sys
-import xmlrpclib
import socket
import gettext
from urlparse import urlparse
(fd, filename) = tempfile.mkstemp(dir=path)
scriptname = script_path + os.sep + filename.split(os.sep)[-1:][0]
# define the script to execute
+ # when providing support for python3 wrt xmlrpclib
+ # looks safer to keep things as-is
script = """
#!%(python)s
import xmlrpclib
####################
class SfaApi (XmlrpcApi):
"""
- An SfaApi instance is a basic xmlrcp service
+ An SfaApi instance is a basic xmlrpc service
augmented with the local cryptographic material and hrn
It also has the notion of its own interface (a string describing
import traceback
import threading
from Queue import Queue
-import xmlrpclib
import SocketServer
import BaseHTTPServer
import SimpleXMLRPCServer
from sfa.util.cache import Cache
from sfa.trust.certificate import Certificate
from sfa.trust.trustedroots import TrustedRoots
+from sfa.util.py23 import xmlrpc_client
# don't hard code an api class anymore here
from sfa.generic import Generic
# can't use format_exc() as it is not available in jython yet
# (even in trunk).
type, value, tb = sys.exc_info()
- raise xmlrpclib.Fault(1,''.join(traceback.format_exception(type, value, tb)))
+ raise xmlrpc_client.Fault(1,''.join(traceback.format_exception(type, value, tb)))
# override this one from the python 2.7 code
# originally defined in class TCPServer
#
import string
-import xmlrpclib
# SOAP support is optional
try:
#from sfa.util.faults import SfaNotImplemented, SfaAPIError, SfaInvalidAPIMethod, SfaFault
from sfa.util.faults import SfaInvalidAPIMethod, SfaAPIError, SfaFault
from sfa.util.sfalogging import logger
+from sfa.util.py23 import xmlrpc_client
####################
# See "2.2 Characters" in the XML specification:
f(*args)
# You can't hide from me!
-xmlrpclib.Marshaller._Marshaller__dump = xmlrpclib_dump
+# Note: not quite sure if this will still cause
+# the expected behaviour under python3
+xmlrpc_client.Marshaller._Marshaller__dump = xmlrpclib_dump
class XmlrpcApi:
"""
"""
# Parse request into method name and arguments
try:
- interface = xmlrpclib
- self.protocol = 'xmlrpclib'
- (args, method) = xmlrpclib.loads(data)
+ interface = xmlrpc_client
+ self.protocol = 'xmlrpc'
+ (args, method) = xmlrpc_client.loads(data)
if method_map.has_key(method):
method = method_map[method]
methodresponse = True
convert result to a valid xmlrpc or soap response
"""
- if self.protocol == 'xmlrpclib':
+ if self.protocol == 'xmlrpc':
if not isinstance(result, SfaFault):
result = (result,)
- response = xmlrpclib.dumps(result, methodresponse = True, encoding = self.encoding, allow_none = 1)
+ response = xmlrpc_client.dumps(result, methodresponse = True, encoding = self.encoding, allow_none = 1)
elif self.protocol == 'soap':
if isinstance(result, Exception):
result = faultParameter(NS.ENV_T + ":Server", "Method Failed", method)
from __future__ import print_function
-import xmlrpclib
import uuid
from sfa.trust.certificate import Certificate
from sfa.util.faults import GidInvalidParentHrn, GidParentHrn
-from sfa.util.sfalogging import logger
from sfa.util.xrn import hrn_to_urn, urn_to_hrn, hrn_authfor_hrn
+from sfa.util.sfalogging import logger
+from sfa.util.py23 import xmlrpc_client
##
# Create a new uuid. Returns the UUID as a string.
dict = {}
if data:
if data.lower().startswith('uri:http://<params>'):
- dict = xmlrpclib.loads(data[11:])[0][0]
+ dict = xmlrpc_client.loads(data[11:])[0][0]
else:
spl = data.split(', ')
for val in spl:
from __future__ import print_function
-import xmlrpclib
-
from sfa.trust.certificate import Certificate
from sfa.trust.gid import GID
+from sfa.util.py23 import xmlrpc_client
+
# Ticket is tuple:
# (gidCaller, gidObject, attributes, rspec, delegate)
#
dict["gidCaller"] = self.gidCaller.save_to_string(save_parents=True)
if self.gidObject:
dict["gidObject"] = self.gidObject.save_to_string(save_parents=True)
- str = "URI:" + xmlrpclib.dumps((dict,), allow_none=True)
+ str = "URI:" + xmlrpc_client.dumps((dict,), allow_none=True)
self.set_data(str)
def decode(self):
data = self.get_data()
if data:
- dict = xmlrpclib.loads(self.get_data()[4:])[0][0]
+ dict = xmlrpc_client.loads(self.get_data()[4:])[0][0]
else:
dict = {}
import sys
import os
import time
-import ConfigParser
import tempfile
import codecs
from sfa.util.xml import XML
from sfa.util.py23 import StringIO
+from sfa.util.py23 import ConfigParser
default_config = \
"""
# SFA API faults
#
-try:
- from xmlrpc.client import Fault as xmlrpcFault
-except:
- from xmlrpclib import Fault as xmlrpcFault
-
from sfa.util.genicode import GENICODE
+from sfa.util.py23 import xmlrpc_client
-class SfaFault(xmlrpcFault):
+class SfaFault(xmlrpc_client.Fault):
def __init__(self, faultCode, faultString, extra = None):
if extra:
faultString += ": " + str(extra)
- xmlrpcFault.__init__(self, faultCode, faultString)
+ xmlrpc_client.Fault.__init__(self, faultCode, faultString)
class Forbidden(SfaFault):
def __init__(self, extra = None):
def __str__(self):
return repr(self.value)
-class BadRequestHash(xmlrpcFault):
+class BadRequestHash(xmlrpc_client.Fault):
def __init__(self, hash = None, extra = None):
faultString = "bad request hash: " + str(hash)
- xmlrpcFault.__init__(self, GENICODE.ERROR, faultString)
+ xmlrpc_client.Fault.__init__(self, GENICODE.ERROR, faultString)
class MissingTrustedRoots(SfaFault):
def __init__(self, value, extra = None):
+# our own simplistic replacement for six
try:
StringType = basestring
except:
from StringIO import StringIO
except:
from io import StringIO
+
+try:
+ import xmlrpclib as xmlrpc_client
+except:
+ from xmlrpc import client as xmlrpc_client
+
+try:
+ import ConfigParser
+except:
+ import configparser as ConfigParser
import unittest
-import xmlrpclib
from sfa.trust.certificate import Certificate, Keypair
+from sfa.util.py23 import xmlrpc_client
class TestCert(unittest.TestCase):
def setUp(self):
# try something a bit more complicated, like an xmlrpc encoding of
# some parameters
cert = Certificate(subject="test")
- data = xmlrpclib.dumps((1, "foo", ["a", "b"], {"c": "d", "e": "f"}, True))
+ data = xmlrpc_client.dumps((1, "foo", ["a", "b"], {"c": "d", "e": "f"}, True))
cert.set_data(data)
self.assertEqual(cert.get_data(), data)
import sys, pprint
import modulefinder
-focus=[ 'sfa' , 'OpenSSL', 'M2Crypto', 'xmlrpclib', 'threading' ]
+focus = [ 'sfa' , 'OpenSSL', 'M2Crypto', 'xmlrpclib', 'threading' ]
class mymf(modulefinder.ModuleFinder):
def __init__(self,*args,**kwargs):
git://git.onelab.eu / sfa.git / commitdiff