def _connect(self):
context = hasattr(ssl, "_create_unverified_context") and \
ssl._create_unverified_context() or None
if context:
transport = xmlrpclib.SafeTransport(use_datetime=True,
context=context)
else:
transport = xmlrpclib.SafeTransport(use_datetime=True)
self._server = xmlrpclib.ServerProxy(self._url, transport=transport)
return True
def __init__(self,
probe,
uri,
transport=None,
encoding=None,
verbose=0,
allow_none=0,
use_datetime=0):
xmlrpclib.ServerProxy.__init__(self, uri, transport, encoding, verbose,
allow_none, use_datetime)
self._probe = probe
# establish a "logical" server connection
# get the url
import urllib
type, uri = urllib.splittype(uri)
if type not in ("http", "https"):
raise IOError("unsupported XML-RPC protocol")
self.__host, self.__handler = urllib.splithost(uri)
if not self.__handler:
self.__handler = "/RPC2"
if transport is None:
if type == "https":
transport = xmlrpclib.SafeTransport(use_datetime=use_datetime)
else:
transport = xmlrpclib.Transport(use_datetime=use_datetime)
self.__transport = transport
self.__encoding = encoding
self.__verbose = verbose
self.__allow_none = allow_none
def login(self, switchToMaster=False):
try:
self._url = self._protocol + self._host + ':' + self._port
# On python 2.7.9, HTTPS is verified by default,
if self._useSSL and self._verifySSL is False:
context = ssl.SSLContext(
ssl.PROTOCOL_SSLv23) # @UndefinedVariable
context.verify_mode = ssl.CERT_NONE
transport = xmlrpclib.SafeTransport(context=context)
else:
transport = None
self._session = XenAPI.Session(self._url, transport=transport)
self._session.xenapi.login_with_password(self._username,
self._password)
self._loggedIn = True
self._apiVersion = self._session.API_version
self._poolName = unicode(self.getPoolName())
except XenAPI.Failure as e: # XenAPI.Failure: ['HOST_IS_SLAVE', '172.27.0.29'] indicates that this host is an slave of 172.27.0.29, connect to it...
if switchToMaster and e.details[0] == 'HOST_IS_SLAVE':
logger.info(
'{0} is an Slave, connecting to master at {1} cause switchToMaster is True'
.format(self._host, e.details[1]))
self._host = e.details[1]
self.login()
else:
raise XenFailure(e.details)
def __init__(self,
uri,
transport=None,
encoding=None,
verbose=0,
allow_none=0,
use_datetime=0,
timeout=default_timeout,
raise_errors=True):
self._pending = []
# establish a "logical" server connection
# get the url
import urllib
type, uri = urllib.splittype(uri)
if type not in ("http", "https"):
raise IOError, "unsupported XML-RPC protocol"
self.__host, self.__handler = urllib.splithost(uri)
if not self.__handler:
self.__handler = "/RPC2"
if transport is None:
if type == "https":
transport = xmlrpclib.SafeTransport(use_datetime=use_datetime)
else:
transport = TimeoutTransport(timeout=timeout,
use_datetime=use_datetime)
self.__transport = transport
self.__encoding = encoding
self.__verbose = verbose
self.__allow_none = allow_none
self._timeouts = 0
self._errors = []
self.raise_errors = raise_errors
def setup_connection(self):
# on *NIX, the proxy can show up either upper or lowercase.
# Prefer lower case, and prefer HTTPS over HTTP if the
# NEOS.scheme is https.
proxy = os.environ.get('http_proxy', os.environ.get('HTTP_PROXY', ''))
if NEOS.scheme == 'https':
proxy = os.environ.get('https_proxy',
os.environ.get('HTTPS_PROXY', proxy))
if proxy:
self.transport = ProxiedTransport()
self.transport.set_proxy(proxy)
elif NEOS.scheme == 'https':
self.transport = xmlrpclib.SafeTransport()
else:
self.transport = xmlrpclib.Transport()
self.neos = xmlrpclib.ServerProxy("%s://%s:%s" %
(NEOS.scheme, NEOS.host, NEOS.port),
transport=self.transport)
logger.info("Connecting to the NEOS server ... ")
try:
result = self.neos.ping()
logger.info("OK.")
except (socket.error, xmlrpclib.ProtocolError,
six.moves.http_client.BadStatusLine):
e = sys.exc_info()[1]
self.neos = None
logger.info("Fail.")
logger.warning("NEOS is temporarily unavailable.\n")
def _xml_rpc_auth(self):
"""
Authenticates with the server using XML-RPC and returns the cookie's
name and ID.
"""
# TODO: This method should be replaced with SafeCookieTransfer class!!!
import re
import ssl
import tempfile
import xmlrpclib
try:
ssl_context = ssl.create_default_context(cafile=self.ca_cert)
transport = xmlrpclib.SafeTransport(context=ssl_context)
except TypeError:
# py < 2.7.9
transport = xmlrpclib.SafeTransport()
hub = xmlrpclib.ServerProxy(
urljoin(self.base_url, 'client'),
allow_none=True,
transport=transport,
verbose=True)
stdout = sys.stdout
tmp_file = tempfile.TemporaryFile()
try:
sys.stdout = tmp_file
hub.auth.login_password(self.auth.username, self.auth.password)
tmp_file.seek(0)
stdout_content = tmp_file.read()
except xmlrpclib.Fault:
raise RuntimeError('Failed to authenticate with the server')
finally:
sys.stdout = stdout
tmp_file.close()
pattern = re.compile('beaker_auth_token=[\w.-]*')
results = pattern.findall(stdout_content)
if not results:
raise RuntimeError("Cookie not found")
return {'beaker_auth_token': results[0].split('=')[1]}
def connect(url):
try:
if 'https' in url:
context = hasattr(ssl, '_create_unverified_context') and ssl._create_unverified_context() or None
connection = xmlrpclib.ServerProxy(url, transport=xmlrpclib.SafeTransport(use_datetime=True, context=context))
else:
connection = xmlrpclib.ServerProxy(url)
return connection
except (xmlrpclib.ProtocolError, xmlrpclib.Fault, IOError) as e:
print "Unable to connect to %s" % url
sys.exit(1)
def connect(url):
try:
print "Connecting to Server..."
if 'https' in url:
context = hasattr(ssl, '_create_unverified_context') and ssl._create_unverified_context() or None
connection = xmlrpclib.ServerProxy(url, transport=xmlrpclib.SafeTransport(use_datetime=True, context=context))
else:
connection = xmlrpclib.ServerProxy(url)
connection.system.listMethods()
print "Connection Successful!"
print "connect-to-server : pass"
return connection
except (xmlrpclib.ProtocolError, xmlrpclib.Fault, IOError) as e:
print "CONNECTION ERROR!"
print "Unable to connect to %s" % url
print e
print "connect-to-server : fail"
exit(1)
def __init__(self,
uri,
transport=None,
encoding=None,
verbose=0,
allow_none=0,
use_datetime=0,
timeout=default_timeout,
raise_errors=True):
self._pending = []
# establish a "logical" server connection
# get the url
from six.moves.urllib.parse import urlparse
parsed_url = urlparse(uri)
scheme = parsed_url.scheme
self.__host = parsed_url.netloc
self.__handler = parsed_url.path
if scheme not in ("http", "https"):
raise IOError("unsupported XML-RPC protocol")
if not self.__handler:
self.__handler = "/RPC2"
if transport is None:
if scheme == "https":
transport = xmlrpclib.SafeTransport(use_datetime=use_datetime)
else:
transport = TimeoutTransport(timeout=timeout,
use_datetime=use_datetime)
self.__transport = transport
self.__encoding = encoding
self.__verbose = verbose
self.__allow_none = allow_none
self._timeouts = 0
self._errors = []
self.raise_errors = raise_errors
def refresh_available_addons(force=False, progress_callback=None):
pypi = xmlrpclib.ServerProxy('https://pypi.python.org/pypi',
transport=xmlrpclib.SafeTransport())
if progress_callback:
progress_callback(1, 0)
pkg_dict = {}
for data in pypi.search({'keywords': 'orange'}):
name = data['name']
order = data['_pypi_ordering']
if name not in pkg_dict or pkg_dict[name][0] < order:
pkg_dict[name] = (order, data['version'])
try:
import slumber
readthedocs = slumber.API(base_url='http://readthedocs.org/api/v1/')
except:
readthedocs = None
docs = {}
if progress_callback:
progress_callback(len(pkg_dict) + 1, 1)
with closing(open_addons(flag="c")) as addons:
for i, (name, (_, version)) in enumerate(pkg_dict.items()):
installed = addons[
name.lower()] if name.lower() in addons else None
if force or not installed or installed.available_version != version:
try:
data = pypi.release_data(name, version)
urls = pypi.release_urls(name, version)
release_urls = \
[ReleaseUrl(url["filename"], url["url"],
url["size"], url["python_version"],
url["packagetype"])
for url in urls]
if readthedocs:
try:
docs = readthedocs.project.get(
slug=name.lower())['objects'][0]
except:
docs = {}
addons[name.lower()] = OrangeAddOn(
name=name,
available_version=data['version'],
installed_version=installed.installed_version
if installed else None,
summary=data['summary'],
description=data.get('description', ''),
author=str((data.get('author', '') or '') + ' ' + (
data.get('author_email', '') or '')).strip(),
docs_url=data.get('docs_url',
docs.get('subdomain', '')),
keywords=data.get('keywords', "").split(","),
homepage=data.get('home_page', ''),
package_url=data.get('package_url', ''),
release_urls=release_urls)
except Exception:
import traceback
traceback.print_exc()
warnings.warn('Could not load data for the add-on: %s' %
name)
if progress_callback:
progress_callback(len(pkg_dict) + 1, i + 2)
rebuild_index()
