Fixing RM.DEPLOY being executed after/during RM.RELEASE by adding a release_lock...
[nepi.git] / src / nepi / resources / linux / ccn / fibentry.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 clsinit_copy, ResourceState, \
23     ResourceAction, reschedule_delay
24 from nepi.resources.linux.application import LinuxApplication
25 from nepi.resources.linux.ccn.ccnd import LinuxCCND
26 from nepi.util.timefuncs import tnow
27
28 import os
29 import socket
30 import time
31
32
33 # TODO: Add rest of options for ccndc!!!
34 #       Implement ENTRY DELETE!!
35
36 @clsinit_copy
37 class LinuxFIBEntry(LinuxApplication):
38     _rtype = "LinuxFIBEntry"
39
40     @classmethod
41     def _register_attributes(cls):
42         uri = Attribute("uri",
43                 "URI prefix to match and route for this FIB entry",
44                 default = "ccnx:/",
45                 flags = Flags.ExecReadOnly)
46
47         protocol = Attribute("protocol",
48                 "Transport protocol used in network connection to peer "
49                 "for this FIB entry. One of 'udp' or 'tcp'.",
50                 type = Types.Enumerate, 
51                 default = "udp",
52                 allowed = ["udp", "tcp"],
53                 flags = Flags.ExecReadOnly)
54
55         host = Attribute("host",
56                 "Peer hostname used in network connection for this FIB entry. ",
57                 flags = Flags.ExecReadOnly)
58
59         port = Attribute("port",
60                 "Peer port address used in network connection to peer "
61                 "for this FIB entry.",
62                 flags = Flags.ExecReadOnly)
63
64         ip = Attribute("ip",
65                 "Peer host public IP used in network connection for this FIB entry. ",
66                 flags = Flags.ReadOnly)
67
68         cls._register_attribute(uri)
69         cls._register_attribute(protocol)
70         cls._register_attribute(host)
71         cls._register_attribute(port)
72         cls._register_attribute(ip)
73
74     @classmethod
75     def _register_traces(cls):
76         ping = Trace("ping", "Ping to the peer end")
77         mtr = Trace("mtr", "Mtr to the peer end")
78         traceroute = Trace("traceroute", "Tracerout to the peer end")
79
80         cls._register_trace(ping)
81         cls._register_trace(mtr)
82         cls._register_trace(traceroute)
83
84     def __init__(self, ec, guid):
85         super(LinuxFIBEntry, self).__init__(ec, guid)
86         self._home = "fib-%s" % self.guid
87         self._ping = None
88         self._mtr = None
89         self._traceroute = None
90
91     @property
92     def ccnd(self):
93         ccnd = self.get_connected(LinuxCCND.rtype())
94         if ccnd: return ccnd[0]
95         return None
96
97     @property
98     def node(self):
99         if self.ccnd: return self.ccnd.node
100         return None
101
102     def trace(self, name, attr = TraceAttr.ALL, block = 512, offset = 0):
103         if name == "ping":
104             return self.ec.trace(self._ping, "stdout", attr, block, offset)
105         if name == "mtr":
106             return self.ec.trace(self._mtr, "stdout", attr, block, offset)
107         if name == "traceroute":
108             return self.ec.trace(self._traceroute, "stdout", attr, block, offset)
109
110         return super(LinuxFIBEntry, self).trace(name, attr, block, offset)
111     
112     def do_deploy(self):
113         # Wait until associated ccnd is provisioned
114         if not self.ccnd or self.ccnd.state < ResourceState.READY:
115             # ccnr needs to wait until ccnd is deployed and running
116             self.ec.schedule(reschedule_delay, self.deploy)
117         else:
118             if not self.get("ip"):
119                 host = self.get("host")
120                 ip = socket.gethostbyname(host)
121                 self.set("ip", ip)
122
123             if not self.get("command"):
124                 self.set("command", self._start_command)
125
126             if not self.get("env"):
127                 self.set("env", self._environment)
128
129             command = self.get("command")
130
131             self.info("Deploying command '%s' " % command)
132
133             self.do_discover()
134             self.do_provision()
135             self.configure()
136
137             self.debug("----- READY ---- ")
138             self.set_ready()
139
140     def upload_start_command(self):
141         command = self.get("command")
142         env = self.get("env")
143
144         # We want to make sure the FIB entries are created
145         # before the experiment starts.
146         # Run the command as a bash script in the background, 
147         # in the host ( but wait until the command has
148         # finished to continue )
149         env = env and self.replace_paths(env)
150         command = self.replace_paths(command)
151
152         # ccndc seems to return exitcode OK even if a (dns) error
153         # occurred, so we need to account for this case here. 
154         (out, err), proc = self.execute_command(command, 
155                 env, blocking = True)
156
157         if proc.poll():
158             msg = "Failed to execute command"
159             self.error(msg, out, err)
160             raise RuntimeError, msg
161         
162     def configure(self):
163         if self.trace_enabled("ping"):
164             self.info("Configuring PING trace")
165             self._ping = self.ec.register_resource("LinuxPing")
166             self.ec.set(self._ping, "printTimestamp", True)
167             self.ec.set(self._ping, "target", self.get("host"))
168             self.ec.register_connection(self._ping, self.node.guid)
169             # schedule ping deploy
170             self.ec.deploy(guids=[self._ping], group = self.deployment_group)
171
172         if self.trace_enabled("mtr"):
173             self.info("Configuring MTR trace")
174             self._mtr = self.ec.register_resource("LinuxMtr")
175             self.ec.set(self._mtr, "noDns", True)
176             self.ec.set(self._mtr, "printTimestamp", True)
177             self.ec.set(self._mtr, "continuous", True)
178             self.ec.set(self._mtr, "target", self.get("host"))
179             self.ec.register_connection(self._mtr, self.node.guid)
180             # schedule mtr deploy
181             self.ec.deploy(guids=[self._mtr], group = self.deployment_group)
182
183         if self.trace_enabled("traceroute"):
184             self.info("Configuring TRACEROUTE trace")
185             self._traceroute = self.ec.register_resource("LinuxTraceroute")
186             self.ec.set(self._traceroute, "printTimestamp", True)
187             self.ec.set(self._traceroute, "continuous", True)
188             self.ec.set(self._traceroute, "target", self.get("host"))
189             self.ec.register_connection(self._traceroute, self.node.guid)
190             # schedule mtr deploy
191             self.ec.deploy(guids=[self._traceroute], group = self.deployment_group)
192
193     def do_start(self):
194         if self.state == ResourceState.READY:
195             command = self.get("command")
196             self.info("Starting command '%s'" % command)
197
198             self.set_started()
199         else:
200             msg = " Failed to execute command '%s'" % command
201             self.error(msg, out, err)
202             raise RuntimeError, msg
203
204     def do_stop(self):
205         command = self.get('command')
206         env = self.get('env')
207         
208         if self.state == ResourceState.STARTED:
209             self.info("Stopping command '%s'" % command)
210
211             command = self._stop_command
212             (out, err), proc = self.execute_command(command, env,
213                     blocking = True)
214
215             self.set_stopped()
216
217             if err:
218                 msg = " Failed to execute command '%s'" % command
219                 self.error(msg, out, err)
220                 raise RuntimeError, msg
221
222     @property
223     def _start_command(self):
224         uri = self.get("uri") or ""
225         protocol = self.get("protocol") or ""
226         ip = self.get("ip") or "" 
227         port = self.get("port") or ""
228
229         # add ccnx:/example.com/ udp 224.0.0.204 52428
230         return "ccndc add %(uri)s %(protocol)s %(host)s %(port)s" % ({
231             "uri" : uri,
232             "protocol": protocol,
233             "host": ip,
234             "port": port
235             })
236
237     @property
238     def _stop_command(self):
239         uri = self.get("uri") or ""
240         protocol = self.get("protocol") or ""
241         ip = self.get("ip") or ""
242         port = self.get("port") or ""
243
244         # add ccnx:/example.com/ udp 224.0.0.204 52428
245         return "ccndc del %(uri)s %(protocol)s %(host)s %(port)s" % ({
246             "uri" : uri,
247             "protocol": protocol,
248             "host": ip,
249             "port": port
250             })
251
252     @property
253     def _environment(self):
254         return self.ccnd.path
255        
256     def valid_connection(self, guid):
257         # TODO: Validate!
258         return True
259