from sfa.client.sfi import Sfi
from sfa.util.sfalogging import logger, DEBUG
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
+import sfa.client.sfaprotocol as sfaprotocol
def url_hostname_port (url):
if url.find("://")<0:
url=self.url()
logger.info('issuing GetVersion at %s'%url)
# setting timeout here seems to get the call to fail - even though the response time is fast
- #server=xmlrpcprotocol.server_proxy(url, key_file, cert_file, verbose=self.verbose, timeout=options.timeout)
- server=xmlrpcprotocol.server_proxy(url, key_file, cert_file, verbose=self.verbose)
+ #server=sfaprotocol.server_proxy(url, key_file, cert_file, verbose=self.verbose, timeout=options.timeout)
+ server=sfaprotocol.server_proxy(url, key_file, cert_file, verbose=self.verbose)
self._version=server.GetVersion()
except:
logger.log_exc("failed to get version")
from sfa.rspecs.version_manager import VersionManager
from sfa.client.return_value import ReturnValue
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
+import sfa.client.sfaprotocol as sfaprotocol
from sfa.client.client_helper import pg_users_arg, sfa_users_arg
AGGREGATE_PORT=12346
# Get key and certificate
key_file = self.get_key_file()
cert_file = self.get_cert_file(key_file)
- self.key = Keypair(filename=key_file)
self.key_file = key_file
self.cert_file = cert_file
self.cert = GID(filename=cert_file)
self.logger.info("Contacting Registry at: %s"%self.reg_url)
- self.registry = xmlrpcprotocol.server_proxy(self.reg_url, key_file, cert_file, timeout=self.options.timeout, verbose=self.options.debug)
+ self.registry = sfaprotocol.server_proxy(self.reg_url, key_file, cert_file, timeout=self.options.timeout, verbose=self.options.debug)
self.logger.info("Contacting Slice Manager at: %s"%self.sm_url)
- self.slicemgr = xmlrpcprotocol.server_proxy(self.sm_url, key_file, cert_file, timeout=self.options.timeout, verbose=self.options.debug)
+ self.slicemgr = sfaprotocol.server_proxy(self.sm_url, key_file, cert_file, timeout=self.options.timeout, verbose=self.options.debug)
return
def get_cached_server_version(self, server):
self.logger.info("Getting Registry issued cert")
self.read_config()
# *hack. need to set registyr before _get_gid() is called
- self.registry = xmlrpcprotocol.server_proxy(self.reg_url, key_file, cert_file, timeout=self.options.timeout, verbose=self.options.debug)
+ self.registry = sfaprotocol.server_proxy(self.reg_url, key_file, cert_file, timeout=self.options.timeout, verbose=self.options.debug)
gid = self._get_gid(type='user')
self.registry = None
self.logger.info("Writing certificate to %s"%cert_file)
host_parts = host.split('/')
host_parts[0] = host_parts[0] + ":" + str(port)
url = "http://%s" % "/".join(host_parts)
- return xmlrpcprotocol.server_proxy(url, keyfile, certfile, timeout=self.options.timeout, verbose=self.options.debug)
+ return sfaprotocol.server_proxy(url, keyfile, certfile, timeout=self.options.timeout, verbose=self.options.debug)
# xxx opts could be retrieved in self.options
def server_proxy_from_opts(self, opts):
elif record['type'] in ["slice"]:
try:
cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
- except xmlrpcprotocol.ServerException, e:
+ except sfaprotocol.ServerException, e:
# XXX smbaker -- once we have better error return codes, update this
# to do something better than a string compare
if "Permission error" in e.args[0]:
import os
import tempfile
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
+import sfa.client.sfaprotocol as sfaprotocol
from sfa.plc.nodemanager import NodeManager
from sfa.trust.credential import Credential
addr, port = self.config.SFA_REGISTRY_HOST, self.config.SFA_REGISTRY_PORT
url = "http://%(addr)s:%(port)s" % locals()
### xxx this would require access to the api...
- server = xmlrpcprotocol.server_proxy(url, self.key_file, self.cert_file)
+ server = sfaprotocol.server_proxy(url, self.key_file, self.cert_file)
return server
def get_node_key(self):
#from sfa.util.faults import *
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
+import sfa.client.sfaprotocol as sfaprotocol
from sfa.util.xml import XML
# GeniLight client support is optional
# xxx url and self.api are undefined
server = GeniClientLight(url, self.api.key_file, self.api.cert_file)
else:
- server = xmlrpcprotocol.server_proxy(self.get_url(), key_file, cert_file, timeout)
+ server = sfaprotocol.server_proxy(self.get_url(), key_file, cert_file, timeout)
return server
##
from sfa.storage.table import SfaTable
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
+import sfa.client.sfaprotocol as sfaprotocol
from sfa.generic import Generic
# and a valid credential
authority = config.SFA_INTERFACE_HRN
url = 'http://%s:%s/' %(config.SFA_REGISTRY_HOST, config.SFA_REGISTRY_PORT)
- registry = xmlrpcprotocol.server_proxy(url, key_file, cert_file)
+ registry = sfaprotocol.server_proxy(url, key_file, cert_file)
sfa_api = Generic.the_flavour()
credential = sfa_api.getCredential()
from sfa.util.sfalogging import logger
from sfa.util.xrn import get_authority, hrn_to_urn
from sfa.util.config import Config
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
from sfa.trust.gid import GID
from sfa.trust.trustedroots import TrustedRoots
from sfa.trust.certificate import Keypair, Certificate
from sfa.util.faults import ConnectionKeyGIDMismatch
from sfa.util.config import Config
-import sfa.client.xmlrpcprotocol as xmlrpcprotocol
+import sfa.client.sfaprotocol as sfaprotocol
from sfa.util.plxrn import hrn_to_pl_slicename, slicename_to_hrn
from sfa.trust.certificate import Keypair, Certificate
if verbose:
print "Contacting registry at: %(url)s" % locals()
- server = xmlrpcprotocol.server_proxy(url, keyfile, certfile)
+ server = sfaprotocol.server_proxy(url, keyfile, certfile)
return server
import random
import string
import unittest
-import sfa.util.xmlrpcprotocol as xmlrpcprotocol
+import sfa.util.sfaprotocol as sfaprotocol
from unittest import TestCase
from optparse import OptionParser
from sfa.util.xrn import get_authority
self.cert.save_to_file(cert_file)
SFI_AGGREGATE = config.SFI_SM.replace('12347', '12346')
SFI_CM = 'http://' + options.cm_host + ':12346'
- self.registry = xmlrpcprotocol.server_proxy(config.SFI_REGISTRY, key_file, cert_file)
- self.aggregate = xmlrpcprotocol.server_proxy(SFI_AGGREGATE, key_file, cert_file)
- self.sm = xmlrpcprotocol.server_proxy(config.SFI_SM, key_file, cert_file)
- self.cm = xmlrpcprotocol.server_proxy(SFI_CM, key_file, cert_file)
+ self.registry = sfaprotocol.server_proxy(config.SFI_REGISTRY, key_file, cert_file)
+ self.aggregate = sfaprotocol.server_proxy(SFI_AGGREGATE, key_file, cert_file)
+ self.sm = sfaprotocol.server_proxy(config.SFI_SM, key_file, cert_file)
+ self.cm = sfaprotocol.server_proxy(SFI_CM, key_file, cert_file)
self.hrn = config.SFI_USER
# XX defaulting to user, but this should be configurable so we can
# test from components persepctive
server_exception = False
try:
callable(self.credential)
- except xmlrpcprotocol.ServerException:
+ except sfaprotocol.ServerException:
server_exception = True
finally:
if self.type in ['user'] and not server_exception: