aboutsummaryrefslogtreecommitdiffstats
path: root/vicn/resource/ns3/emulated_channel.py
blob: 08d7a14b173c3a1384a236950567e04fe29b3387 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (c) 2017 Cisco and/or its affiliates.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

import logging
import random

from netmodel.model.type                import Integer
from netmodel.util.socket		import check_port
from vicn.core.address_mgr              import AddressManager
from vicn.core.attribute      	        import Attribute, Multiplicity
from vicn.core.exception                import ResourceNotFound
from vicn.core.requirement              import Requirement
from vicn.core.resource                 import BaseResource
from vicn.core.resource_mgr             import wait_resources
from vicn.core.task                     import inline_task, async_task, task
from vicn.core.task                     import BashTask, run_task
from vicn.resource.channel              import Channel
from vicn.resource.linux.application    import LinuxApplication as Application
from vicn.resource.linux.net_device     import NetDevice
from vicn.resource.linux.tap_device     import TapDevice
from vicn.resource.linux.veth_pair      import VethPair
from vicn.resource.lxd.lxc_container    import LxcContainer
from vicn.resource.node                 import Node

log = logging.getLogger(__name__)

class EmulatedChannel(Channel, Application):
    """EmulatedChannel resource

    This resources serves as a base class for wireless channels emulated by
    means of ns3 simulation.

    Attributes:
        ap (Reference[node]): Reference to the AP node
        stations (Reference[node]): Reference to the list of stations.
        control_port (int): Port used to communicate with the management
            interface of the simulation.

    Implementation notes:
      - Both AP and stations are allocated a separate VLAN to isolate broadcast
        traffic and prevent loops on the bridge.
      - We also need that all interfaces related to ap and stations are created
        before we run the commandline (currently, dynamically adding/removing
        AP and stations is not supported by the emulator). This is made 
        possible thanks to the key=True parameter, which makes sure the
        attributes are processed before the __create__ is called.

    Todo:
      - Retrieve the process PID to kill it during __delete__
    """

    __resource_type__ = BaseResource

    ap = Attribute(Node, description = 'AP', key = True)
    stations = Attribute(Node, description = 'List of stations',
            multiplicity = Multiplicity.OneToMany, key = True)
    control_port = Attribute(Integer, 
            description = 'Control port for the simulation')

    # Overloaded attributes
    node = Attribute(requirements = [
            Requirement('bridge')
        ])

    #--------------------------------------------------------------------------
    # Constructor
    #--------------------------------------------------------------------------

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # AP (resp. stations) interfaces (for external connectivity) and
        # tap_devices (for connection to emulator)
        self._ap_if = None
        self._ap_tap = None
        self._sta_ifs = dict()
        self._sta_taps = dict()

        # Device names to be attached to the bridge (differs according to the
        # node type, Physical or LxcContainer, and eventually None for an
        # unmanaged stations)
        self._ap_bridged = None
        self._sta_bridged = dict()

    #--------------------------------------------------------------------------
    # Resource lifecycle
    #--------------------------------------------------------------------------

    @inline_task
    def __get__(self):
        raise ResourceNotFound

    def __create__(self):
        # NOTE: http://stackoverflow.com/questions/21141352/python-subprocess-
        #       calling-a-script-which-runs-a-background-process-hanging
        # The output of the background scripts is still going to the same file
        # descriptor as the child script, thus the parent script waits for it
        # to finish.
        cmd = '(' + self.__app_name__ + ' ' + self._get_cmdline_params() + \
            '>/dev/null 2>&1) &'
        return BashTask(self.node, cmd)

    def __delete__(self):
        raise NotImplementedError

    #--------------------------------------------------------------------------
    # Attribute handlers
    #--------------------------------------------------------------------------

    @async_task
    async def _set_ap(self, ap=None):
        if ap is None:
            ap = self.ap
        if ap is None:
            log.info('Ignored setting ap to None...')
            return

        # Add a WiFi interface for the AP...
        interfaces = list()
        if isinstance(ap, LxcContainer):
            # Ideally, We need to create a VethPair for each station
            # This should be monitored for the total channel bw
            host = NetDevice(node = ap.node,
                device_name='vhh-' + ap.name + '-' + self.name,
                monitored = False,
                managed = False)
            self._ap_if = VethPair(node = self.ap,
                    name          = 'vh-' + ap.name + '-' + self.name,
                    device_name   = 'vh-' + ap.name + '-' + self.name, 
                    host          = host,
                    owner = self)
            self._ap_bridged = self._ap_if.host
        else:
            raise NotImplementedError
        self._state.manager.commit_resource(self._ap_if)

        interfaces.append(self._ap_if)

        # Add a tap interface for the AP...
        self._ap_tap = TapDevice(node = self.node, 
                owner = self,
                device_name = 'tap-' + ap.name + '-' + self.name,
                up = True,
                promiscuous = True,
                monitored = False)
        self._state.manager.commit_resource(self._ap_tap)
        interfaces.append(self._ap_tap)

        # Wait for interfaces to be setup
        await wait_resources(interfaces)

        # NOTE: only set channel after the resource is created or it might
        # create loops which, at this time, are not handled 
        self._ap_if.set('channel', self)

        # Add interfaces to bridge
        vlan = AddressManager().get('vlan', self, tag='ap') 

        # AS the container has created the VethPair already without Vlan, we
        # need to delete and recreate it
        task = self.node.bridge._remove_interface(self._ap_bridged)
        await run_task(task, self._state.manager)
        task = self.node.bridge._add_interface(self._ap_bridged, vlan = vlan)
        await run_task(task, self._state.manager)

        task = self.node.bridge._add_interface(self._ap_tap, vlan = vlan)
        await run_task(task, self._state.manager)

        print('/!\ pass information to the running simulation')

    @inline_task
    def _get_ap(self):
        return {'ap': None}

    @inline_task
    def _get_stations(self):
        return {'stations': list()}

    @async_task
    async def _set_stations(self, stations=None):
        print('adding stations...')
        if stations is None:
            stations = self.stations

        for station in stations:
            await self._add_station(station)

    def _add_stations(self, stations):
        raise NotImplementedError

    @inline_task
    def _remove_stations(self, station):
        raise NotImplementedError