systematic use of context managers for dealing with files instead of open()/close...
[nepi.git] / src / nepi / resources / ns3 / resource_manager_generator.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 version 2 as
7 #    published by the Free Software Foundation;
8 #
9 #    This program is distributed in the hope that it will be useful,
10 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
11 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 #    GNU General Public License for more details.
13 #
14 #    You should have received a copy of the GNU General Public License
15 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 #
17 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
18
19 #
20 # Instructions to automatically generate ns-3 ResourceManagers
21
22 # Configure the ns-3 enviorment (e.g.):
23 #
24 #  export PYTHONPATH=~/.nepi/nepi-usr/bin/ns-3/ns-3.20/optimized/build/lib/python/site-packages
25 #  export LD_LIBRARY_PATH=~/.nepi/nepi-usr/bin/ns-3/ns-3.20/optimized/build/lib
26 #
27 # Run the RM generator:
28 #
29 #  PYTHONPATH=$PYTHONPATH:~/repos/nepi/src python src/nepi/resources/ns3/resource_manager_generator.py
30 #
31
32 from __future__ import print_function
33
34 # Force the load of ns3 libraries
35 from nepi.resources.ns3.ns3wrapper import load_ns3_module
36
37 import os
38 import re
39
40 adapted_types = ["ns3::Node",
41         "ns3::Icmpv4L4Protocol",
42         "ns3::ArpL3Protocol",
43         "ns3::Ipv4L3Protocol",
44         "ns3::PropagationLossModel",
45         "ns3::MobilityModel",
46         "ns3::PropagationDelayModel",
47         "ns3::WifiRemoteStationManager",
48         "ns3::WifiNetDevice",
49         "ns3::WifiChannel",
50         "ns3::WifiPhy",
51         "ns3::WifiMac",
52         "ns3::ErrorModel",
53         "ns3::ErrorRateModel",
54         "ns3::Application", 
55         "ns3::FdNetDevice",
56         #"ns3::DceApplication", 
57         "ns3::NetDevice",
58         "ns3::Channel",
59         "ns3::Queue"]
60
61 base_types = ["ns3::IpL4Protocol"]
62
63 def select_base_class(ns3, tid): 
64     base_class_import = None
65     base_class = None
66    
67     rtype = tid.GetName()
68
69     type_id = ns3.TypeId()
70
71     for type_name in adapted_types:
72         tid_base = type_id.LookupByName(type_name)
73         if type_name == rtype or tid.IsChildOf(tid_base):
74             base_class = "NS3Base" + type_name.replace("ns3::", "")
75             base_module = "ns3" + type_name.replace("ns3::", "").lower()
76             base_class_import = "from nepi.resources.ns3.%s import %s " % (
77                     base_module, base_class)
78             return (base_class_import, base_class)
79
80     base_class_import = "from nepi.resources.ns3.ns3base import NS3Base"
81     base_class = "NS3Base"
82
83     for type_name in base_types:
84         tid_base = type_id.LookupByName(type_name)
85         if type_name == rtype or tid.IsChildOf(tid_base):
86             return (base_class_import, base_class)
87
88     return (None, None)
89
90 def create_ns3_rms():
91     ns3 = load_ns3_module()
92
93     type_id = ns3.TypeId()
94     
95     tid_count = type_id.GetRegisteredN()
96     base = type_id.LookupByName("ns3::Object")
97
98     # Create a .py file using the ns-3 RM template for each ns-3 TypeId
99     for i in xrange(tid_count):
100         tid = type_id.GetRegistered(i)
101         
102         (base_class_import, base_class) = select_base_class(ns3, tid)
103         if not base_class:
104             continue
105         
106         if tid.MustHideFromDocumentation() or \
107                 not tid.HasConstructor() or \
108                 not tid.IsChildOf(base): 
109             continue
110        
111         attributes = template_attributes(ns3, tid)
112         traces = template_traces(ns3, tid)
113         ptid = tid
114         while ptid.HasParent():
115             ptid = ptid.GetParent()
116             attributes += template_attributes(ns3, ptid)
117             traces += template_traces(ns3, ptid)
118
119         attributes = "\n" + attributes if attributes else "pass"
120         traces = "\n" + traces if traces else "pass"
121
122         category = tid.GetGroupName()
123
124         rtype = tid.GetName()
125         classname = rtype.replace("ns3::", "NS3").replace("::","")
126         uncamm_rtype = re.sub('([a-z])([A-Z])', r'\1-\2', rtype).lower()
127         short_rtype = uncamm_rtype.replace("::","-")
128
129         d = os.path.dirname(os.path.realpath(__file__))
130         with open(os.path.join(d, "templates", "resource_manager_template.txt"), "r") as ftemp:
131             template = ftemp.read()
132
133         template = template. \
134                 replace("<CLASS_NAME>", classname). \
135                 replace("<RTYPE>", rtype). \
136                 replace("<ATTRIBUTES>", attributes). \
137                 replace("<TRACES>", traces). \
138                 replace("<BASE_CLASS_IMPORT>", base_class_import). \
139                 replace("<BASE_CLASS>", base_class). \
140                 replace("<SHORT-RTYPE>", short_rtype)
141
142         fname = uncamm_rtype.replace('ns3::', ''). \
143                 replace('::', ''). \
144                 replace("-","_").lower() + ".py"
145
146         with open(os.path.join(d, "classes", fname), "w") as f:
147             print(os.path.join(d, fname))
148             print(template)
149             f.write(template)
150
151 def template_attributes(ns3, tid): 
152     d = os.path.dirname(os.path.realpath(__file__))
153     with open(os.path.join(d, "templates", "attribute_template.txt"), "r") as ftemp:
154         template = ftemp.read()
155
156     attributes = ""
157
158     attr_count = tid.GetAttributeN()
159     for i in xrange(attr_count):
160         attr_info = tid.GetAttribute(i)
161         if not attr_info.accessor.HasGetter():
162             continue
163
164         attr_flags = "Flags.Reserved"
165         flags = attr_info.flags
166         if (flags & ns3.TypeId.ATTR_CONSTRUCT) == ns3.TypeId.ATTR_CONSTRUCT:
167             attr_flags += " | Flags.Construct"
168         else:
169             if (flags & ns3.TypeId.ATTR_GET) != ns3.TypeId.ATTR_GET:
170                 attr_flags += " | Flags.NoRead"
171             elif (flags & ns3.TypeId.ATTR_SET) != ns3.TypeId.ATTR_SET:
172                 attr_flags += " | Flags.NoWrite"
173
174         attr_name = attr_info.name
175         checker = attr_info.checker
176         attr_help = attr_info.help.replace('"', '\\"').replace("'", "\\'")
177         value = attr_info.initialValue
178         attr_value = value.SerializeToString(checker)
179         attr_allowed = "None"
180         attr_range = "None"
181         attr_type = "Types.String"
182
183         if isinstance(value, ns3.ObjectVectorValue):
184             continue
185         elif isinstance(value, ns3.PointerValue):
186             continue
187         elif isinstance(value, ns3.WaypointValue):
188             continue
189         elif isinstance(value, ns3.BooleanValue):
190             attr_type = "Types.Bool"
191             attr_value = "True" if attr_value == "true" else "False"
192         elif isinstance(value, ns3.EnumValue):
193             attr_type = "Types.Enumerate"
194             allowed = checker.GetUnderlyingTypeInformation().split("|")
195             attr_allowed = "[%s]" % ",".join(map(lambda x: "\"%s\"" % x, allowed))
196         elif isinstance(value, ns3.DoubleValue):
197             attr_type = "Types.Double"
198             # TODO: range
199         elif isinstance(value, ns3.UintegerValue):
200             attr_type = "Types.Integer"
201             # TODO: range
202
203         attr_id = "attr_" + attr_name.lower().replace("-", "_")
204         attributes += template.replace("<ATTR_ID>", attr_id) \
205                 .replace("<ATTR_NAME>", attr_name) \
206                 .replace("<ATTR_HELP>", attr_help) \
207                 .replace("<ATTR_TYPE>", attr_type) \
208                 .replace("<ATTR_DEFAULT>", attr_value) \
209                 .replace("<ATTR_ALLOWED>", attr_allowed) \
210                 .replace("<ATTR_RANGE>", attr_range) \
211                 .replace("<ATTR_FLAGS>", attr_flags) 
212
213     return attributes
214
215 def template_traces(ns3, tid): 
216     d = os.path.dirname(os.path.realpath(__file__))
217     with open(os.path.join(d, "templates", "trace_template.txt"), "r") as ftemp:
218         template = ftemp.read()
219
220     traces = ""
221
222     trace_count = tid.GetTraceSourceN()
223     for i in xrange(trace_count):
224         trace_info = tid.GetTraceSource(i)
225         trace_name = trace_info.name
226         trace_help = trace_info.help.replace('"', '\\"').replace("'", "\\'")
227
228         trace_id = trace_name.lower()
229         traces += template.replace("<TRACE_ID>", trace_id) \
230                 .replace("<TRACE_NAME>", trace_name) \
231                 .replace("<TRACE_HELP>", trace_help) 
232
233     return traces
234
235 if __name__ == "__main__":
236     create_ns3_rms()