X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2Fnepi%2Fresources%2Flinux%2Fccn%2Fccncontent.py;h=f75f0a038b676b382deac9a6bc551e283a3ee2b1;hb=ac866efb762875550bdc0c05d693e5eb026f435e;hp=fbe7c95630852688447cdcb2f3a84ea1b960c2b3;hpb=245dc3d34b17d5ccbdb4e438c998bd547a7af076;p=nepi.git

diff --git a/src/nepi/resources/linux/ccn/ccncontent.py b/src/nepi/resources/linux/ccn/ccncontent.py
index fbe7c956..f75f0a03 100644
--- a/src/nepi/resources/linux/ccn/ccncontent.py
+++ b/src/nepi/resources/linux/ccn/ccncontent.py
@@ -18,81 +18,133 @@
 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
 
 from nepi.execution.attribute import Attribute, Flags, Types
-from nepi.execution.trace import Trace, TraceAttr
-from nepi.execution.resource import ResourceManager, clsinit_copy, ResourceState, \
+from nepi.execution.resource import clsinit_copy, ResourceState, \
     ResourceAction
 from nepi.resources.linux.application import LinuxApplication
 from nepi.resources.linux.ccn.ccnr import LinuxCCNR
-from nepi.resources.linux.node import OSType
+from nepi.util.timefuncs import tnow
 
-from nepi.util.sshfuncs import ProcStatus
-from nepi.util.timefuncs import strfnow, strfdiff
 import os
 
-reschedule_delay = "0.5s"
-
 @clsinit_copy
-class LinuxCCNR(LinuxApplication):
+class LinuxCCNContent(LinuxApplication):
     _rtype = "LinuxCCNContent"
 
     @classmethod
     def _register_attributes(cls):
         content_name = Attribute("contentName",
                 "The name of the content to publish (e.g. ccn:/VIDEO) ",
-            flags = Flags.ExecReadOnly)
+                flags = Flags.Design)
+
         content = Attribute("content",
                 "The content to publish. It can be a path to a file or plain text ",
-            flags = Flags.ExecReadOnly)
+                flags = Flags.Design)
 
+        scope = Attribute("scope",
+                "Use the given scope on the start-write request (if -r specified). "
+                "scope can be 1 (local), 2 (neighborhood), or 3 (unlimited). "
+                "Note that a scope of 3 is encoded as the absence of any scope in the interest. ",
+                type = Types.Integer,
+                default = 1,
+                flags = Flags.Design)
 
         cls._register_attribute(content_name)
         cls._register_attribute(content)
-
-    @classmethod
-    def _register_traces(cls):
-        log = Trace("log", "CCND log output")
-
-        cls._register_trace(log)
+        cls._register_attribute(scope)
 
     def __init__(self, ec, guid):
         super(LinuxCCNContent, self).__init__(ec, guid)
-
+        self._home = "content-%s" % self.guid
+        
     @property
     def ccnr(self):
-        ccnr = self.get_connected(LinuxCCNR.rtype())
+        ccnr = self.get_connected(LinuxCCNR.get_rtype())
         if ccnr: return ccnr[0]
         return None
 
-    def deploy(self):
-        if not self.get("command"):
-            self.set("command", self._default_command)
-        
-        if not self.get("env"):
-            self.set("env", self._default_environment)
+    @property
+    def ccnd(self):
+        if self.ccnr: return self.ccnr.ccnd
+        return None
+
+    @property
+    def node(self):
+        if self.ccnr: return self.ccnr.node
+        return None
+
+    def do_deploy(self):
+        if not self.ccnr or self.ccnr.state < ResourceState.READY:
+            self.debug("---- RESCHEDULING DEPLOY ---- node state %s " % self.node.state )
+            
+            # ccnr needs to wait until ccnd is deployed and running
+            self.ec.schedule(self.reschedule_delay, self.deploy)
+        else:
+            if not self.get("command"):
+                self.set("command", self._start_command)
+
+            if not self.get("env"):
+                self.set("env", self._environment)
+
+            # set content to stdin, so the content will be
+            # uploaded during provision
+            self.set("stdin", self.get("content"))
+
+            command = self.get("command")
+
+            self.info("Deploying command '%s' " % command)
+
+            self.do_discover()
+            self.do_provision()
+
+            self.set_ready()
 
-        # Wait until associated ccnd is provisioned
-        ccnr = self.ccnr
+    def upload_start_command(self):
+        command = self.get("command")
+        env = self.get("env")
 
-        if not ccnr or ccnr.state < ResourceState.STARTED:
-            self.ec.schedule(reschedule_delay, self.deploy)
+        self.info("Uploading command '%s'" % command)
+
+        # We want to make sure the content is published
+        # before the experiment starts.
+        # Run the command as a bash script in the background, 
+        # in the host ( but wait until the command has
+        # finished to continue )
+        env = self.replace_paths(env)
+        command = self.replace_paths(command)
+
+        (out, err), proc = self.execute_command(command, 
+                env, blocking = True)
+
+        if proc.poll():
+            msg = "Failed to execute command"
+            self.error(msg, out, err)
+            raise RuntimeError, msg
+
+    def do_start(self):
+        if self.state == ResourceState.READY:
+            command = self.get("command")
+            self.info("Starting command '%s'" % command)
+
+            self.set_started()
         else:
-            # Add a start after condition so CCNR will not start
-            # before CCND does
-            self.ec.register_condition(self.guid, ResourceAction.START, 
-                ccnd.guid, ResourceState.STARTED)
- 
-            # Invoke the actual deployment
-            super(LinuxCCNContent, self).deploy()
+            msg = " Failed to execute command '%s'" % command
+            self.error(msg, out, err)
+            raise RuntimeError, msg
 
     @property
-    def _default_command(self):
-        return "ccnseqwriter -r %s " % self.get("contentName")
+    def _start_command(self):
+        command = ["ccnseqwriter"]
+        command.append("-r %s" % self.get("contentName"))
+        command.append("-s %d" % self.get("scope"))
+        command.append("< %s" % os.path.join(self.app_home, 'stdin'))
+
+        command = " ".join(command)
+        return command
 
     @property
-    def _default_environment(self):
-        env = "PATH=$PATH:${EXP_HOME}/ccnx/bin "
-        return env            
-        
+    def _environment(self):
+        return self.ccnd.path
+       
     def valid_connection(self, guid):
         # TODO: Validate!
         return True