Introduced groups + lxd profiles + diverted control network handling to lxd + misc bug fixes

Change-Id: Iae26bc2994ac9704dde7dfa8fbe4be1b74cf9e6f
Signed-off-by: Marcel Enguehard <mengueha+fdio@cisco.com>

31 files changed, 809 insertions, 538 deletions

diff --git a/config/logging.conf b/config/logging.conf
index b1ca30fd..b21a4c4d 100755
--- a/config/logging.conf
+++ b/config/logging.conf
@@ -15,7 +15,7 @@ handlers=file_handler
 class=FileHandler
 level=DEBUG
 formatter=formatter
-args=("/tmp/vicn.log", "w")
+args=("~/.vicn/vicn.log", "w")
 
 [formatter_formatter]
 format=%(asctime)s %(levelname)8s %(name)25s.%(funcName)25s %(message)20s
diff --git a/examples/tutorial/tutorial01.json b/examples/tutorial/tutorial01.json
index edc0e6da..dbef980f 100644
--- a/examples/tutorial/tutorial01.json
+++ b/examples/tutorial/tutorial01.json
@@ -1,6 +1,10 @@
 {
     "resources": [
         {
+            "type": "Group",
+            "name": "topology"
+        },
+        {
             "type": "Physical",
             "name": "server",
             "hostname": "localhost"
@@ -14,41 +18,48 @@
         {
             "type": "LxcImage",
             "name": "ubuntu1604-cicnsuite-rc2",
+            "groups": ["topology"],
             "node": "server"
         },
         {
             "type": "LxcContainer",
             "image": "ubuntu1604-cicnsuite-rc2",
+            "groups": ["topology"],
             "name": "prod1",
             "node": "server"
         },
         {
             "type": "LxcContainer",
             "image": "ubuntu1604-cicnsuite-rc2",
+            "groups": ["topology"],
             "name": "prod2",
             "node": "server"
         },
         {
             "type": "LxcContainer",
             "image": "ubuntu1604-cicnsuite-rc2",
+            "groups": ["topology"],
             "name": "core2",
             "node": "server"
         },
         {
             "type": "LxcContainer",
             "image": "ubuntu1604-cicnsuite-rc2",
+            "groups": ["topology"],
             "name": "core1",
             "node": "server"
         },
         {
             "type": "LxcContainer",
             "image": "ubuntu1604-cicnsuite-rc2",
+            "groups": ["topology"],
             "name": "cons1",
             "node": "server"
         },
         {
             "type": "LxcContainer",
             "name": "cons2",
+            "groups": ["topology"],
             "node": "server",
             "image": "ubuntu1604-cicnsuite-rc2"
         },
@@ -60,7 +71,7 @@
             "type": "WebServer",
             "node": "prod1",
             "prefixes": [
-                "/webserver"
+                "/webserver1"
             ]
         },
         {
@@ -71,7 +82,7 @@
             "type": "WebServer",
             "node": "prod2",
             "prefixes": [
-                "/webserver"
+                "/webserver2"
             ]
         },
         {
@@ -92,26 +103,31 @@
         },
         {
             "type": "Link",
+            "groups": ["topology"],
             "src_node": "cons1",
             "dst_node": "core1"
         },
         {
             "type": "Link",
+            "groups": ["topology"],
             "src_node": "cons2",
             "dst_node": "core1"
         },
         {
             "type": "Link",
+            "groups": ["topology"],
             "src_node": "core1",
             "dst_node": "core2"
         },
         {
             "type": "Link",
+            "groups": ["topology"],
             "src_node": "core2",
             "dst_node": "prod1"
         },
         {
             "type": "Link",
+            "groups": ["topology"],
             "src_node": "core2",
             "dst_node": "prod2"
         },
@@ -120,11 +136,12 @@
             "ip_routing_strategy": "spt",
 	    "ip6_data_prefix": "2001::/50",
 	    "ip4_data_prefix": "192.168.128.0/24",
-	    "ip4_control_prefix": "192.168.140.0/24"
+	    "groups": ["topology"]
         },
         {
             "type": "CentralICN",
-            "face_protocol": "udp4"
+            "face_protocol": "udp4",
+	    "groups": ["topology"]
         }
     ]
 }
diff --git a/vicn/resource/gui.py b/netmodel/model/collection.py
index 3ded7a5a..21be84d8 100644
--- a/vicn/resource/gui.py
+++ b/netmodel/model/collection.py
@@ -16,14 +16,13 @@
 # limitations under the License.
 #
 
-from vicn.helpers.resource_definition import *
+from netmodel.model.filter      import Filter
 
-class GUI(Resource):
+class Collection(list):
     """
-    Resource: GUI
-
-    This resource is empty on purpose. It is a temporary resource used as a
-    placeholder for controlling the GUI and should be deprecated in future
-    releases.
+    A collection corresponds to a list of objects, and includes processing functionalities to
+    manipulate them.
     """
-    pass
+
+    def filter(self, filter):
+        return filter.filter(self)
diff --git a/netmodel/util/file.py b/netmodel/util/file.py
new file mode 100644
index 00000000..4204d533
--- /dev/null
+++ b/netmodel/util/file.py
@@ -0,0 +1,74 @@
+#!/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 errno
+import logging
+import os
+import tempfile
+
+log = logging.getLogger(__name__)
+
+def mkdir(directory):
+    """
+    Create a directory (mkdir -p).
+    Args:
+        directory: A String containing an absolute path.
+    Raises:
+        OSError: If the directory cannot be created.
+    """
+    try:
+        if not os.path.exists(directory):
+            log.info("Creating '%s' directory" % directory)
+        os.makedirs(directory)
+    except OSError as e:
+        if e.errno == errno.EEXIST and os.path.isdir(directory):
+            pass
+        else:
+            raise OSError("Cannot mkdir %s: %s" % (directory, e))
+
+def check_writable_directory(directory):
+    """
+    Tests whether a directory is writable.
+    Args:
+        directory: A String containing an absolute path.
+    Raises:
+        RuntimeError: If the directory does not exists or isn't writable.
+    """
+    if not os.path.exists(directory):
+        raise RuntimeError("Directory '%s' does not exists" % directory)
+    if not os.access(directory, os.W_OK | os.X_OK):
+        raise RuntimeError("Directory '%s' is not writable" % directory)
+    try:
+        with tempfile.TemporaryFile(dir = directory):
+            pass
+    except Exception as e:
+        raise RuntimeError("Cannot write into directory '%s': %s" % (directory, e))
+
+def ensure_writable_directory(directory):
+    """
+    Tests whether a directory exists and is writable. If not,
+    try to create such a directory.
+    Args:
+        directory: A String containing an absolute path.
+    Raises:
+        RuntimeError: If the directory does not exists and cannot be created.
+    """
+    try:
+        check_writable_directory(directory)
+    except RuntimeError as e:
+        mkdir(directory)
diff --git a/netmodel/util/log.py b/netmodel/util/log.py
index 68eb9a7f..f9fa1e03 100644
--- a/netmodel/util/log.py
+++ b/netmodel/util/log.py
@@ -21,6 +21,17 @@ import logging.config
 import os
 import sys
 
+from netmodel.util.file import ensure_writable_directory
+
+# Monkey-patch logging.FileHandler to support expanduser()
+oldFileHandler = logging.FileHandler
+class vICNFileHandler(oldFileHandler):
+    def __init__(self, filename, mode='a', encoding=None, delay=False):
+        filename = os.path.expanduser(filename)
+        ensure_writable_directory(os.path.dirname(filename))
+        super().__init__(filename, mode, encoding, delay)
+logging.FileHandler = vICNFileHandler
+
 colors = {
     'white':        "\033[1;37m",
     'yellow':       "\033[1;33m",
@@ -107,6 +118,7 @@ def initialize_logging():
     if os.path.exists(config_path):
         logging.config.fileConfig(config_path, disable_existing_loggers=False)
 
+
     root = logging.getLogger()
     root.setLevel(logging.DEBUG)
 
diff --git a/vicn/bin/vicn.py b/vicn/bin/vicn.py
index 9a43cf6d..7ece629b 100755
--- a/vicn/bin/vicn.py
+++ b/vicn/bin/vicn.py
@@ -46,36 +46,34 @@ class VICNDaemon(Daemon):
         n_times = 1
         background = False
         setup = False
-        scenario = None
-        node_list, net, ndn, mob, cluster = None, None, None, None, None
 
         parser = ArgumentParser(description=textcolor('green', "Batch usage of VICN."))
-        parser.add_argument('-s', metavar='configuration_file_path',
-                            help="JSON file containing the topology")
-        parser.add_argument('-n', metavar='n_times', type=int,  help='Execute the test multiple times')
-        parser.add_argument('-x', action='store_false', help='No automatic execution')
+        parser.add_argument('-s', '--scenario', metavar='configuration_file_path',
+                action='append',
+                help="JSON file containing the topology")
+        parser.add_argument('-z', '--identifier', metavar='identifier', type=str, help='Experiment identifier')
+        parser.add_argument('-x', '--no-execute', action='store_false', help='Configure only, no automatic execution')
+        parser.add_argument('-c', '--clean', action='store_true', help='Clean deployment before setup')
+        parser.add_argument('-C', '--clean-only', action='store_true', help='Clean only')
 
         arguments = parser.parse_args()
-        args = vars(arguments)
 
+        scenario = arguments.scenario
+        if not scenario:
+            log.error('No scenario specified')
+            sys.exit(-1)
 
-        for option in args.keys():
-            if args[option] is not None:
-                if option == "s":
-                    print(" * Loading the configuration file at {0}".format(args[option]))
-                    scenario = args[option]
-                elif option == "t" and args[option] is True:
-                    background = True
-                elif option == "x" and args[option] is True:
-                    setup = True
-                elif option == "n":
-                    n_times = args[option]
+        identifier = arguments.identifier or "default"
+        clean = arguments.clean or arguments.clean_only
+        execute = not arguments.clean_only or arguments.no_execute
 
         self._api = API()
-        self._api.configure(scenario, setup)
+        self._api.configure(scenario)
 
-        if node_list is not None:
-            ResourceManager().set(node_list)
+        if clean:
+            self._api.teardown()
+        if execute:
+            self._api.setup(commit = True)
 
     def main(self):
         """
diff --git a/vicn/core/api.py b/vicn/core/api.py
index 09167aa0..708e2581 100644
--- a/vicn/core/api.py
+++ b/vicn/core/api.py
@@ -33,6 +33,7 @@ from vicn.resource.node         import Node
 
 DEFAULT_SETTINGS = {
     'network': '192.168.0.0/16',
+    'bridge_name': 'br0',
     'mac_address_base': '0x00163e000000',
     'websocket_port': 9999
 }
@@ -48,48 +49,25 @@ class Event_ts(asyncio.Event):
 class API(metaclass = Singleton):
 
     def terminate(self):
+        # XXX not valid if nothing has been initialized
         ResourceManager().terminate()
 
-    def parse_topology_file(self, topology_fn):
-        log.debug("Parsing topology file %(topology_fn)s" % locals())
+    def parse_topology_file(self, topology_fn, resources, settings):
+        log.info("Parsing topology file %(topology_fn)s" % locals())
         try:
             topology_fd = open(topology_fn, 'r')
         except IOError:
-            self.error("Topology file '%(topology_fn)s not found" % locals())
-            return None
+            log.error("Topology file '%(topology_fn)s not found" % locals())
+            sys.exit(1)
 
         try:
             topology = json.loads(topology_fd.read())
 
             # SETTING
-            settings = DEFAULT_SETTINGS
             settings.update(topology.get('settings', dict()))
 
-            # VICN process-related initializations
-            nofile = settings.get('ulimit-n', None)
-            if nofile is not None and nofile > 0:
-                if nofile < 1024:
-                    log.error('Too few allowed open files for the process')
-                    import os; os._exit(1)
-
-                log.info('Setting open file descriptor limit to {}'.format(
-                            nofile))
-                ulimit.setrlimit(
-                        ulimit.RLIMIT_NOFILE,
-                        (nofile, nofile))
-
-            ResourceManager(base=topology_fn, settings=settings)
-
             # NODES
-            resources = topology.get('resources', list())
-            for resource in resources:
-                try:
-                    ResourceManager().create_from_dict(**resource)
-                except Exception as e:
-                    log.warning("Could not create resource '%r': %r" % \
-                            (resource, e,))
-                    import traceback; traceback.print_exc()
-                    continue
+            resources.extend(topology.get('resources', list()))
 
         except SyntaxError:
             log.error("Error reading topology file '%s'" % (topology_fn,))
@@ -97,16 +75,42 @@ class API(metaclass = Singleton):
 
         log.debug("Done parsing topology file %(topology_fn)s" % locals())
 
-    def configure(self, name, setup=False):
+    def configure(self, scenario_list):
         log.info("Parsing configuration file", extra={'category': 'blue'})
-        self.parse_topology_file(name)
+        resources = list()
+        settings = DEFAULT_SETTINGS
+        for scenario in scenario_list:
+            self.parse_topology_file(scenario, resources, settings)
+
+        # VICN process-related initializations
+        nofile = settings.get('ulimit-n', None)
+        if nofile is not None and nofile > 0:
+            if nofile < 1024:
+                log.error('Too few allowed open files for the process')
+                import os; os._exit(1)
+
+            log.info('Setting open file descriptor limit to {}'.format(
+                        nofile))
+            ulimit.setrlimit(
+                    ulimit.RLIMIT_NOFILE,
+                    (nofile, nofile))
+
+        ResourceManager(base=scenario[-1], settings=settings)
+
+        for resource in resources:
+            try:
+                ResourceManager().create_from_dict(**resource)
+            except Exception as e:
+                log.error("Could not create resource '%r': %r" % \
+                        (resource, e,))
+                import os; os._exit(1)
+
         self._configured = True
-        ResourceManager().setup(commit=setup)
 
-    def setup(self):
+    def setup(self, commit = False):
         if not self._configured:
             raise NotConfigured
-        ResourceManager().setup()
+        ResourceManager().setup(commit)
 
     def teardown(self):
         ResourceManager().teardown()
diff --git a/vicn/core/attribute.py b/vicn/core/attribute.py
index f6ec7c70..22f44487 100644
--- a/vicn/core/attribute.py
+++ b/vicn/core/attribute.py
@@ -42,7 +42,6 @@ class Multiplicity:
     OneToMany = '1_N'
     ManyToOne = 'N_1'
     ManyToMany = 'N_N'
-    
 
     @staticmethod
     def reverse(value):
@@ -108,7 +107,7 @@ class Attribute(abc.ABC, ObjectSpecification):
         self.is_aggregate = False
 
         self._reverse_attributes = list()
-        
+
     #--------------------------------------------------------------------------
     # Display
     #--------------------------------------------------------------------------
@@ -157,7 +156,7 @@ class Attribute(abc.ABC, ObjectSpecification):
                 value = value.get_uuid()
             return value
         else:
-            try: 
+            try:
                 cur_value = vars(instance)[self.name]
                 if self.is_collection:
                     # copy the list
@@ -167,11 +166,11 @@ class Attribute(abc.ABC, ObjectSpecification):
                 if self.is_collection:
                     cur_value = list()
 
-            instance._state.dirty[self.name].trigger(Operations.LIST_ADD, 
+            instance._state.dirty[self.name].trigger(Operations.LIST_ADD,
                     value, cur_value)
 
             # prevent instrumented list to perform operation
-            raise VICNListException 
+            raise VICNListException
 
     def do_list_remove(self, instance, value):
         if instance.is_local_attribute(self.name):
@@ -184,11 +183,11 @@ class Attribute(abc.ABC, ObjectSpecification):
             if self.is_collection:
                 # copy the list
                 cur_value = list(cur_value)
-            instance._state.dirty[self.name].trigger(Operations.LIST_REMOVE, 
+            instance._state.dirty[self.name].trigger(Operations.LIST_REMOVE,
                     value, cur_value)
 
             # prevent instrumented list to perform operation
-            raise VICNListException 
+            raise VICNListException
 
     def do_list_clear(self, instance):
         if instance.is_local_attribute(self.name):
@@ -198,11 +197,11 @@ class Attribute(abc.ABC, ObjectSpecification):
             if self.is_collection:
                 # copy the list
                 cur_value = list(cur_value)
-            instance._state.dirty[self.name].trigger(Operations.LIST_CLEAR, 
+            instance._state.dirty[self.name].trigger(Operations.LIST_CLEAR,
                     value, cur_value)
 
             # prevent instrumented list to perform operation
-            raise VICNListException 
+            raise VICNListException
 
     def handle_getitem(self, instance, item):
         if isinstance(item, UUID):
@@ -227,7 +226,7 @@ class Attribute(abc.ABC, ObjectSpecification):
 
     @property
     def is_collection(self):
-        return self.multiplicity in (Multiplicity.OneToMany, 
+        return self.multiplicity in (Multiplicity.OneToMany,
                 Multiplicity.ManyToMany)
 
     def is_set(self, instance):
diff --git a/vicn/core/collection.py b/vicn/core/collection.py
new file mode 100644
index 00000000..fb222891
--- /dev/null
+++ b/vicn/core/collection.py
@@ -0,0 +1,23 @@
+#!/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.
+#
+
+from vicn.core.sa_collections       import InstrumentedList
+from netmodel.model.collection      import Collection
+
+class Collection(InstrumentedList, Collection):
+    pass
diff --git a/vicn/core/exception.py b/vicn/core/exception.py
index d7422723..977fc8ad 100644
--- a/vicn/core/exception.py
+++ b/vicn/core/exception.py
@@ -37,3 +37,10 @@ class SetupException(VICNException): pass
 class VICNListException(VICNException): pass
 
 class ResourceNotFound(VICNException): pass
+
+class VICNWouldBlock(VICNException):
+    """
+    Exception called when a request would block and the user explicitely
+    required non-blocking behaviour
+    """
+    pass
diff --git a/vicn/core/resource.py b/vicn/core/resource.py
index 9355cd07..ab96daa5 100644
--- a/vicn/core/resource.py
+++ b/vicn/core/resource.py
@@ -27,6 +27,10 @@ import traceback
 import types
 
 from abc                            import ABC, ABCMeta
+from threading                      import Event as ThreadEvent
+
+# LXD workaround
+from pylxd.exceptions import NotFound as LXDAPIException
 
 from netmodel.model.mapper          import ObjectSpecification
 from netmodel.model.type            import String, Bool, Integer, Dict
@@ -35,12 +39,13 @@ from netmodel.util.deprecated       import deprecated
 from netmodel.util.singleton        import Singleton
 from vicn.core.attribute            import Attribute, Multiplicity, Reference
 from vicn.core.attribute            import NEVER_SET
+from vicn.core.collection           import Collection
 from vicn.core.commands             import ReturnValue
 from vicn.core.event                import Event, AttributeChangedEvent
 from vicn.core.exception            import VICNException, ResourceNotFound
+from vicn.core.exception            import VICNWouldBlock
 from vicn.core.resource_factory     import ResourceFactory
 from vicn.core.requirement          import Requirement, Property
-from vicn.core.sa_collections       import InstrumentedList, _list_decorators
 from vicn.core.scheduling_algebra   import SchedulingAlgebra
 from vicn.core.state                import ResourceState, UUID
 from vicn.core.state                import Operations, InstanceState
@@ -95,12 +100,24 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
     The base Resource class implements all the logic related to resource
     instances.
-    
-    See also : 
+
+    See also :
      * ResourceManager : logic related to class instanciation
      * Resource metaclass : logic related to class construction
      * ResourceFactory : logic related to available classes and mapping from
         name to type
+
+    Internal attributes:
+
+     -  _reverse_attributes: a dict mapping attribute objects with the class
+        that declared the reverse attribute.
+
+        For instance, a Group declares a collection of Resource objects through
+        its resources attributes. It also mentions a reverse attribute named
+        'groups'. This means every Resource class will be equipped with a
+        groups attribute, being a collection of Group objects.
+
+        Resource._reverse_attributes = { <Attribute: groups> : Resource }
     """
 
     __type__ = TopLevelResource
@@ -139,7 +156,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
         # Cache dependencies
         self._deps = None
-        
+
         # Internal data tag for resources
         self._internal_data = dict()
 
@@ -168,7 +185,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                         else:
                             resource = x
                         if not resource:
-                            raise VICNException(E_UNK_RES_NAME.format(key, 
+                            raise VICNException(E_UNK_RES_NAME.format(key,
                                         self.name, self.__class__.__name__, x))
                         element = resource if isinstance(resource, Reference) \
                                 else resource._state.uuid
@@ -176,13 +193,13 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                     value = new_value
                 else:
                     if isinstance(value, str):
-                        resource = ResourceManager().by_name(value) 
+                        resource = ResourceManager().by_name(value)
                     elif isinstance(value, UUID):
-                        resource = ResourceManager().by_uuid(value) 
+                        resource = ResourceManager().by_uuid(value)
                     else:
                         resource = value
                     if not resource:
-                        raise VICNException(E_UNK_RES_NAME.format(key, 
+                        raise VICNException(E_UNK_RES_NAME.format(key,
                                     self.name, self.__class__.__name__, value))
                     value = value if isinstance(resource, Reference) \
                             else resource._state.uuid
@@ -202,7 +219,6 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                 default = self.get_default_collection(attr) if attr.is_collection else \
                         self.get_default(attr)
                 if vars(attr)['default'] != NEVER_SET:
-                    #import pdb; pdb.set_trace()
                     self.set(attr.name, default, blocking=False)
             if issubclass(attr.type, Resource) and attr.requirements:
                 for req in attr.requirements:
@@ -218,7 +234,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
     def __after_init__(self):
         return tuple()
- 
+
     def __subresources__(self):
         return None
 
@@ -248,8 +264,8 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
         attribute = self.get_attribute(attribute_name)
 
-        # Handling Lambda attributes
         if hasattr(attribute, 'func') and attribute.func:
+            # Handling Lambda attributes
             value = attribute.func(self)
         else:
             if self.is_local_attribute(attribute.name):
@@ -266,25 +282,44 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
         if value is NEVER_SET:
             if not allow_never_set:
-                log.error(E_GET_NON_LOCAL.format(attribute_name, 
+                log.error(E_GET_NON_LOCAL.format(attribute_name,
                             self._state.uuid))
                 raise NotImplementedError
 
-            if attribute.is_collection:
-                value = self.get_default_collection(attribute)
-            else:
-                if attribute.auto:
-                    # Automatic instanciation
-                    if attribute.requirements:
-                        log.warning('Ignored requirements {}'.format(
-                                    attribute.requirements))
-                    value = self.auto_instanciate(attribute)
-
-                if value is NEVER_SET:
-                    value = self.get_default(attribute)
-
-            if self.is_local_attribute(attribute.name):
-                self.set(attribute.name, value)
+            # node.routing_table is local and auto, so this needs to be tested first...
+            if attribute.auto:
+                # Automatic instanciation
+                #
+                # Used for instance in route.node.routing_table.routes
+                if attribute.requirements:
+                    log.warning('Ignored requirements {}'.format(
+                                attribute.requirements))
+                value = self.auto_instanciate(attribute)
+
+            if value is NEVER_SET:
+                if self.is_local_attribute(attribute.name):
+                    if attribute.is_collection:
+                        value = self.get_default_collection(attribute)
+                    else:
+                        value = self.get_default(attribute)
+                    self.set(attribute.name, value)
+                else:
+                    log.info("Fetching remote value for {}.{}".format(self,attribute.name))
+                    task = getattr(self, "_get_{}".format(attribute.name))()
+                    #XXX This is ugly but it prevents the LxdNotFound exception
+                    while True:
+                        try:
+                            rv = task.execute_blocking()
+                            break
+                        except LxdAPIException:
+                            log.warning("LxdAPIException, retrying to fetch value")
+                            continue
+                        except Exception as e:
+                            import traceback; traceback.print_tb(e.__traceback__)
+                            log.error("Failed to retrieve remote value for {} on {}".format(attribute.name, self))
+                            import os; os._exit(1)
+                    value = rv[attribute.name]
+                    vars(self)[attribute.name] = value
 
         if unref and isinstance(value, UUID):
             value = self.from_uuid(value)
@@ -297,6 +332,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
         return value
 
+    # XXX async_get should not be blocking
     async def async_get(self, attribute_name, default=NEVER_SET, unref=True,
             resolve=True, allow_never_set=False, blocking=True):
         attribute = self.get_attribute(attribute_name)
@@ -318,14 +354,14 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                     # exists
                     value = vars(self).get(attribute.name, NEVER_SET)
                     if value is NEVER_SET:
-                        await self._state.manager.attribute_get(self, 
+                        await self._state.manager.attribute_get(self,
                                 attribute_name, value)
                         value = vars(self).get(attribute.name, NEVER_SET)
 
         # Handling NEVER_SET
         if value is NEVER_SET:
             if not allow_never_set:
-                log.error(E_GET_NON_LOCAL.format(attribute_name, 
+                log.error(E_GET_NON_LOCAL.format(attribute_name,
                             self._state.uuid))
                 raise NotImplementedError
 
@@ -366,27 +402,19 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         """
         attribute = self.get_attribute(attribute_name)
 
-        if set_reverse and attribute.reverse_name: 
+        # Let's transform value if not in the proper format
+        if attribute.is_collection and not isinstance(value, Collection):
+            value = Collection.from_list(value, self, attribute)
+        else:
+            if isinstance(value, UUID):
+                value = self.from_uuid(value)
+
+        if set_reverse and attribute.reverse_name:
             for base in self.__class__.mro():
                 if not hasattr(base, '_reverse_attributes'):
                     continue
 
                 for ra in base._reverse_attributes.get(attribute, list()):
-                    # Value information : we need resources, not uuids
-                    if attribute.is_collection:
-                        lst = list()
-                        if value:
-                            for x in value:
-                                if isinstance(x, UUID):
-                                    x = self.from_uuid(x)
-                                lst.append(x)
-                        value = InstrumentedList(lst)
-                        value._attribute = attribute
-                        value._instance = self
-                    else:
-                        if isinstance(value, UUID):
-                            value = self.from_uuid(value)
-
                     if ra.multiplicity == Multiplicity.OneToOne:
                         if value is not None:
                             value.set(ra.name, self, set_reverse = False)
@@ -400,30 +428,23 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                         else:
                             value is None
                     elif ra.multiplicity == Multiplicity.ManyToMany:
-                        collection = value.get(ra.name)
-                        value.extend(self)
-
-        # Handling value : we need uuids, not resources
-        if attribute.is_collection:
-            if not isinstance(value, InstrumentedList):
-                lst = list()
-                if value:
-                    for x in value:
-                        if isinstance(x, Resource):
-                            x = x.get_uuid()
-                        lst.append(x)
-
-                    value = InstrumentedList(lst)
-                else: 
-                    value = InstrumentedList([])
-                value._attribute = attribute
-                value._instance = self
-        else:
-            if isinstance(value, Resource):
-                value = value.get_uuid()
+                        # Example:
+                        # _set(self, attribute_name)
+                        # self = Resource()
+                        # attribute_name = <Attribute groups>
+                        # value = <Collection 140052309461896 [<Group: topology resources=[], name=topology, owner=None, managed=True>]>
+                        # element = <Group: ...>
+
+                        # We add each element of the collection to the remote
+                        # attribute which is also a collection
+                        for element in value:
+                            collection = element.get(ra.name)
+                            # XXX duplicates ?
+                            collection.append(self)
+
         return value
 
-    def set(self, attribute_name, value, current=False, set_reverse=True, 
+    def set(self, attribute_name, value, current=False, set_reverse=True,
             blocking = True):
         value = self._set(attribute_name, value, current=current,
                 set_reverse=set_reverse)
@@ -479,14 +500,11 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
             if attribute.default._resource is Self:
                 default = getattr(self, attribute.default._attribute)
             else:
-                default = getattr(attribute.default._resource, 
+                default = getattr(attribute.default._resource,
                         attribute.default._attribute)
         else:
             default = attribute.default
-        value = InstrumentedList(default)
-        value._attribute = attribute
-        value._instance = self
-        return value
+        return Collection.from_list(default, self, attribute)
 
     def get_default(self, attribute):
         if isinstance(attribute.default, types.FunctionType):
@@ -495,7 +513,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
             if attribute.default._resource is Self:
                 value = getattr(self, attribute.default._attribute)
             else:
-                value = getattr(attribute.default._resource, 
+                value = getattr(attribute.default._resource,
                         attribute.default._attribute)
         else:
             value = copy.deepcopy(attribute.default)
@@ -525,17 +543,22 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
     @classmethod
     def _sanitize(cls):
-        """Sanitize the object model to accomodate for multiple declaration
-            styles
+        """
+        This methods performs sanitization of the object declaration.
+
+        More specifically:
+         - it goes over all attributes and sets their name based on the python
+           object attribute name.
+         - it establishes mutual object relationships through reverse attributes.
 
-        In particular, this method:
-          - set names to all attributes
         """
         cls._reverse_attributes = dict()
         cur_reverse_attributes = dict()
         for name, obj in vars(cls).items():
             if not isinstance(obj, ObjectSpecification):
                 continue
+
+            # XXX it seems obj should always be an attribute, confirm !
             if isinstance(obj, Attribute):
                 obj.name = name
 
@@ -555,23 +578,62 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
             #
             # NOTE: we need to do this after merging to be sure we get all
             #   properties inherited from parent (eg. multiplicity)
+            #
+            # See "Reverse attributes" section in BaseResource docstring.
+            #
+            # Continueing with the same example, let's detail how it is handled:
+            #
+            # Original declaration:
+            # >>>
+            # class Group(Resource):
+            #     resources = Attribute(Resource, description = 'Resources belonging to the group',
+            # 	    multiplicity = Multiplicity.ManyToMany,
+            #             default = [],
+            #             reverse_name = 'groups',
+            #             reverse_description = 'Groups to which the resource belongs')
+            # <<<
+            #
+            # Local variables:
+            #   cls = <class 'vicn.resource.group.Group'>
+            #   obj = <Attribute resources>
+            #   obj.type = <class 'vicn.core.Resource'>
+            #   reverse_attribute = <Attribute groups>
+            #
+            # Result:
+            #    1) Group._reverse_attributes =
+            #       { <Attribute resources> : [<Attribute groups>, ...], ...}
+            #    2) Add attribute <Attribute groups> to class Resource
+            #    3) Resource._reverse_attributes =
+            #       { <Attribute groups> : [<Attribute resources], ...], ...}
+            #
             if has_reverse:
                 a = {
-                    'name'          : obj.reverse_name,
-                    'description'   : obj.reverse_description,
-                    'multiplicity'  : Multiplicity.reverse(obj.multiplicity),
-                    'auto'          : obj.reverse_auto,
+                    'name'                  : obj.reverse_name,
+                    'description'           : obj.reverse_description,
+                    'multiplicity'          : Multiplicity.reverse(obj.multiplicity),
+                    'reverse_name'          : obj.name,
+                    'reverse_description'   : obj.description,
+                    'auto'                  : obj.reverse_auto,
                 }
                 reverse_attribute = Attribute(cls,  **a)
                 reverse_attribute.is_aggregate = True
 
+                # 1) Store the reverse attributes to be later inserted in the
+                # remote class, at the end of the function
+                # TODO : clarify the reasons to perform this in two steps
                 cur_reverse_attributes[obj.type] = reverse_attribute
 
-                #print('*** class backref ***', cls, obj, reverse_attribute)
+                # 2)
                 if not obj in cls._reverse_attributes:
                     cls._reverse_attributes[obj] = list()
                 cls._reverse_attributes[obj].append(reverse_attribute)
 
+                # 3)
+                if not reverse_attribute in obj.type._reverse_attributes:
+                    obj.type._reverse_attributes[reverse_attribute] = list()
+                obj.type._reverse_attributes[reverse_attribute].append(obj)
+
+        # Insert newly created reverse attributes in the remote class
         for kls, a in cur_reverse_attributes.items():
             setattr(kls, a.name, a)
 
@@ -583,7 +645,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                 continue
             if attribute.is_aggregate and not aggregates:
                 continue
-                
+
             yield attribute
 
     def iter_keys(self):
@@ -617,7 +679,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         for req in reqs:
             if req._type != attribute.name:
                 continue
-                
+
             for attr_name, prop in req.properties.items():
                 value = next(iter(prop.value))
             capabilities |= req._capabilities
@@ -626,7 +688,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         cls = self._state.manager.get_resource_with_capabilities(
                 attribute.type, capabilities)
 
-        # Before creating a new instance of a class, let's check 
+        # Before creating a new instance of a class, let's check
         resource = cls(**cstr_attributes)
 
         self._state.manager.commit_resource(resource)
@@ -636,10 +698,10 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         return list(self.iter_attributes(aggregates = aggregates))
 
     def get_attribute_names(self, aggregates = False):
-        return set(a.name 
+        return set(a.name
                 for a in self.iter_attributes(aggregates = aggregates))
 
-    def get_attribute_dict(self, field_names = None, aggregates = False, 
+    def get_attribute_dict(self, field_names = None, aggregates = False,
             uuid = True):
         assert not field_names or field_names.is_star()
         attributes = self.get_attributes(aggregates = aggregates)
@@ -653,11 +715,11 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                 ret[a.name] = list()
                 for x in value:
                     if uuid and isinstance(x, Resource):
-                        x = x._state.uuid._uuid 
+                        x = x._state.uuid._uuid
                     ret[a.name].append(x)
             else:
                 if uuid and isinstance(value, Resource):
-                    value = value._state.uuid._uuid 
+                    value = value._state.uuid._uuid
                 ret[a.name] = value
         return ret
 
@@ -673,7 +735,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         self._state.state = state
 
     def get_types(self):
-        return [cls.__name__.lower() for cls in self.__class__.mro() 
+        return [cls.__name__.lower() for cls in self.__class__.mro()
                 if cls.__name__ not in ('ABC', 'BaseType', 'object')]
 
     def get_type(self):
@@ -686,12 +748,20 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         # Showing aggregate attributes can cause infinite loops
         name = self._state.uuid if self.name in (None, NEVER_SET) else self.name
         return '<{}: {} {}>'.format(self.__class__.__name__, name,
-                ', '.join('{}={}'.format(k,v) 
-                    for k, v in self.get_attribute_dict().items())) 
+                ', '.join('{}={}'.format(k,v)
+                    for k, v in self.get_attribute_dict().items()))
 
     def __str__(self):
         return self.__repr__()
 
+    def to_dict(self):
+        dic = self.get_attribute_dict(aggregates = True)
+        dic['id']    = self._state.uuid._uuid
+        dic['type']  = self.get_types()
+        dic['state'] = self._state.state
+        dic['log']   = self._state.log
+        return dic
+
     #---------------------------------------------------------------------------
     # Resource helpers
     #---------------------------------------------------------------------------
@@ -709,7 +779,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
                 if not value:
                     continue
 
-                if a.multiplicity in (Multiplicity.OneToOne, 
+                if a.multiplicity in (Multiplicity.OneToOne,
                         Multiplicity.ManyToOne):
                     resource = value
                     if not resource:
@@ -742,13 +812,12 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         l.extend(list(args))
         if id:
             N = 3
-            uuid = ''.join(random.choice(string.ascii_uppercase + 
+            uuid = ''.join(random.choice(string.ascii_uppercase +
                         string.digits) for _ in range(N))
             l.append(uuid)
         name = NAME_SEP.join(str(x) for x in l)
         return name
 
-    
     def check_requirements(self):
         for attr in self.iter_attributes():
             if issubclass(attr.type, Resource) and attr.requirements:
@@ -762,7 +831,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
 
     @deprecated
     def trigger(self, action, attribute_name, *args, **kwargs):
-        self._state.manager.trigger(self, action, attribute_name, 
+        self._state.manager.trigger(self, action, attribute_name,
                 *args, **kwargs)
 
     #--------------------------------------------------------------------------
@@ -816,7 +885,7 @@ class BaseResource(BaseType, ABC, metaclass=ResourceMetaclass):
         return hasattr(self, '_{}_{}'.format(action, attribute.name))
 
     def is_setup(self):
-        return self.state in (ResourceState.SETUP_PENDING, 
+        return self.state in (ResourceState.SETUP_PENDING,
                 ResourceState.SETUP, ResourceState.DIRTY)
 
     __get__ = None
@@ -851,7 +920,7 @@ class CompositionMixin:
             await element._state.clean.wait()
         self._state.clean.set()
 
-_Resource, EmptyResource = SchedulingAlgebra(BaseResource, ConcurrentMixin, 
+_Resource, EmptyResource = SchedulingAlgebra(BaseResource, ConcurrentMixin,
         CompositionMixin, SequentialMixin)
 
 class ManagedResource(_Resource):
diff --git a/vicn/core/resource_mgr.py b/vicn/core/resource_mgr.py
index c6ce77ab..4ca8060c 100644
--- a/vicn/core/resource_mgr.py
+++ b/vicn/core/resource_mgr.py
@@ -288,6 +288,7 @@ class ResourceManager(metaclass=Singleton):
 
     def create_from_dict(self, **resource):
         resource_type = resource.pop('type', None)
+
         assert resource_type
 
         return self.create(resource_type.lower(), **resource)
@@ -354,6 +355,21 @@ class ResourceManager(metaclass=Singleton):
         if commit:
             self.commit()
 
+    def teardown(self):
+        asyncio.ensure_future(self._teardown())
+
+    async def _teardown(self):
+        task = EmptyTask()
+        # XXX we should never have to autoinstanciate
+        # XXX why keeping this code
+        for resource in self.get_resources():
+            if resource.get_type() == 'lxccontainer':
+                task = task | resource.__delete__()
+                print("RESOURCE", resource.name)
+        self.schedule(task)
+        ret = await wait_task(task)
+        return ret
+
     def get_resource_with_capabilities(self, cls, capabilities):
         if '__type__' in cls.__dict__ and cls.__type__ == FactoryResource:
             candidates = inheritors(cls)
@@ -806,7 +822,10 @@ class ResourceManager(metaclass=Singleton):
                     resource._state.attr_change_success[attribute.name] = True
                 else:
                     log.error('Attribute error {} for resource {}'.format(
-                            resource.get_uuid(), attribute.name))
+                        attribute.name, resource.get_uuid()))
+                    print("task1=", task)
+                    sys.stdout.flush()
+
                     import traceback; traceback.print_tb(e.__traceback__)
                     log.error('Failed with exception: {}'.format(e))
                     import os; os._exit(1)
@@ -931,10 +950,13 @@ class ResourceManager(metaclass=Singleton):
                         resource._state.attr_change_success[attribute.name] = True
                     else:
                         log.error('Attribute error {} for resource {}'.format(
-                                resource.get_uuid(), attribute.name))
+                            attribute.name, resource.get_uuid()))
+                        # XXX need better logging
+                        print("task2=", task._node.name, task.get_full_cmd())
+                        sys.stdout.flush()
                         e = resource._state.attr_change_value[attribute.name]
-                        new_state = AttributeState.ERROR
                         import traceback; traceback.print_tb(e.__traceback__)
+                        new_state = AttributeState.ERROR
                         import os; os._exit(1)
 
             else:
@@ -956,9 +978,10 @@ class ResourceManager(metaclass=Singleton):
         return Query.from_dict(dic)
 
     def _monitor_netmon(self, resource):
-        ip = resource.node.host_interface.ip4_address
+        ip = resource.node.management_interface.ip4_address
         if not ip:
-            log.error('IP of monitored Node is None')
+            log.error('IP of monitored Node {} is None'.format(resource.node))
+            #return # XXX
             import os; os._exit(1)
 
         ws = self._router.add_interface('websocketclient', address=ip,
@@ -1009,7 +1032,7 @@ class ResourceManager(metaclass=Singleton):
 
     def _monitor_emulator(self, resource):
         ns = resource
-        ip = ns.node.bridge.ip4_address # host_interface.ip_address
+        ip = ns.node.bridge.ip4_address # management_interface.ip_address
 
         ws_ns = self._router.add_interface('websocketclient', address = ip,
                 port = ns.control_port,
@@ -1252,7 +1275,13 @@ class ResourceManager(metaclass=Singleton):
                 state = resource._state.state
                 self.log(resource, 'Current state is {}'.format(state))
 
-                if state == ResourceState.UNINITIALIZED:
+                if state == ResourceState.ERROR:
+                    e = resource._state.change_value
+                    print("------")
+                    import traceback; traceback.print_tb(e.__traceback__)
+                    log.error('Resource: {} - Exception: {}'.format(pfx, e))
+                    import os; os._exit(1)
+                elif state == ResourceState.UNINITIALIZED:
                     pending_state = ResourceState.PENDING_DEPS
                 elif state == ResourceState.DEPS_OK:
                     pending_state = ResourceState.PENDING_INIT
@@ -1379,24 +1408,26 @@ class ResourceManager(metaclass=Singleton):
                         # with container.execute(), not container.get()
                         log.warning('LXD Fix (not found). Reset resource')
                         new_state = ResourceState.INITIALIZED
+                        resource._state.change_success = True
                     elif ENABLE_LXD_WORKAROUND and isinstance(e, LXDAPIException):
                         # "not found" is the normal exception when the container
                         # does not exists. anyways the bug should only occur
                         # with container.execute(), not container.get()
                         log.warning('LXD Fix (API error). Reset resource')
                         new_state = ResourceState.INITIALIZED
+                        resource._state.change_success = True
                     elif isinstance(e, ResourceNotFound):
                         # The resource does not exist
                         self.log(resource, S_GET_DONE.format(
                                     resource._state.change_value))
                         new_state = ResourceState.GET_DONE
                         resource._state.change_value = None
+                        resource._state.change_success = True
                     else:
                         e = resource._state.change_value
                         log.error('Cannot get resource state {} : {}'.format(
                                     resource.get_uuid(), e))
                         new_state = ResourceState.ERROR
-                    resource._state.change_success = True
 
             elif pending_state == ResourceState.PENDING_KEYS:
                 if resource._state.change_success == True:
@@ -1442,10 +1473,7 @@ class ResourceManager(metaclass=Singleton):
                         resource._state.change_success = True
                     else:
                         self.log(resource, 'CREATE failed: {}'.format(e))
-                        e = resource._state.change_value
-                        import traceback; traceback.print_tb(e.__traceback__)
-                        log.error('Failed with exception {}'.format(e))
-                        import os; os._exit(1)
+                        new_state = ResourceState.ERROR
 
             elif pending_state == ResourceState.PENDING_UPDATE:
                 if resource._state.change_success == True:
@@ -1462,11 +1490,8 @@ class ResourceManager(metaclass=Singleton):
                         resource._state.change_success = True
                         resource._state.write_lock.release()
                     else:
-                        e = resource._state.change_value
                         resource._state.write_lock.release()
-                        import traceback; traceback.print_tb(e.__traceback__)
-                        log.error('Failed with exception {}'.format(e))
-                        import os; os._exit(1)
+                        new_state = ResourceState.ERROR
 
             elif pending_state == ResourceState.PENDING_DELETE:
                 raise NotImplementedError
@@ -1475,4 +1500,3 @@ class ResourceManager(metaclass=Singleton):
                 raise RuntimeError
 
             await self._set_resource_state(resource, new_state)
-
diff --git a/vicn/core/sa_collections.py b/vicn/core/sa_collections.py
index e627caa5..a4a24f85 100644
--- a/vicn/core/sa_collections.py
+++ b/vicn/core/sa_collections.py
@@ -12,8 +12,9 @@
 
 import logging
 
-from vicn.core.sa_compat    import py2k
 from vicn.core.exception    import VICNListException
+from vicn.core.sa_compat    import py2k
+from vicn.core.state        import UUID
 
 log = logging.getLogger(__name__)
 
@@ -29,7 +30,7 @@ def _list_decorators():
             try:
                 item = self._attribute.do_list_add(self._instance, item)
                 fn(self, item)
-            except VICNListException as e: 
+            except VICNListException as e:
                 pass
         _tidy(append)
         return append
@@ -121,7 +122,7 @@ def _list_decorators():
                     try:
                         self._attribute.do_list_remove(self._instance, item)
                     except : has_except = True
-                if not has_except: 
+                if not has_except:
                     fn(self, index)
         _tidy(__delitem__)
         return __delitem__
@@ -180,7 +181,7 @@ def _list_decorators():
                 self._attribute.do_list_remove(self._instance, item)
                 item = fn(self, index)
                 return item
-            except : return None 
+            except : return None
         _tidy(pop)
         return pop
 
@@ -230,13 +231,27 @@ def _instrument_list(cls):
     # inspired by sqlalchemy
     for method, decorator in _list_decorators().items():
         fn = getattr(cls, method, None)
-        if fn:	
+        if fn:
             #if (fn and method not in methods and
             #        not hasattr(fn, '_sa_instrumented')):
             setattr(cls, method, decorator(fn))
 
 class InstrumentedList(list):
 
+    @classmethod
+    def from_list(cls, value, instance, attribute):
+        lst = list()
+        if value:
+            for x in value:
+                if isinstance(x, UUID):
+                    x = instance.from_uuid(x)
+                lst.append(x)
+        # Having a class method is important for inheritance
+        value = cls(lst)
+        value._attribute = attribute
+        value._instance = instance
+        return value
+
     def __contains__(self, key):
         from vicn.core.resource import Resource
         if isinstance(key, Resource):
diff --git a/vicn/core/state.py b/vicn/core/state.py
index bb108b2b..81876790 100644
--- a/vicn/core/state.py
+++ b/vicn/core/state.py
@@ -75,7 +75,7 @@ class UUID:
         random identifier of length UUID_LEN. Components of the UUID are
         separated by UUID_SEP.
         """
-        uuid = ''.join(random.choice(string.ascii_uppercase + string.digits) 
+        uuid = ''.join(random.choice(string.ascii_uppercase + string.digits)
                 for _ in range(UUID_LEN))
         if name:
             uuid = name # + UUID_SEP + uuid
@@ -105,7 +105,7 @@ class PendingValue:
 
         if action == Operations.SET:
             self.value = value
-            self.operations = [(Operations.SET, value)] 
+            self.operations = [(Operations.SET, value)]
         elif action == Operations.LIST_CLEAR:
             self.value = list()
             self.operations = [(Operations.LIST_CLEAR, None)]
@@ -136,9 +136,8 @@ class InstanceState:
         # LIST set add remove clear
         self.dirty          = dict()
 
-
         # Initialize resource state
-        self.lock = asyncio.Lock() 
+        self.lock = asyncio.Lock()
         self.write_lock = asyncio.Lock()
         self.state          = ResourceState.UNINITIALIZED
         self.clean = asyncio.Event()
@@ -161,7 +160,7 @@ class InstanceState:
         self.attr_log = dict()
         # Initialize attribute state
         for attribute in instance.iter_attributes():
-            self.attr_lock[attribute.name] = asyncio.Lock() 
+            self.attr_lock[attribute.name] = asyncio.Lock()
             self.attr_init[attribute.name] = asyncio.Event()
             self.attr_clean[attribute.name] = asyncio.Event()
             self.attr_state[attribute.name] = AttributeState.UNINITIALIZED
diff --git a/vicn/core/task.py b/vicn/core/task.py
index 53321972..8346c65e 100644
--- a/vicn/core/task.py
+++ b/vicn/core/task.py
@@ -219,6 +219,14 @@ class PythonTask(Task):
         fut = loop.run_in_executor(None, partial)
         fut.add_done_callback(self._done_callback)
 
+    def execute_blocking(self, *args, **kwargs):
+        all_args = self._args + args
+        all_kwargs = dict()
+        all_kwargs.update(self._kwargs)
+        all_kwargs.update(kwargs)
+
+        return self._func(*all_args, **all_kwargs)
+
     def __repr__(self):
         s = _get_func_desc(self._func)
         return '<Task[py] {}>'.format(s) if s else '<Task[py]>'
diff --git a/vicn/resource/central.py b/vicn/resource/central.py
index 1013d1a5..09b24184 100644
--- a/vicn/resource/central.py
+++ b/vicn/resource/central.py
@@ -22,13 +22,14 @@ import os
 
 from netmodel.model.type                import String
 from netmodel.util.misc                 import pairwise
-from vicn.core.attribute                import Attribute
+from vicn.core.attribute                import Attribute, Reference
 from vicn.core.exception                import ResourceNotFound
 from vicn.core.resource                 import Resource
 from vicn.core.task                     import async_task, inline_task
 from vicn.core.task                     import EmptyTask, BashTask
 from vicn.resource.channel              import Channel
 from vicn.resource.ip.route             import IPRoute
+from vicn.resource.group                import Group
 from vicn.resource.icn.forwarder        import Forwarder
 from vicn.resource.icn.face             import L2Face, L4Face, FaceProtocol
 from vicn.resource.icn.producer         import Producer
@@ -148,60 +149,63 @@ MAP_ROUTING_STRATEGY = {
 # L2 and L4/ICN graphs
 #------------------------------------------------------------------------------
 
-def _get_l2_graph(manager, with_managed = False):
+def _get_l2_graph(groups, with_managed = False):
     G = nx.Graph()
-    for node in manager.by_type(Node):
-        G.add_node(node._state.uuid)
-
-    for channel in manager.by_type(Channel):
-        if channel.has_type('emulatedchannel'):
-            src = channel._ap_if
-            for dst in channel._sta_ifs.values():
-                if not with_managed and (not src.managed or not dst.managed):
-                    continue
-                if G.has_edge(src.node._state.uuid, dst.node._state.uuid):
-                    continue
-
-                map_node_interface = { src.node._state.uuid : src._state.uuid,
-                    dst.node._state.uuid: dst._state.uuid}
-                G.add_edge(src.node._state.uuid, dst.node._state.uuid,
-                        map_node_interface = map_node_interface)
-        else:
-            # This is for a normal Channel
-            for src_it in range(0,len(channel.interfaces)):
-                src = channel.interfaces[src_it]
-
-                # Iterate over the remaining interface to create all the
-                # possible combination
-                for dst_it in range(src_it+1,len(channel.interfaces)):
-                    dst = channel.interfaces[dst_it]
-
-                    if not with_managed and (not src.managed or
-                            not dst.managed):
+#    for node in manager.by_type(Node):
+#        G.add_node(node._state.uuid)
+
+    for group in groups:
+        for channel in group.iter_by_type_str('channel'):
+            if channel.has_type('emulatedchannel'):
+                src = channel._ap_if
+                for dst in channel._sta_ifs.values():
+                    if not with_managed and (not src.managed or not dst.managed):
                         continue
                     if G.has_edge(src.node._state.uuid, dst.node._state.uuid):
                         continue
-                    map_node_interface = {
-                        src.node._state.uuid : src._state.uuid,
+
+                    map_node_interface = { src.node._state.uuid : src._state.uuid,
                         dst.node._state.uuid: dst._state.uuid}
                     G.add_edge(src.node._state.uuid, dst.node._state.uuid,
                             map_node_interface = map_node_interface)
+            else:
+                # This is for a normal Channel
+                for src_it in range(0, len(channel.interfaces)):
+                    src = channel.interfaces[src_it]
+
+                    # Iterate over the remaining interface to create all the
+                    # possible combination
+                    for dst_it in range(src_it+1,len(channel.interfaces)):
+                        dst = channel.interfaces[dst_it]
+
+                        if not with_managed and (not src.managed or
+                                not dst.managed):
+                            continue
+                        if G.has_edge(src.node._state.uuid, dst.node._state.uuid):
+                            continue
+                        map_node_interface = {
+                            src.node._state.uuid : src._state.uuid,
+                            dst.node._state.uuid: dst._state.uuid}
+                        G.add_edge(src.node._state.uuid, dst.node._state.uuid,
+                                map_node_interface = map_node_interface)
     return G
 
-def _get_icn_graph(manager):
+def _get_icn_graph(manager, groups):
     G = nx.Graph()
-    for forwarder in manager.by_type(Forwarder):
-        node = forwarder.node
-        G.add_node(node._state.uuid)
-        for face in forwarder.faces:
-            other_face = manager.by_uuid(face._internal_data['sibling_face'])
-            other_node = other_face.node
-            if G.has_edge(node._state.uuid, other_node._state.uuid):
-                continue
-            map_node_face = { node._state.uuid: face._state.uuid,
-                other_node._state.uuid: other_face._state.uuid }
-            G.add_edge(node._state.uuid, other_node._state.uuid,
-                    map_node_face = map_node_face)
+    for group in groups:
+        # It's safer to iterate on node which we know are in the right groups,
+        # while it might not be the case for the forwarders...
+        for node in group.iter_by_type_str('node'):
+            G.add_node(node._state.uuid)
+            for face in node.forwarder.faces:
+                other_face = manager.by_uuid(face._internal_data['sibling_face'])
+                other_node = other_face.node
+                if G.has_edge(node._state.uuid, other_node._state.uuid):
+                    continue
+                map_node_face = { node._state.uuid: face._state.uuid,
+                    other_node._state.uuid: other_face._state.uuid }
+                G.add_edge(node._state.uuid, other_node._state.uuid,
+                        map_node_face = map_node_face)
 
     return G
 
@@ -241,14 +245,18 @@ class IPRoutes(Resource):
 
     def _get_ip_origins(self):
         origins = dict()
-        for node in self._state.manager.by_type(Node):
-            node_uuid = node._state.uuid
-            if not node_uuid in origins:
-                origins[node_uuid] = list()
-            for interface in node.interfaces:
-                origins[node_uuid].append(interface.ip4_address)
-                if interface.ip6_address: #Control interfaces have no v6 address
-                    origins[node_uuid].append(interface.ip6_address)
+        for group in self.groups:
+            for node in group.iter_by_type_str('node'):
+                node_uuid = node._state.uuid
+                if not node_uuid in origins:
+                    origins[node_uuid] = list()
+                for interface in node.interfaces:
+                    # XXX temp fix (WouldBlock)
+                    try:
+                        origins[node_uuid].append(interface.ip4_address)
+                        if interface.ip6_address: #Control interfaces have no v6 address
+                            origins[node_uuid].append(interface.ip6_address)
+                    except: pass
         return origins
 
     def _get_ip_routes(self):
@@ -257,7 +265,7 @@ class IPRoutes(Resource):
 
         strategy = MAP_ROUTING_STRATEGY.get(self.routing_strategy)
 
-        G = _get_l2_graph(self._state.manager)
+        G = _get_l2_graph(self.groups)
         origins = self._get_ip_origins()
 
         # node -> list(origins for which we have routes)
@@ -294,7 +302,7 @@ class IPRoutes(Resource):
             if prefix == next_hop_ingress_ip:
                 # Direct route on src_node.name :
                 # route add [prefix] dev [next_hop_interface_.device_name]
-                route4 = IPRoute(node     = src_node,
+                route = IPRoute(node     = src_node,
                                 managed    = False,
                                 owner      = self,
                                 ip_address = prefix,
@@ -334,7 +342,7 @@ class IPRoutes(Resource):
         IP routing strategy : direct routes only
         """
         routes = list()
-        G = _get_l2_graph(self._state.manager)
+        G = _get_l2_graph(self.groups)
         for src_node_uuid, dst_node_uuid, data in G.edges_iter(data = True):
             src_node = self._state.manager.by_uuid(src_node_uuid)
             dst_node = self._state.manager.by_uuid(dst_node_uuid)
@@ -424,7 +432,7 @@ class ICNFaces(Resource):
         protocol = FaceProtocol.from_string(self.protocol_name)
 
         faces = list()
-        G = _get_l2_graph(self._state.manager)
+        G = _get_l2_graph(self.groups)
         for src_node_uuid, dst_node_uuid, data in G.edges_iter(data = True):
             src_node = self._state.manager.by_uuid(src_node_uuid)
             dst_node = self._state.manager.by_uuid(dst_node_uuid)
@@ -436,14 +444,16 @@ class ICNFaces(Resource):
             log.debug('{} -> {} ({} -> {})'.format(src_node_uuid,
                         dst_node_uuid, src.device_name, dst.device_name))
 
+            # XXX This should be moved to the various faces, that register to a
+            # factory
             if protocol == FaceProtocol.ether:
                 src_face = L2Face(node        = src_node,
-                                  owner      = self,
+                                  owner       = self,
                                   protocol    = protocol,
                                   src_nic     = src,
                                   dst_mac     = dst.mac_address)
                 dst_face = L2Face(node        = dst_node,
-                                  owner      = self,
+                                  owner       = self,
                                   protocol    = protocol,
                                   src_nic     = dst,
                                   dst_mac     = src.mac_address)
@@ -451,14 +461,14 @@ class ICNFaces(Resource):
             elif protocol in (FaceProtocol.tcp4, FaceProtocol.tcp6,
                     FaceProtocol.udp4, FaceProtocol.udp6):
                 src_face = L4Face(node        = src_node,
-                                  owner      = self,
+                                  owner       = self,
                                   protocol    = protocol,
                                   src_ip      = src.ip4_address,
                                   dst_ip      = dst.ip4_address,
                                   src_port    = TMP_DEFAULT_PORT,
                                   dst_port    = TMP_DEFAULT_PORT)
                 dst_face = L4Face(node        = dst_node,
-                                  owner      = self,
+                                  owner       = self,
                                   protocol    = protocol,
                                   src_ip      = dst.ip4_address,
                                   dst_ip      = src.ip4_address,
@@ -510,17 +520,18 @@ class ICNRoutes(Resource):
 
     def _get_prefix_origins(self):
         origins = dict()
-        for producer in self._state.manager.by_type(Producer):
-            node_uuid = producer.node._state.uuid
-            if not node_uuid in origins:
-                origins[node_uuid] = list()
-            origins[node_uuid].extend(producer.prefixes)
+        for group in self.groups:
+            for producer in group.iter_by_type_str('producer'):
+                node_uuid = producer.node._state.uuid
+                if not node_uuid in origins:
+                    origins[node_uuid] = list()
+                origins[node_uuid].extend(producer.prefixes)
         return origins
 
     def _get_icn_routes(self):
         strategy = MAP_ROUTING_STRATEGY.get(self.routing_strategy)
 
-        G = _get_icn_graph(self._state.manager)
+        G = _get_icn_graph(self._state.manager, self.groups)
         origins = self._get_prefix_origins()
 
         routes = list()
@@ -571,104 +582,6 @@ class DnsServerEntry(Resource):
 
 #------------------------------------------------------------------------------
 
-class ContainerSetup(Resource):
-    """
-    Resource: ContainerSetup
-
-    Setup of container networking
-
-    Todo:
-      - This should be merged into the LxcContainer resource
-    """
-
-    container = Attribute(LxcContainer)
-
-    #--------------------------------------------------------------------------
-    # Resource lifecycle
-    #--------------------------------------------------------------------------
-
-    def __subresources__(self):
-
-        dns_server_entry = DnsServerEntry(node = self.container,
-                owner      = self,
-                ip_address = self.container.node.bridge.ip4_address,
-                interface_name = self.container.host_interface.device_name)
-
-        return dns_server_entry
-
-    @inline_task
-    def __get__(self):
-        raise ResourceNotFound
-
-    def __create__(self):
-        #If no IP has been given on the host interface (e.g., through DHCP)
-        #We need to assign one
-        if not self.container.host_interface.ip4_address:
-            # a) get the IP
-            assign=self._state.manager.by_type(Ipv4Assignment)[0]
-            ip4_addr = assign.get_control_address(self.container.host_interface)
-            self.container.host_interface.ip4_address = ip4_addr
-
-
-            # a) routes: host -> container
-            #   . container interfaces
-            #   . container host (main) interface
-            # route add -host {ip_address} dev {bridge_name}
-            route = IPRoute(node       = self.container.node,
-                            managed    = False,
-                            owner      = self,
-                            ip_address = ip4_addr,
-                            interface  = self.container.node.bridge)
-            route.node.routing_table.routes << route
-
-            # b) route: container -> host
-            # route add {ip_gateway} dev {interface_name}
-            # route add default gw {ip_gateway} dev {interface_name}
-            route = IPRoute(node       = self.container,
-                            owner      = self,
-                            managed    = False,
-                            ip_address = self.container.node.bridge.ip4_address,
-                            interface  = self.container.host_interface)
-            route.node.routing_table.routes << route
-            route_gw = IPRoute(node       = self.container,
-                               managed    = False,
-                               owner      = self,
-                               ip_address = 'default',
-                               interface  = self.container.host_interface,
-                               gateway    = self.container.node.bridge.ip4_address)
-            route_gw.node.routing_table.routes << route_gw
-
-
-        return BashTask(self.container.node, CMD_IP_FORWARD)
-
-#------------------------------------------------------------------------------
-
-class ContainersSetup(Resource):
-    """
-    Resource: ContainersSetup
-
-    Setup of LxcContainers (main resource)
-
-    Todo:
-      - This should be merged into the LxcContainer resource
-    """
-
-    #--------------------------------------------------------------------------
-    # Resource lifecycle
-    #--------------------------------------------------------------------------
-
-    def __subresources__(self):
-        containers  = self._state.manager.by_type(LxcContainer)
-        if len(containers) == 0:
-            return None
-
-        container_resources = [ContainerSetup(owner = self, container = c)
-            for c in containers]
-
-        return Resource.__concurrent__(*container_resources)
-
-#------------------------------------------------------------------------------
-
 class CentralIP(Resource):
     """
     Resource: CentralIP
@@ -678,32 +591,31 @@ class CentralIP(Resource):
 
     ip_routing_strategy = Attribute(String, description = 'IP routing strategy',
             default = 'pair') # spt, pair
-    ip6_data_prefix = Attribute(String, description="Prefix for IPv6 forwarding", mandatory=True)
-    ip4_data_prefix = Attribute(String, description="Prefix for IPv4 forwarding", mandatory=True)
-    ip4_control_prefix = Attribute(String, description="Prefix for IPv4 control", mandatory=True)
+    ip6_data_prefix = Attribute(String, description="Prefix for IPv6 forwarding",
+            mandatory = True)
+    ip4_data_prefix = Attribute(String, description="Prefix for IPv4 forwarding",
+            mandatory = True)
 
     #--------------------------------------------------------------------------
     # Resource lifecycle
     #--------------------------------------------------------------------------
 
-    #def __after_init__(self):
-    #    return ('Node', 'Channel', 'Interface')
+    def __after_init__(self):
+        return ('Node', 'Channel', 'Interface')
+
+    def __after__(self):
+        return ('EmulatedChannel')
 
     def __subresources__(self):
-        ip4_assign = Ipv4Assignment(prefix=self.ip4_data_prefix,
-                control_prefix=self.ip4_control_prefix)
-        ip6_assign = Ipv6Assignment(prefix=self.ip6_data_prefix)
-        containers_setup = ContainersSetup(owner=self)
+        ip4_assign = Ipv4Assignment(prefix = self.ip4_data_prefix,
+                groups = Reference(self, 'groups'))
+        ip6_assign = Ipv6Assignment(prefix = self.ip6_data_prefix,
+                groups = Reference(self, 'groups'))
         ip_routes = IPRoutes(owner = self,
+                groups = Reference(self, 'groups'),
                 routing_strategy = self.ip_routing_strategy)
 
-        return (ip4_assign | ip6_assign) > (ip_routes | containers_setup)
-
-    @inline_task
-    def __get__(self):
-        raise ResourceNotFound
-
-    __delete__ = None
+        return (ip4_assign | ip6_assign) > ip_routes
 
 #------------------------------------------------------------------------------
 
@@ -734,9 +646,11 @@ class CentralICN(Resource):
         return ('CentralIP',)
 
     def __subresources__(self):
-        icn_faces = ICNFaces(owner = self, protocol_name = self.face_protocol)
+        icn_faces = ICNFaces(owner = self, protocol_name = self.face_protocol,
+                groups = Reference(self, 'groups'))
         icn_routes = ICNRoutes(owner = self,
-                routing_strategy = self.icn_routing_strategy)
+                routing_strategy = self.icn_routing_strategy,
+                groups = Reference(self, 'groups'))
         return icn_faces > icn_routes
 
     @inline_task
diff --git a/vicn/resource/channel.py b/vicn/resource/channel.py
index d91bebcf..4576e0e7 100644
--- a/vicn/resource/channel.py
+++ b/vicn/resource/channel.py
@@ -22,8 +22,6 @@ from vicn.core.attribute    import Attribute
 from vicn.core.task         import EmptyTask
 from vicn.resource.ip_assignment    import Ipv6Assignment, Ipv4Assignment
 
-from math import log, ceil
-
 class Channel(Resource):
     """
     Resource: Channel
@@ -49,26 +47,3 @@ class Channel(Resource):
         ret = "{:03}".format(len(self.interfaces))
         ret = ret + ''.join(sorted(map(lambda x : x.node.name, self.interfaces)))
         return ret
-
-    def __create__(self):
-        interfaces = sorted(self.interfaces, key = lambda x : x.device_name)
-        if interfaces:
-            #IPv6
-            central6 = self._state.manager.by_type(Ipv6Assignment)[0]
-            prefix6_size = min(64, 128 - ceil(log(len(self.interfaces), 2)))
-            prefix6 = iter(central6.get_prefix(self, prefix6_size))
-
-            #IPv4
-            central4 = self._state.manager.by_type(Ipv4Assignment)[0]
-            prefix4_size = 32 - ceil(log(len(self.interfaces), 2))
-            prefix4 = iter(central4.get_prefix(self, prefix4_size))
-
-            for interface in interfaces:
-                try:
-                    interface.ip4_address = next(prefix4)
-                except StopIteration as e:
-                    import pdb; pdb.set_trace()
-                interface.ip6_address = next(prefix6)
-                interface.ip6_prefix = prefix6_size
-
-        return EmptyTask()
diff --git a/vicn/resource/group.py b/vicn/resource/group.py
new file mode 100644
index 00000000..1557c42e
--- /dev/null
+++ b/vicn/resource/group.py
@@ -0,0 +1,38 @@
+#!/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.
+#
+
+from vicn.core.resource        import Resource
+from vicn.core.attribute       import Attribute, Multiplicity
+
+class Group(Resource):
+    resources = Attribute(Resource, description = 'Resources belonging to the group',
+	    multiplicity = Multiplicity.ManyToMany,
+            default = [],
+            reverse_name = 'groups',
+            reverse_description = 'Groups to which the resource belongs')
+
+    def iter_by_type(self, type):
+        for r in self.resources:
+            if isinstance(r, type):
+                yield r
+
+    def iter_by_type_str(self, typestr):
+        cls = self._state.manager._available.get(typestr.lower())
+        if not cls:
+            return list()
+        return self.iter_by_type(cls)
diff --git a/vicn/resource/icn/ndnpingserver.py b/vicn/resource/icn/ndnpingserver.py
index da13f59b..f9cfa7cc 100644
--- a/vicn/resource/icn/ndnpingserver.py
+++ b/vicn/resource/icn/ndnpingserver.py
@@ -55,7 +55,7 @@ class NDNPingServerBase(Producer):
 
     node = Attribute(requirements = [
             Requirement("forwarder", 
-                capabilities = set(['ICN_SUITE_CCNX_1_0'])) ])
+                capabilities = set(['ICN_SUITE_NDN_1_0'])) ])
 
     __package_names__ = ['ndnping']
 
diff --git a/vicn/resource/icn/webserver.py b/vicn/resource/icn/webserver.py
index 8b8e2ef3..71e9f200 100644
--- a/vicn/resource/icn/webserver.py
+++ b/vicn/resource/icn/webserver.py
@@ -25,5 +25,5 @@ class WebServer(Producer):
     CCNX Webserver
     """
 
-    __package_names__ = ['webserver-ccnx']
-    __service_name__ = 'webserver-ccnx'
+    __package_names__ = ['http-server']
+    __service_name__ = 'http-server'
diff --git a/vicn/resource/ip_assignment.py b/vicn/resource/ip_assignment.py
index 7553f4ff..62a32389 100644
--- a/vicn/resource/ip_assignment.py
+++ b/vicn/resource/ip_assignment.py
@@ -16,6 +16,8 @@
 # limitations under the License.
 #
 
+import math
+
 from vicn.core.resource                 import Resource
 from netmodel.model.type                import String
 from vicn.core.attribute                import Attribute
@@ -60,9 +62,42 @@ class IpAssignment(Resource):
             self._assigned_addresses[obj] = ret
         return ret
 
+    @inline_task
+    def __get__(self):
+        raise ResourceNotFound
+
+    @inline_task
+    def __create__(self):
+        # XXX code from Channel.__create__, until Events are properly implemented.
+        # Iterate on channels for allocate IP addresses
+        for group in self.groups:
+            for channel in group.iter_by_type_str('channel'):
+                interfaces = sorted(channel.interfaces, key = lambda x : x.device_name)
+                if not interfaces:
+                    continue
+
+                min_prefix_size = math.ceil(math.log(len(channel.interfaces), 2))
+                prefix_size = min(self.DEFAULT_PREFIX_SIZE, self.MAX_PREFIX_SIZE - min_prefix_size)
+                prefix = iter(self.get_prefix(channel, prefix_size))
+
+                for interface in interfaces:
+                    ip = next(prefix)
+                    print('attribute ip=', ip)
+                    setattr(interface, self.ATTR_ADDRESS, ip)
+                    setattr(interface, self.ATTR_PREFIX, prefix_size)
+
+    __delete__ = None
+
 class Ipv6Assignment(IpAssignment):
     PrefixClass = Inet6Prefix
-
+    DEFAULT_PREFIX_SIZE = 64
+    MAX_PREFIX_SIZE = 128
+    ATTR_ADDRESS = 'ip6_address'
+    ATTR_PREFIX  = 'ip6_prefix'
 
 class Ipv4Assignment(IpAssignment):
     PrefixClass = Inet4Prefix
+    DEFAULT_PREFIX_SIZE = 32
+    MAX_PREFIX_SIZE = 32
+    ATTR_ADDRESS = 'ip4_address'
+    ATTR_PREFIX  = 'ip4_prefix'
diff --git a/vicn/resource/linux/application.py b/vicn/resource/linux/application.py
index d2b5139e..ed135da6 100644
--- a/vicn/resource/linux/application.py
+++ b/vicn/resource/linux/application.py
@@ -21,7 +21,6 @@ from vicn.core.resource                     import Resource, EmptyResource
 from vicn.resource.application              import Application
 from vicn.resource.linux.package_manager    import Packages
 
-
 class LinuxApplication(Application):
     """
     Resource: Linux Application
diff --git a/vicn/resource/linux/bridge.py b/vicn/resource/linux/bridge.py
index 882f0226..7b5ceed7 100644
--- a/vicn/resource/linux/bridge.py
+++ b/vicn/resource/linux/bridge.py
@@ -46,7 +46,7 @@ class Bridge(Channel, BaseNetDevice):
                 Requirement('bridge_manager')
             ])
     device_name = Attribute(
-            default = DEFAULT_BRIDGE_NAME,
+            default = lambda self: self._state.manager.get('bridge_name'),
             mandatory = False)
 
     #--------------------------------------------------------------------------
diff --git a/vicn/resource/linux/dnsmasq.py b/vicn/resource/linux/dnsmasq.py
index e18f750f..b5aa8053 100644
--- a/vicn/resource/linux/dnsmasq.py
+++ b/vicn/resource/linux/dnsmasq.py
@@ -42,7 +42,6 @@ TPL_CONF='''
 
 interface=$interface
 dhcp-range=$dhcp_range
-dhcp-host=00:0e:c6:81:79:01,192.168.128.200,12h
 
 #server=$server
 $flags
@@ -60,12 +59,12 @@ class DnsMasq(Service, DnsServer):
     __package_names__ = ['dnsmasq']
     __service_name__ = 'dnsmasq'
 
-    interface = Attribute(Interface, 
+    interface = Attribute(Interface,
             description = 'Interface on which to listen')
     lease_interval = Attribute(String,
             default = '12h')
     server = Attribute(String)
-    dhcp_authoritative = Attribute(Bool, 
+    dhcp_authoritative = Attribute(Bool,
             description = 'Flag: DHCP authoritative',
             default = True)
     log_queries = Attribute(Bool, description = 'Flag: log DNS queries',
@@ -80,10 +79,7 @@ class DnsMasq(Service, DnsServer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if not self.interface:
-            if self.node.bridge:
-                self.interface = self.node.bridge
-            else:
-                self.interface = self.node.host_interface
+            raise Exception("Cannot initialize bridge without interface")
 
     def __subresources__(self):
         # Overwrite configuration file
diff --git a/vicn/resource/linux/net_device.py b/vicn/resource/linux/net_device.py
index 1ce7e4d5..e40256ea 100644
--- a/vicn/resource/linux/net_device.py
+++ b/vicn/resource/linux/net_device.py
@@ -22,14 +22,14 @@ import math
 import random
 import string
 
-from netmodel.model.type        import Integer, String, Bool
-from vicn.core.address_mgr      import AddressManager
-from vicn.core.attribute        import Attribute
-from vicn.core.exception        import ResourceNotFound
-from vicn.core.resource         import BaseResource
-from vicn.core.task             import BashTask, task, EmptyTask
-from vicn.resource.application  import Application
-from vicn.resource.interface    import Interface
+from netmodel.model.type                import Integer, String, Bool
+from vicn.core.address_mgr              import AddressManager
+from vicn.core.attribute                import Attribute
+from vicn.core.exception                import ResourceNotFound
+from vicn.core.resource                 import BaseResource
+from vicn.core.task                     import BashTask, task, EmptyTask
+from vicn.resource.linux.application    import LinuxApplication as Application
+from vicn.resource.interface            import Interface
 
 # parse_ip_addr inspired from:
 # From: https://github.com/ohmu/poni/blob/master/poni/cloud_libvirt.py
diff --git a/vicn/resource/linux/package_manager.py b/vicn/resource/linux/package_manager.py
index 86b7057a..eaf83e17 100644
--- a/vicn/resource/linux/package_manager.py
+++ b/vicn/resource/linux/package_manager.py
@@ -19,7 +19,7 @@
 import asyncio
 import logging
 
-from netmodel.model.type        import String
+from netmodel.model.type        import String, Bool
 from vicn.core.attribute        import Attribute, Multiplicity
 from vicn.core.exception        import ResourceNotFound
 from vicn.core.requirement      import Requirement
@@ -63,7 +63,7 @@ class PackageManager(Resource):
     Resource: PackageManager
 
     APT package management wrapper.
-    
+
     Todo:
       - We assume a package manager is always installed on every machine.
       - Currently, we limit ourselves to debian/ubuntu, and voluntarily don't
@@ -79,6 +79,9 @@ class PackageManager(Resource):
             reverse_auto = True,
             mandatory = True,
             multiplicity = Multiplicity.OneToOne)
+    trusted = Attribute(Bool,
+            description="Force repository trust",
+            default=False)
 
     #--------------------------------------------------------------------------
     # Constructor and Accessors
@@ -94,34 +97,28 @@ class PackageManager(Resource):
     #--------------------------------------------------------------------------
 
     def __after__(self):
-        if self.node.__class__.__name__ == 'Physical':
-            # UGLY : This blocking code is currently needed
-            task = self.node.host_interface._get_ip4_address()
-            ip_dict = task.execute_blocking()
-            self.node.host_interface.ip4_address = ip_dict['ip4_address']
-            return ('Repository',)
-        else:
-            return ('Repository', 'CentralIP', 'RoutingTable')
+        return ('Repository',)
 
     @inline_task
     def __get__(self):
         raise ResourceNotFound
 
-    def __create__(self):
+    #---------------------------------------------------------------------------
+    # Methods
+    #---------------------------------------------------------------------------
+
+    def __method_setup_repositories__(self):
         repos = EmptyTask()
         for repository in self._state.manager.by_type_str('Repository'):
             deb_source = self._get_deb_source(repository)
             path = self._get_path(repository)
-            repo = BashTask(self.node, CMD_SETUP_REPO, 
+            # XXX There is no need to setup a repo if there is no package to install
+            repo = BashTask(self.node, CMD_SETUP_REPO,
                     {'deb_source': deb_source, 'path': path})
             repos = repos | repo
 
-        return repos 
+        return repos
 
-    #---------------------------------------------------------------------------
-    # Methods
-    #---------------------------------------------------------------------------
-        
     def __method_update__(self):
         kill = BashTask(self.node, CMD_APT_GET_KILL, {'node': self.node.name},
                 lock = self.apt_lock)
@@ -139,13 +136,12 @@ class PackageManager(Resource):
         else:
             update = EmptyTask()
 
-        return (kill > dpkg_configure_a) > update
+        return (self.__method_setup_repositories__() > (kill > dpkg_configure_a)) > update
 
     def __method_install__(self, package_name):
-        update = self.__method_update__()
         install = BashTask(self.node, CMD_PKG_INSTALL, {'package_name':
                 package_name}, lock = self.apt_lock)
-        return update > install
+        return self.__method_update__() > install
 
     #---------------------------------------------------------------------------
     # Internal methods
@@ -158,10 +154,20 @@ class PackageManager(Resource):
         return '/etc/apt/sources.list.d/{}.list'.format(repository.repo_name)
 
     def _get_deb_source(self, repository):
-        path = repository.node.host_interface.ip4_address + '/'
+        protocol = 'https' if repository.ssl else 'http'
+        path = repository.node.hostname + '/'
         if repository.directory:
             path += repository.directory + '/'
-        return 'deb http://{} {}/'.format(path, self.node.dist)
+        trusted = '[trusted=yes] ' if self.trusted else ''
+        if repository.sections:
+            sections = ' {}'.format(' '.join(repository.sections))
+        else:
+            sections = ''
+        if '$DISTRIBUTION' in path:
+            path = path.replace('$DISTRIBUTION', self.node.dist)
+            return 'deb {}{}://{} ./{}'.format(trusted, protocol, path, sections)
+        else:
+            return 'deb {}{}://{} {}{}'.format(trusted, protocol, path, self.node.dist, sections)
 
 #------------------------------------------------------------------------------
 
@@ -173,7 +179,7 @@ class Package(Resource):
     """
 
     package_name = Attribute(String, mandatory = True)
-    node = Attribute(Node, 
+    node = Attribute(Node,
             mandatory = True,
             requirements=[
                 Requirement('package_manager')
@@ -208,7 +214,7 @@ class Packages(Resource):
     since package_names are static for a resource, this is not a problem here.
     """
     names = Attribute(String, multiplicity = Multiplicity.OneToMany)
-    node = Attribute(Node, 
+    node = Attribute(Node,
             mandatory = True,
             requirements=[
                 Requirement('package_manager')
@@ -229,4 +235,3 @@ class Packages(Resource):
             return Resource.__concurrent__(*packages)
         else:
             return None
-        
diff --git a/vicn/resource/linux/repository.py b/vicn/resource/linux/repository.py
index f3e70565..cd740d38 100644
--- a/vicn/resource/linux/repository.py
+++ b/vicn/resource/linux/repository.py
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-from netmodel.model.type        import String
+from netmodel.model.type        import String, Bool
 from vicn.core.attribute        import Attribute, Multiplicity
 from vicn.resource.application  import Application
 
@@ -35,7 +35,12 @@ class Repository(Application):
             default = 'vicn')
     directory = Attribute(String, description = 'Directory holding packages', 
             default = '')
+    sections = Attribute(String, description = 'Sections',
+            multiplicity = Multiplicity.OneToMany,
+            default = [])
     distributions = Attribute(String, 
             description = 'List of distributions served by this repository',
             multiplicity = Multiplicity.ManyToMany,
             default = ['sid', 'trusty', 'xenial'])
+    ssl = Attribute(Bool, description = 'Use SSL (https) for repository',
+            default = True)
diff --git a/vicn/resource/lxd/lxc_container.py b/vicn/resource/lxd/lxc_container.py
index 9daaffb7..5670d1a2 100644
--- a/vicn/resource/lxd/lxc_container.py
+++ b/vicn/resource/lxd/lxc_container.py
@@ -18,16 +18,14 @@
 
 import logging
 import shlex
-import time
 
-# Suppress logging from pylxd dependency on ws4py 
+# Suppress logging from pylxd dependency on ws4py
 # (this needs to be included before pylxd)
 from ws4py import configure_logger
 configure_logger(level=logging.ERROR)
 import pylxd
 
 from netmodel.model.type            import String, Integer, Bool, Self
-from vicn.core.address_mgr          import AddressManager
 from vicn.core.attribute            import Attribute, Reference, Multiplicity
 from vicn.core.commands             import ReturnValue
 from vicn.core.exception            import ResourceNotFound
@@ -37,12 +35,10 @@ from vicn.core.task                 import task, inline_task, BashTask, EmptyTas
 from vicn.resource.linux.net_device import NetDevice
 from vicn.resource.node             import Node
 from vicn.resource.vpp.scripts      import APPARMOR_VPP_PROFILE
+from vicn.resource.lxd.lxd_profile  import LXD_PROFILE_DEFAULT_IFNAME
 
 log = logging.getLogger(__name__)
 
-# Default name of VICN management/monitoring interface
-DEFAULT_LXC_NETDEVICE = 'eth0'
-
 # Default remote server (pull mode only)
 DEFAULT_SOURCE_URL      = 'https://cloud-images.ubuntu.com/releases/'
 
@@ -56,8 +52,10 @@ CMD_UNSET_IP6_FWD = 'sysctl -w net.ipv6.conf.all.forwarding=0'
 CMD_SET_IP6_FWD = 'sysctl -w net.ipv6.conf.all.forwarding=1'
 CMD_GET_IP6_FWD = 'sysctl -n net.ipv6.conf.all.forwarding'
 
+CMD_NETWORK_DHCP='dhclient {container.management_interface.device_name}'
+
 # Type: ContainerName
-ContainerName = String(max_size = 64, ascii = True, 
+ContainerName = String(max_size = 64, ascii = True,
         forbidden = ('/', ',', ':'))
 
 class LxcContainer(Node):
@@ -74,12 +72,12 @@ class LxcContainer(Node):
 
     architecture = Attribute(String, description = 'Architecture',
             default = 'x86_64')
-    container_name = Attribute(ContainerName, 
+    container_name = Attribute(ContainerName,
             description = 'Name of the container',
             default = Reference(Self, 'name'))
     ephemeral = Attribute(Bool, description = 'Ephemeral container flag',
             default = False)
-    node = Attribute(Node, 
+    node = Attribute(Node,
             description = 'Node on which the container is running',
             mandatory = True,
             requirements = [
@@ -91,26 +89,26 @@ class LxcContainer(Node):
                 Requirement('bridge'),
                 # A DNS server is required to provide internet connectivity to
                 # the containers
-                Requirement('dns_server'),
+                # Requirement('dns_server'),
             ])
-    profiles = Attribute(String, multiplicity = Multiplicity.OneToMany, 
-            default = ['default'])
+    profiles = Attribute(String, multiplicity = Multiplicity.OneToMany,
+            default = ['vicn'])
     image = Attribute(String, description = 'image', default = None)
     is_image = Attribute(Bool, defaut = False)
     pid = Attribute(Integer, description = 'PID of the container')
     ip6_forwarding = Attribute(Bool, default=True)
 
-    #-------------------------------------------------------------------------- 
+    #--------------------------------------------------------------------------
     # Constructor / Accessors
-    #-------------------------------------------------------------------------- 
+    #--------------------------------------------------------------------------
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._container = None
 
-    #-------------------------------------------------------------------------- 
+    #--------------------------------------------------------------------------
     # Resource lifecycle
-    #-------------------------------------------------------------------------- 
+    #--------------------------------------------------------------------------
 
     @inline_task
     def __initialize__(self):
@@ -120,11 +118,11 @@ class LxcContainer(Node):
         self.node_with_kernel = Reference(self, 'node')
 
         # We automatically add the management/monitoring interface
-        self._host_interface = NetDevice(node = self, 
+        self._management_interface = NetDevice(node = self,
                 owner = self,
                 monitored = False,
-                device_name = DEFAULT_LXC_NETDEVICE)
-        self._state.manager.commit_resource(self._host_interface)
+                device_name = LXD_PROFILE_DEFAULT_IFNAME)
+        self._state.manager.commit_resource(self._management_interface)
 
         for iface in self.interfaces:
             if iface.get_type() == "dpdkdevice":
@@ -150,7 +148,9 @@ class LxcContainer(Node):
             wait_vpp_host = wait_resource_task(self.node.vpp_host)
         create = self._create_container()
         start = self.__method_start__()
-        return wait_vpp_host > (create > start)
+        #XXX Should be an option on the netdevice
+        dhcp_interface = BashTask(self, CMD_NETWORK_DHCP, {'container':self})
+        return (wait_vpp_host > (create > start)) > dhcp_interface
 
     @task
     def _create_container(self):
@@ -158,54 +158,52 @@ class LxcContainer(Node):
         log.debug('Container description: {}'.format(container))
         client = self.node.lxd_hypervisor.client
         self._container = client.containers.create(container, wait=True)
-        self._container.start(wait = True)
+        #self._container.start(wait = True)
 
     def _get_container_description(self):
         # Base configuration
         container = {
-            'name'          : self.container_name, 
+            'name'          : self.container_name,
             'architecture'  : self.architecture,
-            'ephemeral'     : self.ephemeral,  
-            'profiles'      : ['default'],
+            'ephemeral'     : self.ephemeral,
+            'profiles'      : self.profiles,
             'config'        : {},
             'devices'       : {},
         }
 
         # DEVICES
 
-        devices = {}
         # FIXME Container profile support is provided by setting changes into
         # configuration (currently only vpp profile is supported)
         for profile in self.profiles:
             if profile == 'vpp':
                 # Set the new apparmor profile. This will be created in VPP
-                # application 
+                # application
                 # Mount hugetlbfs in the container.
                 container['config']['raw.lxc'] = APPARMOR_VPP_PROFILE
                 container['config']['security.privileged'] = 'true'
 
                 for device in self.node.vpp_host.uio_devices:
                     container['devices'][device] = {
-                        'path' : '/dev/{}'.format(device), 
+                        'path' : '/dev/{}'.format(device),
                         'type' : 'unix-char' }
 
-        # NETWORK (not for images) 
-
-        if not self.is_image:
-            container['config']['user.network_mode'] = 'link-local'
-            device = {
-                'type'      : 'nic',
-                'name'      : self.host_interface.device_name,
-                'nictype'   : 'bridged',
-                'parent'    : self.node.bridge.device_name,
-            }
-            device['hwaddr'] = AddressManager().get_mac(self)
-            prefix = 'veth-{}'.format(self.container_name)
-            device['host_name'] = AddressManager().get('device_name', self, 
-                    prefix = prefix, scope = prefix)
-
-            container['devices'][device['name']] = device
-            
+#        # NETWORK (not for images)
+#
+#        if not self.is_image:
+#            container['config']['user.network_mode'] = 'link-local'
+#            device = {
+#                'type'      : 'nic',
+#                'name'      : self.host_interface.device_name,
+#                'nictype'   : 'bridged',
+#                'parent'    : self.node.bridge.device_name,
+#            }
+#            device['hwaddr'] = AddressManager().get_mac(self)
+#            prefix = 'veth-{}'.format(self.container_name)
+#            device['host_name'] = AddressManager().get('device_name', self,
+#                    prefix = prefix, scope = prefix)
+#
+#            container['devices'][device['name']] = device
 
         # SOURCE
 
@@ -233,6 +231,7 @@ class LxcContainer(Node):
     @task
     def __delete__(self):
         log.info("Delete container {}".format(self.container_name))
+        import pdb; pdb.set_trace()
         self.node.lxd_hypervisor.client.containers.remove(self.name)
 
     #--------------------------------------------------------------------------
@@ -243,7 +242,7 @@ class LxcContainer(Node):
         """
         Attribute: pid (getter)
         """
-        return BashTask(self.node, CMD_GET_PID, {'container': self}, 
+        return BashTask(self.node, CMD_GET_PID, {'container': self},
                 parse = lambda rv: {'pid': rv.stdout.strip()})
 
     #--------------------------------------------------------------------------
diff --git a/vicn/resource/lxd/lxd_hypervisor.py b/vicn/resource/lxd/lxd_hypervisor.py
index 68b7ab28..f9952e4f 100644
--- a/vicn/resource/lxd/lxd_hypervisor.py
+++ b/vicn/resource/lxd/lxd_hypervisor.py
@@ -38,6 +38,7 @@ from vicn.core.task                   import BashTask, task
 from vicn.resource.linux.application  import LinuxApplication as Application
 from vicn.resource.linux.service      import Service
 from vicn.resource.linux.certificate  import Certificate
+from vicn.resource.lxd.lxd_profile    import LxdProfile
 
 # Suppress non-important logging messages from requests and urllib3
 logging.getLogger("requests").setLevel(logging.WARNING)
@@ -52,19 +53,20 @@ DEFAULT_KEY_PATH = os.path.expanduser(os.path.join(
         '~', '.vicn', 'lxd_client_cert', 'client_key.pem'))
 
 # FIXME hardcoded password for LXD server
-DEFAULT_TRUST_PASSWORD = 'vicn'
+LXD_TRUST_PWD_DEFAULT = 'vicn'
 
-DEFAULT_LXD_STORAGE = 100 # GB
+LXD_STORAGE_SIZE_DEFAULT = 100 # GB
+LXD_NETWORK_DEFAULT = 'lxdbr-vicn'
+LXD_PROFILE_NAME_DEFAULT = 'vicn'
 
+ZFS_DEFAULT_POOL_NAME = 'vicn'
 # Commands used to interact with the LXD hypervisor
 CMD_LXD_CHECK_INIT = 'lsof -i:{lxd.lxd_port}'
 
 CMD_LXD_INIT_BASE = 'lxd init --auto '
-CMD_LXD_INIT='''
-{base}
-lxc profile unset default environment.http_proxy
-lxc profile unset default user.network_mode
-'''
+
+CMD_LXD_NETWORK_GET = 'lxc network list | grep {lxd_hypervisor.network}'
+CMD_LXD_NETWORK_SET = 'lxc network create {lxd_hypervisor.network} || true'
 
 #------------------------------------------------------------------------------
 # Subresources
@@ -82,7 +84,7 @@ class LxdInit(Application):
             'storage-backend'       : self.owner.storage_backend,
             'network-port'          : self.owner.lxd_port,
             'network-address'       : '0.0.0.0',
-            'trust-password'        : DEFAULT_TRUST_PASSWORD,
+            'trust-password'        : self.owner.trust_password,
         }
 
         if self.owner.storage_backend == 'zfs':
@@ -104,8 +106,7 @@ class LxdInit(Application):
         # error: Failed to create the ZFS pool: The ZFS modules are not loaded.
         # Try running '/sbin/modprobe zfs' as root to load them.
         # zfs-dkms in the host
-        return BashTask(self.owner.node, CMD_LXD_INIT, {'base': cmd},
-                as_root = True)
+        return BashTask(self.owner.node, cmd, as_root = True)
 
     def __delete__(self):
         raise NotImplementedError
@@ -134,7 +135,7 @@ class LxdInstallCert(Resource):
         client certificate for the LXD daemon.
         """
         log.info('Adding certificate on LXD')
-        self.owner.client.authenticate(DEFAULT_TRUST_PASSWORD)
+        self.owner.client.authenticate(self.owner.trust_password)
         if not self.owner.client.trusted:
             raise Exception
 
@@ -154,9 +155,13 @@ class LxdHypervisor(Service):
             default = 'zfs',
             choices = ['zfs'])
     storage_size = Attribute(Integer, description = 'Storage size',
-            default = DEFAULT_LXD_STORAGE) # GB
+            default = LXD_STORAGE_SIZE_DEFAULT) # GB
     zfs_pool = Attribute(String, description = 'ZFS pool',
-            default='vicn')
+            default=ZFS_DEFAULT_POOL_NAME)
+    network  = Attribute(String, description = 'LXD network name',
+            default=LXD_NETWORK_DEFAULT)
+    trust_password = Attribute(String, description = 'Trust password for the LXD server',
+            default=LXD_TRUST_PWD_DEFAULT)
 
     # Just overload attribute with a new reverse
     node = Attribute(
@@ -194,8 +199,13 @@ class LxdHypervisor(Service):
                 owner = self)
         lxd_cert_install = LxdInstallCert(certificate = lxd_local_cert,
                 owner = self)
+        lxd_vicn_profile = LxdProfile(name=LXD_PROFILE_NAME_DEFAULT,
+                                      node=self.node,
+                                      description='vICN profile',
+                                      network=self.network,
+                                      pool=self.zfs_pool)
 
-        return (lxd_init | lxd_local_cert) > lxd_cert_install
+        return (lxd_init | lxd_local_cert) > (lxd_vicn_profile | lxd_cert_install)
 
     #--------------------------------------------------------------------------
     # Private methods
@@ -221,3 +231,10 @@ class LxdHypervisor(Service):
     @property
     def aliases(self):
         return [alias for image in self.images for alias in image.aliases]
+
+    @task
+    def _get_network(self):
+        return None #XXX We assume it's always nothing
+
+    def _set_network(self):
+        return BashTask(self.node, CMD_LXD_NETWORK_SET, {'lxd_hypervisor': self})
diff --git a/vicn/resource/lxd/lxd_profile.py b/vicn/resource/lxd/lxd_profile.py
new file mode 100644
index 00000000..e7afee4a
--- /dev/null
+++ b/vicn/resource/lxd/lxd_profile.py
@@ -0,0 +1,56 @@
+#!/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.
+#
+
+from vicn.core.resource                 import Resource
+from netmodel.model.type                import String
+from vicn.core.attribute                import Attribute, Multiplicity
+from vicn.core.task                     import BashTask
+from vicn.core.exception              import ResourceNotFound
+
+CMD_LXD_PROFILE_CREATE = '''
+lxc profile create {profile.name} description="{profile.description}"
+lxc profile device add {profile.name} root disk pool={profile.pool} path=/
+lxc profile device add {profile.name} {profile.iface_name} nic name={profile.iface_name} nictype=bridged parent={profile.network}
+lxc profile unset {profile.name} environment.http_proxy
+lxc profile unset {profile.name} user.network_mode
+'''
+
+CMD_LXD_PROFILE_GET = 'lxc profile list | grep {profile.name}'
+
+# Default name of VICN management/monitoring interface
+#
+# This should be kept in sync with /etc/network/interfaces in the image file so that dhcp works
+LXD_PROFILE_DEFAULT_IFNAME = 'vicn_mgmt'
+
+class LxdProfile(Resource):
+
+    description = Attribute(String, descr="profile description", mandatory=True)
+    pool = Attribute(String, descr="ZFS pool used by the containers", mandatory=True)
+    network = Attribute(String, description='Network on which to attach', mandatory=True)
+    iface_name = Attribute(String, description='Default interface name',
+            default = LXD_PROFILE_DEFAULT_IFNAME)
+    node = Attribute(Resource, mandatory=True)
+
+    def __get__(self):
+        def parse(rv):
+            if not rv.stdout:
+                raise ResourceNotFound
+        return BashTask(self.node, CMD_LXD_PROFILE_GET, {'profile':self}, parse=parse)
+
+    def __create__(self):
+        return BashTask(self.node, CMD_LXD_PROFILE_CREATE, {'profile':self})
diff --git a/vicn/resource/node.py b/vicn/resource/node.py
index ad519666..c785e32b 100644
--- a/vicn/resource/node.py
+++ b/vicn/resource/node.py
@@ -61,33 +61,17 @@ class Node(Resource):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self._host_interface = None
+        self._management_interface = None
 
     #---------------------------------------------------------------------------
     # Public API
     #---------------------------------------------------------------------------
 
     @property
-    def host_interface(self):
-        """
-        We assume that any unmanaged interface associated to the host is the
-        main host interface. It should thus be declared in the JSON topology.
-        We might later perform some kind of auto discovery.
-
-        This unmanaged interface is only required to get the device_name:
-          - to create Veth (need a parent)
-          - to ssh a node, get its ip address (eg for the repo)
-          - to avoid loops in type specification
-
-        It is used for all nodes to provide network connectivity.
-        """
-
-        for interface in self.interfaces:
-            if not interface.managed or interface.owner is not None:
-                return interface
-
-        raise Exception('Cannot find host interface for node {}: {}'.format(
-                    self, self.interfaces))
+    def management_interface(self):
+        if not self._management_interface:
+            raise Exception("No management interface has been defined")
+        return self._management_interface
 
     def execute(self, command, output = False, as_root = False):
         raise NotImplementedError