# Copyright (C) 2013 INRIA
#
# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation;
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
import os
import time
import threading
-import xmlrpclib
+
+from six import integer_types, string_types
+from six.moves import xmlrpc_client
def _retry(fn):
def rv(*p, **kw):
- for x in xrange(5):
+ for x in range(5):
try:
return fn(*p, **kw)
except (socket.error, IOError, OSError):
self._url = urlpattern % {'hostname':hostname}
if (proxy is not None):
- import urllib2
- class HTTPSProxyTransport(xmlrpclib.Transport):
+ from six.moves.urllib import request as urllib_request
+ class HTTPSProxyTransport(xmlrpc_client.Transport):
def __init__(self, proxy, use_datetime=0):
- opener = urllib2.build_opener(urllib2.ProxyHandler({"https" : proxy}))
- xmlrpclib.Transport.__init__(self, use_datetime)
+ opener = urllib_request.build_opener(urllib2.ProxyHandler({"https" : proxy}))
+ xmlrpc_client.Transport.__init__(self, use_datetime)
self.opener = opener
def request(self, host, handler, request_body, verbose=0):
- req = urllib2.Request('https://%s%s' % (host, handler), request_body)
+ req = urllib_request.Request('https://%s%s' % (host, handler), request_body)
req.add_header('User-agent', self.user_agent)
self.verbose = verbose
return self.parse_response(self.opener.open(req))
self.threadlocal = threading.local()
# Load blacklist from file
- if self._ecobj.get_global('PlanetlabNode', 'persist_blacklist'):
+ if self._ecobj.get_global('planetlab::Node', 'persist_blacklist'):
self._set_blacklist()
@property
def api(self):
# Cannot reuse same proxy in all threads, py2.7 is not threadsafe
- return xmlrpclib.ServerProxy(
+ return xmlrcp_client.ServerProxy(
self._url ,
transport = self._proxy_transport(),
allow_none = True)
try:
# test authorization
network_types = _retry(self.mcapi.GetNetworkTypes)(self.auth)
- except (xmlrpclib.ProtocolError, xmlrpclib.Fault),e:
+ except (xmlrpc_client.ProtocolError, xmlrpc_client.Fault) as e:
warnings.warn(str(e))
return True
* nodefamily : string, the nodefamily this node should be based upon
* plain : boolean, use plain bootstrapfs image if set (for tests)
"""
- if not isinstance(node, (str, int, long)):
- raise ValueError, "Node must be either a non-unicode string or an int"
+ if not isinstance(node, integer_types + string_types):
+ raise ValueError("Node must be either a non-unicode string or an int")
return _retry(self.mcapi.GetNodeFlavour)(self.auth, node)
def get_nodes(self, node_id_or_name = None, fields = None, **kw):
filters = filters, peer=None, **kw)
)
else:
- peer_filter = map(name_to_id, peer)
+ peer_filter = [name_to_id(x) for x in peer]
elif peer is None or peer == self._local_peer:
peer_filter = None
return _retry(self.mcapi.DeleteSliceFromNodes)(self.auth, slice_id_or_name, node_id_or_hostname)
def start_multicall(self):
- self.threadlocal.mc = xmlrpclib.MultiCall(self.mcapi)
+ self.threadlocal.mc = xmlrpc_client.MultiCall(self.mcapi)
def finish_multicall(self):
mc = self.threadlocal.mc
def release(self):
self.count -= 1
- if self._ecobj.get_global('PlanetlabNode', 'persist_blacklist') and self.count == 0:
- if self._blacklist:
- to_blacklist = list()
- hostnames = self.get_nodes(list(self._blacklist), ['hostname'])
- for hostname in hostnames:
- to_blacklist.append(hostname['hostname'])
-
- nepi_home = os.path.join(os.path.expanduser("~"), ".nepi")
- plblacklist_file = os.path.join(nepi_home, "plblacklist.txt")
-
- with open(plblacklist_file, 'w') as f:
- for host in to_blacklist:
- f.write("%s\n" % host)
+ if self.count == 0:
+ blacklist = self._blacklist
+ self._blacklist = set()
+ self._reserved = set()
+ if self._ecobj.get_global('PlanetlabNode', 'persist_blacklist'):
+ if blacklist:
+ to_blacklist = list()
+ hostnames = self.get_nodes(list(blacklist), ['hostname'])
+ for hostname in hostnames:
+ to_blacklist.append(hostname['hostname'])
+
+ nepi_home = os.path.join(os.path.expanduser("~"), ".nepi")
+ plblacklist_file = os.path.join(nepi_home, "plblacklist.txt")
+
+ with open(plblacklist_file, 'w') as f:
+ for host in to_blacklist:
+ f.write("%s\n" % host)
+
class PLCAPIFactory(object):
"""