src/nepi/resources/all/collector.py

   1 #
   2 #    NEPI, a framework to manage network experiments
   3 #    Copyright (C) 2013 INRIA
   4 #
   5 #    This program is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation, either version 3 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  19
  20 from nepi.execution.attribute import Attribute, Flags, Types
  21 from nepi.execution.trace import Trace, TraceAttr
  22 from nepi.execution.resource import ResourceManager, clsinit, ResourceState, \
  23         ResourceAction
  24 from nepi.util.sshfuncs import ProcStatus
  25
  26 import os
  27 import tempfile
  28
  29 @clsinit
  30 class Collector(ResourceManager):
  31     """ The collector is reponsible of collecting traces
  32     of a same type associated to RMs into a local directory.
  33
  34     .. class:: Class Args :
  35
  36         :param ec: The Experiment controller
  37         :type ec: ExperimentController
  38         :param guid: guid of the RM
  39         :type guid: int
  40         :param creds: Credentials to communicate with the rm (XmppClient)
  41         :type creds: dict
  42
  43     """
  44     _rtype = "Collector"
  45
  46     @classmethod
  47     def _register_attributes(cls):
  48         trace_name = Attribute("traceName", "Name of the trace to be collected",
  49                 flags = Flags.ExecReadOnly)
  50         store_dir = Attribute("storeDir", "Path to local directory to store trace results",
  51                 default = tempfile.gettempdir(),
  52                 flags = Flags.ExecReadOnly)
  53         sub_dir = Attribute("subDir", "Sub directory to collect traces into",
  54                 flags = Flags.ExecReadOnly)
  55
  56         cls._register_attribute(trace_name)
  57         cls._register_attribute(store_dir)
  58         cls._register_attribute(sub_dir)
  59
  60     def __init__(self, ec, guid):
  61         super(Collector, self).__init__(ec, guid)
  62         self._store_path =  None
  63
  64     @property
  65     def store_path(self):
  66         return self._store_path
  67
  68     def provision(self):
  69         trace_name = self.get("traceName")
  70         if not trace_name:
  71             self.fail()
  72
  73             msg = "No traceName was specified"
  74             self.error(msg)
  75             raise RuntimeError, msg
  76
  77         store_dir = self.get("storeDir")
  78         self._store_path = os.path.join(store_dir, self.ec.exp_id, self.ec.run_id)
  79
  80         subdir = self.get("subDir")
  81         if subdir:
  82             self._store_path = os.path.join(self._store_path, subdir)
  83
  84         msg = "Creating local directory at %s to store %s traces " % (
  85             store_dir, trace_name)
  86         self.info(msg)
  87
  88         try:
  89             os.makedirs(self.store_path)
  90         except OSError:
  91             pass
  92
  93         super(Collector, self).provision()
  94
  95     def deploy(self):
  96         try:
  97             self.discover()
  98             self.provision()
  99         except:
 100             self.fail()
 101             raise
 102
 103         super(Collector, self).deploy()
 104
 105     def release(self):
 106         trace_name = self.get("traceName")
 107
 108         msg = "Collecting '%s' traces to local directory %s" % (
 109             trace_name, self.store_path)
 110         self.info(msg)
 111
 112         rms = self.get_connected()
 113         for rm in rms:
 114             result = self.ec.trace(rm.guid, trace_name)
 115             fpath = os.path.join(self.store_path, "%d.%s" % (rm.guid,
 116                 trace_name))
 117             f = open(fpath, "w")
 118             f.write(result)
 119             f.close()
 120
 121         super(Collector, self).release()
 122
 123     def valid_connection(self, guid):
 124         # TODO: Validate!
 125         return True
 126