# Lucia Guevgeozian <lucia.guevgeozian_odizzio@inria.fr>
from nepi.execution.attribute import Attribute, Flags, Types
-from nepi.execution.resource import ResourceManager, clsinit_copy, ResourceState, \
- reschedule_delay
+from nepi.execution.resource import ResourceManager, clsinit_copy, \
+ ResourceState, reschedule_delay
from nepi.resources.linux.node import LinuxNode
from nepi.resources.planetlab.plcapi import PLCAPIFactory
from nepi.util.execfuncs import lexec
+from nepi.util import sshfuncs
from random import randint
import time
import threading
+import datetime
@clsinit_copy
class PlanetlabNode(LinuxNode):
cls._register_attribute(min_cpu)
cls._register_attribute(max_cpu)
cls._register_attribute(timeframe)
-
def __init__(self, ec, guid):
super(PlanetlabNode, self).__init__(ec, guid)
self._plapi = None
self._node_to_provision = None
+ self._slicenode = False
@property
def plapi(self):
self._plapi = PLCAPIFactory.get_api(pl_user, pl_pass, pl_url,
pl_ptn)
+ if not self._plapi:
+ self.fail_plapi()
+
return self._plapi
- def discover(self):
+ def do_discover(self):
"""
- Based on the attributes defined by the user, discover the suitable nodes
+ Based on the attributes defined by the user, discover the suitable
+ nodes for provision.
"""
- hostname = self.get("hostname")
+ hostname = self._get_hostname()
if hostname:
# the user specified one particular node to be provisioned
# check with PLCAPI if it is alvive
self._blacklist_node(node_id)
self.fail_node_not_alive(hostname)
else:
+ if self._check_if_in_slice([node_id]):
+ self._slicenode = True
self._put_node_in_provision(node_id)
self._node_to_provision = node_id
- super(PlanetlabNode, self).discover()
+ super(PlanetlabNode, self).do_discover()
else:
self.fail_node_not_available(hostname)
node_id = None
if nodes_inslice:
node_id = self._choose_random_node(nodes_inslice)
+ self._slicenode = True
if not node_id:
# Either there were no matching nodes in the user's slice, or
# the nodes in the slice were blacklisted or being provisioned
# by other RM. Note nodes_not_inslice is never empty
node_id = self._choose_random_node(nodes_not_inslice)
+ self._slicenode = False
if node_id:
self._node_to_provision = node_id
- super(PlanetlabNode, self).discover()
+ try:
+ self._set_hostname_attr(node_id)
+ self.info(" Selected node to provision ")
+ except:
+ with PlanetlabNode.lock:
+ self._blacklist_node(node_id)
+ self.do_discover()
+
+ super(PlanetlabNode, self).do_discover()
else:
self.fail_not_enough_nodes()
- def provision(self):
+ def do_provision(self):
"""
Add node to user's slice after verifing that the node is functioning
correctly
provision_ok = False
ssh_ok = False
proc_ok = False
- timeout = 1200
+ timeout = 1800
while not provision_ok:
node = self._node_to_provision
- # Adding try catch to set hostname because sometimes MyPLC fails
- # when trying to retrive node's hostname
- try:
- self._set_hostname_attr(node)
- except:
- self.discover()
- self._add_node_to_slice(node)
+ if not self._slicenode:
+ self._add_node_to_slice(node)
- # check ssh connection
- t = 0
- while t < timeout and not ssh_ok:
-
+ # check ssh connection
+ t = 0
+ while t < timeout and not ssh_ok:
+
+ cmd = 'echo \'GOOD NODE\''
+ ((out, err), proc) = self.execute(cmd)
+ if out.find("GOOD NODE") < 0:
+ t = t + 60
+ time.sleep(60)
+ continue
+ else:
+ ssh_ok = True
+ continue
+ else:
cmd = 'echo \'GOOD NODE\''
((out, err), proc) = self.execute(cmd)
- if out.find("GOOD NODE") < 0:
- t = t + 60
- time.sleep(60)
- continue
- else:
+ if not out.find("GOOD NODE") < 0:
ssh_ok = True
- continue
if not ssh_ok:
# the timeout was reach without establishing ssh connection
# the node is blacklisted, deleted from the slice, and a new
# node to provision is discovered
with PlanetlabNode.lock:
+ self.warn(" Could not SSH login ")
self._blacklist_node(node)
- self._delete_node_from_slice(node)
- self.discover()
+ #self._delete_node_from_slice(node)
+ self.set('hostname', None)
+ self.do_discover()
continue
# check /proc directory is mounted (ssh_ok = True)
((out, err), proc) = self.execute(cmd)
if out.find("/proc type proc") < 0:
with PlanetlabNode.lock:
+ self.warn(" Could not find directory /proc ")
self._blacklist_node(node)
- self._delete_node_from_slice(node)
- self.discover()
+ #self._delete_node_from_slice(node)
+ self.set('hostname', None)
+ self.do_discover()
continue
else:
ip = self._get_ip(node)
self.set("ip", ip)
- super(PlanetlabNode, self).provision()
+ super(PlanetlabNode, self).do_provision()
def _filter_based_on_attributes(self):
"""
nodes = self.plapi.get_nodes()
for node in nodes:
nodes_id.append(node['node_id'])
-
+
return nodes_id
filters['run_level'] = 'boot'
filters['boot_state'] = 'boot'
filters['node_type'] = 'regular'
- filters['>last_contact'] = int(time.time()) - 2*3600
+ #filters['>last_contact'] = int(time.time()) - 2*3600
# adding node_id or hostname to the filters to check for the particular
# node
alive_nodes_id = self._get_nodes_id(filters)
if len(alive_nodes_id) == 0:
- self.fail_discovery()
+ self.fail_node_not_alive(self, hostname)
else:
nodes_id = list()
for node_id in alive_nodes_id:
if node_id not in blist and node_id not in plist:
ping_ok = self._do_ping(node_id)
if not ping_ok:
+ self._set_hostname_attr(node_id)
+ self.warn(" Node not responding PING ")
self._blacklist_node(node_id)
+ self.set('hostname', None)
else:
# discovered node for provision, added to provision list
self._put_node_in_provision(node_id)
return self.plapi.get_nodes(filters, fields=['node_id'])
def _add_node_to_slice(self, node_id):
- self.info(" Selecting node ... ")
+ self.info(" Adding node to slice ")
slicename = self.get("username")
with PlanetlabNode.lock:
slice_nodes = self.plapi.get_slice_nodes(slicename)
slicename = self.get("username")
self.plapi.delete_slice_node(slicename, [node])
+ def _get_hostname(self):
+ hostname = self.get("hostname")
+ ip = self.get("ip")
+ if hostname:
+ return hostname
+ elif ip:
+ hostname = sshfuncs.gethostbyname(ip)
+ return hostname
+ else:
+ return None
+
def _set_hostname_attr(self, node):
"""
Query PLCAPI for the hostname of a certain node id and sets the
"""
ping_ok = False
ip = self._get_ip(node_id)
- command = "ping -c2 %s | echo \"PING OK\"" % ip
+ if not ip: return ping_ok
+
+ command = "ping -c2 %s" % ip
(out, err) = lexec(command)
- if not out.find("PING OK") < 0:
+ if not out.find("2 received") < 0:
ping_ok = True
-
+
return ping_ok
def _blacklist_node(self, node):
"""
Query PLCAPI for the IP of a node with certain node id
"""
- ip = self.plapi.get_interfaces({'node_id':node_id}, fields=['ip'])
- ip = ip[0]['ip']
+ hostname = self.plapi.get_nodes(node_id, ['hostname'])[0]
+ try:
+ ip = sshfuncs.gethostbyname(hostname['hostname'])
+ except:
+ # Fail while trying to find the IP
+ return None
return ip
def fail_discovery(self):
- self.fail()
msg = "Discovery failed. No candidates found for node"
self.error(msg)
raise RuntimeError, msg
- def fail_node_not_alive(self, hostname):
- msg = "Node %s not alive, pick another node" % hostname
+ def fail_node_not_alive(self, hostname=None):
+ msg = "Node %s not alive" % hostname
raise RuntimeError, msg
def fail_node_not_available(self, hostname):
- msg = "Node %s not available for provisioning, pick another \
- node" % hostname
+ msg = "Node %s not available for provisioning" % hostname
raise RuntimeError, msg
def fail_not_enough_nodes(self):
msg = "Not enough nodes available for provisioning"
raise RuntimeError, msg
+ def fail_plapi(self):
+ msg = "Failing while trying to instanciate the PLC API"
+ raise RuntimeError, msg
+
def valid_connection(self, guid):
# TODO: Validate!
return True
git://git.onelab.eu / nepi.git / blobdiff