From: tierno <alfonso.tiernosepulveda@telefonica.com>
Date: Fri, 13 May 2016 10:28:55 +0000 (+0200)
Subject: v0.4.38 new openmanoclient.py library; new version2 for scenario descriptor
X-Git-Tag: v1.0.0~78^2
X-Git-Url: https://osm.etsi.org/gitweb/?a=commitdiff_plain;h=refs%2Fchanges%2F11%2F211%2F1;p=osm%2FRO.git

v0.4.38 new openmanoclient.py library; new version2 for scenario descriptor

Signed-off-by: tierno <alfonso.tiernosepulveda@telefonica.com>
---

diff --git a/auxiliary_functions.py b/auxiliary_functions.py
old mode 100755
new mode 100644
diff --git a/console_proxy_thread.py b/console_proxy_thread.py
old mode 100755
new mode 100644
diff --git a/database_utils/dump_db.sh b/database_utils/dump_db.sh
index dfd5bbf9..3c94d318 100755
--- a/database_utils/dump_db.sh
+++ b/database_utils/dump_db.sh
@@ -22,6 +22,28 @@
 ##
 
 
+LICENSE_HEAD='/**
+* Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+* This file is part of openmano
+* All Rights Reserved.
+*
+* 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.
+*
+* For those usages not covered by the Apache License, Version 2.0 please
+* contact with: nfvlabs@tid.es
+**/
+'
+
 DBUSER="mano"
 DBPASS=""
 DBHOST="localhost"
@@ -105,18 +127,20 @@ do
         echo
 done
 
- 
 #echo structure, including the content of schema_version
-mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --no-data --add-drop-table --add-drop-database --routines --databases $DBNAME > ${DIRNAME}/${DBNAME}_structure.sql
+echo "$LICENSE_HEAD" > ${DIRNAME}/${DBNAME}_structure.sql
+mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --no-data --add-drop-table --add-drop-database --routines --databases $DBNAME >> ${DIRNAME}/${DBNAME}_structure.sql
 echo -e "\n\n\n\n" >> ${DIRNAME}/${DBNAME}_structure.sql
 mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --no-create-info $DBNAME --tables schema_version 2>/dev/null  >> ${DIRNAME}/${DBNAME}_structure.sql
 echo "    ${DIRNAME}/${DBNAME}_structure.sql"
 
 #echo only data
-mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --no-create-info $DBNAME > ${DIRNAME}/${DBNAME}_data.sql
+echo "$LICENSE_HEAD" > ${DIRNAME}/${DBNAME}_data.sql #copy my own header
+mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --no-create-info $DBNAME >> ${DIRNAME}/${DBNAME}_data.sql
 echo "    ${DIRNAME}/${DBNAME}_data.sql"
 
 #echo all
-mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --add-drop-table --add-drop-database --routines --databases $DBNAME > ${DIRNAME}/${DBNAME}_all.sql
+echo "$LICENSE_HEAD" > ${DIRNAME}/${DBNAME}_all.sql #copy my own header
+mysqldump $DBHOST_ $DBPORT_ $DBUSER_ $DBPASS_ --add-drop-table --add-drop-database --routines --databases $DBNAME >> ${DIRNAME}/${DBNAME}_all.sql
 echo "    ${DIRNAME}/${DBNAME}_all.sql"
 
diff --git a/database_utils/mano_db_structure.sql b/database_utils/mano_db_structure.sql
index cea38f4d..aca07aa0 100644
--- a/database_utils/mano_db_structure.sql
+++ b/database_utils/mano_db_structure.sql
@@ -18,11 +18,12 @@
 * For those usages not covered by the Apache License, Version 2.0 please
 * contact with: nfvlabs@tid.es
 **/
--- MySQL dump 10.13  Distrib 5.5.35, for debian-linux-gnu (x86_64)
+
+-- MySQL dump 10.13  Distrib 5.5.43, for debian-linux-gnu (x86_64)
 --
 -- Host: localhost    Database: mano_db
 -- ------------------------------------------------------
--- Server version	5.5.35-1ubuntu1
+-- Server version	5.5.43-0ubuntu0.14.04.1
 
 /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
 /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
@@ -54,15 +55,15 @@ DROP TABLE IF EXISTS `datacenter_nets`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `datacenter_nets` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL COMMENT 'To match with sce_nets',
+  `name` varchar(255) NOT NULL,
   `vim_net_id` varchar(36) NOT NULL,
   `datacenter_id` varchar(36) NOT NULL,
   `type` enum('bridge','data','ptp') NOT NULL DEFAULT 'data' COMMENT 'Type of network',
   `multipoint` enum('true','false') NOT NULL DEFAULT 'true',
   `shared` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'If can be shared with serveral scenarios',
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name_datacenter_id` (`name`,`datacenter_id`),
   KEY `FK_datacenter_nets_datacenters` (`datacenter_id`),
@@ -70,6 +71,29 @@ CREATE TABLE `datacenter_nets` (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Contain the external nets of a datacenter';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
+--
+-- Table structure for table `datacenter_tenants`
+--
+
+DROP TABLE IF EXISTS `datacenter_tenants`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `datacenter_tenants` (
+  `uuid` varchar(36) NOT NULL,
+  `datacenter_id` varchar(36) NOT NULL COMMENT 'Datacenter of this tenant',
+  `vim_tenant_name` varchar(64) DEFAULT NULL,
+  `vim_tenant_id` varchar(36) DEFAULT NULL COMMENT 'Tenant ID at VIM',
+  `created` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'Indicates if this tenant has been created by openmano, or it existed on VIM',
+  `user` varchar(64) DEFAULT NULL,
+  `passwd` varchar(64) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
+  PRIMARY KEY (`uuid`),
+  KEY `FK_vim_tenants_datacenters` (`datacenter_id`),
+  CONSTRAINT `FK_vim_tenants_datacenters` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Scenarios defined by the user';
+/*!40101 SET character_set_client = @saved_cs_client */;
+
 --
 -- Table structure for table `datacenters`
 --
@@ -79,18 +103,98 @@ DROP TABLE IF EXISTS `datacenters`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `datacenters` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
-  `description` varchar(100) DEFAULT NULL,
-  `type` enum('openvim','openstack') NOT NULL DEFAULT 'openvim',
+  `name` varchar(255) NOT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `type` varchar(36) NOT NULL DEFAULT 'openvim',
   `vim_url` varchar(150) NOT NULL COMMENT 'URL of the VIM for the REST API',
   `vim_url_admin` varchar(150) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `config` varchar(4000) DEFAULT NULL COMMENT 'extra config information in json',
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name` (`name`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Datacenters managed by the NFVO.';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
+--
+-- Table structure for table `datacenters_flavors`
+--
+
+DROP TABLE IF EXISTS `datacenters_flavors`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `datacenters_flavors` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `flavor_id` varchar(36) NOT NULL,
+  `datacenter_id` varchar(36) NOT NULL,
+  `vim_id` varchar(36) NOT NULL,
+  `created` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'Indicates if it has been created by openmano, or already existed',
+  PRIMARY KEY (`id`),
+  KEY `FK__flavors` (`flavor_id`),
+  KEY `FK__datacenters_f` (`datacenter_id`),
+  CONSTRAINT `FK__datacenters_f` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `FK__flavors` FOREIGN KEY (`flavor_id`) REFERENCES `flavors` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Table structure for table `datacenters_images`
+--
+
+DROP TABLE IF EXISTS `datacenters_images`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `datacenters_images` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `image_id` varchar(36) NOT NULL,
+  `datacenter_id` varchar(36) NOT NULL,
+  `vim_id` varchar(36) NOT NULL,
+  `created` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'Indicates if it has been created by openmano, or already existed',
+  PRIMARY KEY (`id`),
+  KEY `FK__images` (`image_id`),
+  KEY `FK__datacenters_i` (`datacenter_id`),
+  CONSTRAINT `FK__datacenters_i` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `FK__images` FOREIGN KEY (`image_id`) REFERENCES `images` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Table structure for table `flavors`
+--
+
+DROP TABLE IF EXISTS `flavors`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `flavors` (
+  `uuid` varchar(36) NOT NULL,
+  `name` varchar(255) NOT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `disk` smallint(5) unsigned DEFAULT NULL,
+  `ram` smallint(5) unsigned DEFAULT NULL,
+  `vcpus` smallint(5) unsigned DEFAULT NULL,
+  `extended` varchar(2000) DEFAULT NULL COMMENT 'Extra description json format of needed resources and pining, orginized in sets per numa',
+  PRIMARY KEY (`uuid`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Table structure for table `images`
+--
+
+DROP TABLE IF EXISTS `images`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `images` (
+  `uuid` varchar(36) NOT NULL,
+  `name` varchar(255) NOT NULL,
+  `location` varchar(200) NOT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `metadata` varchar(2000) DEFAULT NULL,
+  PRIMARY KEY (`uuid`),
+  UNIQUE KEY `location` (`location`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
 --
 -- Table structure for table `instance_interfaces`
 --
@@ -103,7 +207,10 @@ CREATE TABLE `instance_interfaces` (
   `instance_vm_id` varchar(36) NOT NULL,
   `instance_net_id` varchar(36) NOT NULL,
   `interface_id` varchar(36) NOT NULL,
-  `vim_interface_id` varchar(36) NOT NULL COMMENT 'vim identity for that interface',
+  `vim_interface_id` varchar(36) DEFAULT NULL COMMENT 'vim identity for that interface',
+  `mac_address` varchar(32) DEFAULT NULL,
+  `ip_address` varchar(64) DEFAULT NULL,
+  `vim_info` text,
   `type` enum('internal','external') NOT NULL COMMENT 'Indicates if this interface is external to a vnf, or internal',
   PRIMARY KEY (`uuid`),
   KEY `FK_instance_vms` (`instance_vm_id`),
@@ -126,15 +233,29 @@ CREATE TABLE `instance_nets` (
   `uuid` varchar(36) NOT NULL,
   `vim_net_id` varchar(36) NOT NULL COMMENT 'Network ID in the VIM DB',
   `instance_scenario_id` varchar(36) NOT NULL,
-  `status` enum('ACTIVE','DOWN','BUILD','ERROR') NOT NULL DEFAULT 'BUILD',
+  `sce_net_id` varchar(36) DEFAULT NULL,
+  `net_id` varchar(36) DEFAULT NULL,
+  `datacenter_id` varchar(36) DEFAULT NULL,
+  `datacenter_tenant_id` varchar(36) NOT NULL,
+  `status` enum('ACTIVE','DOWN','BUILD','ERROR','VIM_ERROR','INACTIVE','DELETED') NOT NULL DEFAULT 'BUILD',
+  `error_msg` varchar(1024) DEFAULT NULL,
+  `vim_info` text,
   `multipoint` enum('true','false') NOT NULL DEFAULT 'true',
   `external` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'If external, means that it already exists at VIM',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `vim_net_id_instance_scenario_id` (`vim_net_id`,`instance_scenario_id`),
   KEY `FK_instance_nets_instance_scenarios` (`instance_scenario_id`),
-  CONSTRAINT `FK_instance_nets_instance_scenarios` FOREIGN KEY (`instance_scenario_id`) REFERENCES `instance_scenarios` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE
+  KEY `FK_instance_nets_sce_nets` (`sce_net_id`),
+  KEY `FK_instance_nets_nets` (`net_id`),
+  KEY `FK_instance_nets_datacenters` (`datacenter_id`),
+  KEY `FK_instance_nets_datacenter_tenants` (`datacenter_tenant_id`),
+  CONSTRAINT `FK_instance_nets_datacenter_tenants` FOREIGN KEY (`datacenter_tenant_id`) REFERENCES `datacenter_tenants` (`uuid`),
+  CONSTRAINT `FK_instance_nets_datacenters` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`),
+  CONSTRAINT `FK_instance_nets_instance_scenarios` FOREIGN KEY (`instance_scenario_id`) REFERENCES `instance_scenarios` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `FK_instance_nets_nets` FOREIGN KEY (`net_id`) REFERENCES `nets` (`uuid`) ON DELETE SET NULL ON UPDATE CASCADE,
+  CONSTRAINT `FK_instance_nets_sce_nets` FOREIGN KEY (`sce_net_id`) REFERENCES `sce_nets` (`uuid`) ON DELETE SET NULL ON UPDATE CASCADE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Instances of networks';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
@@ -147,24 +268,24 @@ DROP TABLE IF EXISTS `instance_scenarios`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `instance_scenarios` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
+  `name` varchar(255) NOT NULL,
+  `tenant_id` varchar(36) DEFAULT NULL,
   `scenario_id` varchar(36) NOT NULL,
-  `nfvo_tenant_id` varchar(36) NOT NULL,
-  `vim_tenant_id` varchar(36) NOT NULL,
   `datacenter_id` varchar(36) NOT NULL,
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `datacenter_tenant_id` varchar(36) NOT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name` (`name`),
-  KEY `FK_scenarios_nfvo_tenants` (`nfvo_tenant_id`),
-  KEY `FK_instance_scenarios_vim_tenants` (`vim_tenant_id`),
+  KEY `FK_scenarios_nfvo_tenants` (`tenant_id`),
+  KEY `FK_instance_scenarios_vim_tenants` (`datacenter_tenant_id`),
   KEY `FK_instance_scenarios_datacenters` (`datacenter_id`),
   KEY `FK_instance_scenarios_scenarios` (`scenario_id`),
+  CONSTRAINT `FK_instance_scenarios_datacenter_tenants` FOREIGN KEY (`datacenter_tenant_id`) REFERENCES `datacenter_tenants` (`uuid`),
   CONSTRAINT `FK_instance_scenarios_datacenters` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`),
-  CONSTRAINT `FK_instance_scenarios_nfvo_tenants` FOREIGN KEY (`nfvo_tenant_id`) REFERENCES `nfvo_tenants` (`uuid`),
-  CONSTRAINT `FK_instance_scenarios_scenarios` FOREIGN KEY (`scenario_id`) REFERENCES `scenarios` (`uuid`),
-  CONSTRAINT `FK_instance_scenarios_vim_tenants` FOREIGN KEY (`vim_tenant_id`) REFERENCES `vim_tenants` (`uuid`)
+  CONSTRAINT `FK_instance_scenarios_nfvo_tenants` FOREIGN KEY (`tenant_id`) REFERENCES `nfvo_tenants` (`uuid`),
+  CONSTRAINT `FK_instance_scenarios_scenarios` FOREIGN KEY (`scenario_id`) REFERENCES `scenarios` (`uuid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Instances of scenarios defined by the user';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
@@ -180,9 +301,11 @@ CREATE TABLE `instance_vms` (
   `instance_vnf_id` varchar(36) NOT NULL,
   `vm_id` varchar(36) NOT NULL,
   `vim_vm_id` varchar(36) NOT NULL COMMENT 'VM ID in the VIM DB',
-  `status` enum('ACTIVE','PAUSED','INACTIVE','CREATING','ERROR','DELETING') NOT NULL DEFAULT 'CREATING',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `status` enum('ACTIVE:NoMgmtIP','ACTIVE','INACTIVE','BUILD','ERROR','VIM_ERROR','PAUSED','SUSPENDED','DELETED') NOT NULL DEFAULT 'BUILD',
+  `error_msg` varchar(1024) DEFAULT NULL,
+  `vim_info` text,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `vim_vm_id` (`vim_vm_id`),
   KEY `FK_instance_vms_vms` (`vm_id`),
@@ -203,12 +326,21 @@ CREATE TABLE `instance_vnfs` (
   `uuid` varchar(36) NOT NULL,
   `instance_scenario_id` varchar(36) NOT NULL,
   `vnf_id` varchar(36) NOT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `sce_vnf_id` varchar(36) DEFAULT NULL,
+  `datacenter_id` varchar(36) DEFAULT NULL,
+  `datacenter_tenant_id` varchar(36) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   KEY `FK_instance_vnfs_vnfs` (`vnf_id`),
   KEY `FK_instance_vnfs_instance_scenarios` (`instance_scenario_id`),
+  KEY `FK_instance_vnfs_sce_vnfs` (`sce_vnf_id`),
+  KEY `FK_instance_vnfs_datacenters` (`datacenter_id`),
+  KEY `FK_instance_vnfs_datacenter_tenants` (`datacenter_tenant_id`),
+  CONSTRAINT `FK_instance_vnfs_datacenter_tenants` FOREIGN KEY (`datacenter_tenant_id`) REFERENCES `datacenter_tenants` (`uuid`),
+  CONSTRAINT `FK_instance_vnfs_datacenters` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`),
   CONSTRAINT `FK_instance_vnfs_instance_scenarios` FOREIGN KEY (`instance_scenario_id`) REFERENCES `instance_scenarios` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT `FK_instance_vnfs_sce_vnfs` FOREIGN KEY (`sce_vnf_id`) REFERENCES `sce_vnfs` (`uuid`) ON DELETE SET NULL ON UPDATE CASCADE,
   CONSTRAINT `FK_instance_vnfs_vnfs` FOREIGN KEY (`vnf_id`) REFERENCES `vnfs` (`uuid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Instances of VNFs as part of a scenario';
 /*!40101 SET character_set_client = @saved_cs_client */;
@@ -222,16 +354,17 @@ DROP TABLE IF EXISTS `interfaces`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `interfaces` (
   `uuid` varchar(36) NOT NULL,
-  `internal_name` varchar(25) NOT NULL,
-  `external_name` varchar(25) DEFAULT NULL COMMENT 'NULL if the interface is not an external interface',
+  `internal_name` varchar(255) NOT NULL,
+  `external_name` varchar(255) DEFAULT NULL,
   `vm_id` varchar(36) NOT NULL,
   `net_id` varchar(36) DEFAULT NULL,
   `type` enum('mgmt','bridge','data') NOT NULL DEFAULT 'data' COMMENT 'Type of network',
   `vpci` char(12) DEFAULT NULL,
   `bw` mediumint(8) unsigned DEFAULT NULL COMMENT 'BW expressed in Mbits/s. Maybe this field is not necessary.',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   `model` varchar(12) DEFAULT NULL,
+  `mac` char(18) DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `internal_name_vm_id` (`internal_name`,`vm_id`),
   KEY `FK_interfaces_vms` (`vm_id`),
@@ -252,12 +385,12 @@ CREATE TABLE `logs` (
   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
   `nfvo_tenant_id` varchar(36) DEFAULT NULL,
-  `related` enum('nfvo_tenants','datacenters','vim_tenants','tenants_datacenters','vnfs','vms','interfaces','nets','scenarios','sce_vnfs','sce_interfaces','sce_nets','instance_scenarios','instance_vnfs','instance_vms','instance_nets','instance_interfaces') NOT NULL COMMENT 'Relevant element for the log',
+  `related` varchar(36) NOT NULL COMMENT 'Relevant element for the log',
   `uuid` varchar(36) DEFAULT NULL COMMENT 'Uuid of vnf, scenario, etc. that log relates to',
   `level` enum('panic','error','info','debug','verbose') NOT NULL,
   `description` varchar(200) NOT NULL,
   PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=3286 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;
+) ENGINE=InnoDB AUTO_INCREMENT=3423 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;
 /*!40101 SET character_set_client = @saved_cs_client */;
 
 --
@@ -270,12 +403,12 @@ DROP TABLE IF EXISTS `nets`;
 CREATE TABLE `nets` (
   `uuid` varchar(36) NOT NULL,
   `vnf_id` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
+  `name` varchar(255) NOT NULL,
   `type` enum('bridge','data','ptp') NOT NULL DEFAULT 'data' COMMENT 'Type of network',
   `multipoint` enum('true','false') NOT NULL DEFAULT 'false',
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `vnf_id_name` (`vnf_id`,`name`),
   CONSTRAINT `FK_nets_vnfs` FOREIGN KEY (`vnf_id`) REFERENCES `vnfs` (`uuid`) ON DELETE CASCADE
@@ -291,10 +424,10 @@ DROP TABLE IF EXISTS `nfvo_tenants`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `nfvo_tenants` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `name` varchar(255) NOT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name` (`name`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Scenarios defined by the user';
@@ -312,8 +445,8 @@ CREATE TABLE `sce_interfaces` (
   `sce_vnf_id` varchar(36) NOT NULL,
   `sce_net_id` varchar(36) DEFAULT NULL,
   `interface_id` varchar(36) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   KEY `FK_sce_interfaces_sce_vnfs` (`sce_vnf_id`),
   KEY `FK_sce_interfaces_sce_nets` (`sce_net_id`),
@@ -333,15 +466,15 @@ DROP TABLE IF EXISTS `sce_nets`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `sce_nets` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) DEFAULT NULL,
+  `name` varchar(255) NOT NULL,
   `scenario_id` varchar(36) DEFAULT NULL COMMENT 'NULL if net is matched to several scenarios',
   `type` enum('bridge','data','ptp') NOT NULL DEFAULT 'data' COMMENT 'Type of network',
   `multipoint` enum('true','false') NOT NULL DEFAULT 'true',
   `external` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'If external, net is already present at VIM',
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
-  `graph` varchar(200) DEFAULT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
+  `graph` varchar(2000) DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   KEY `FK_sce_nets_scenarios` (`scenario_id`),
   CONSTRAINT `FK_sce_nets_scenarios` FOREIGN KEY (`scenario_id`) REFERENCES `scenarios` (`uuid`) ON DELETE CASCADE ON UPDATE CASCADE
@@ -357,13 +490,13 @@ DROP TABLE IF EXISTS `sce_vnfs`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `sce_vnfs` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
+  `name` varchar(255) NOT NULL,
   `scenario_id` varchar(36) NOT NULL,
   `vnf_id` varchar(36) NOT NULL,
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
-  `graph` varchar(200) DEFAULT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
+  `graph` varchar(2000) DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name_scenario_id` (`name`,`scenario_id`),
   KEY `FK_sce_vnfs_scenarios` (`scenario_id`),
@@ -382,19 +515,37 @@ DROP TABLE IF EXISTS `scenarios`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `scenarios` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
-  `nfvo_tenant_id` varchar(36) DEFAULT NULL,
-  `description` varchar(100) DEFAULT NULL,
+  `name` varchar(255) NOT NULL,
+  `tenant_id` varchar(36) DEFAULT NULL,
+  `description` varchar(255) DEFAULT NULL,
   `public` enum('true','false') NOT NULL DEFAULT 'false',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
+  `descriptor` text COMMENT 'Original text descriptor used for create the scenario',
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name` (`name`),
-  KEY `FK_scenarios_nfvo_tenants` (`nfvo_tenant_id`),
-  CONSTRAINT `FK_scenarios_nfvo_tenants` FOREIGN KEY (`nfvo_tenant_id`) REFERENCES `nfvo_tenants` (`uuid`)
+  KEY `FK_scenarios_nfvo_tenants` (`tenant_id`),
+  CONSTRAINT `FK_scenarios_nfvo_tenants` FOREIGN KEY (`tenant_id`) REFERENCES `nfvo_tenants` (`uuid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Scenarios defined by the user';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
+--
+-- Table structure for table `schema_version`
+--
+
+DROP TABLE IF EXISTS `schema_version`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `schema_version` (
+  `version_int` int(11) NOT NULL COMMENT 'version as a number. Must not contain gaps',
+  `version` varchar(20) NOT NULL COMMENT 'version as a text',
+  `openmano_ver` varchar(20) NOT NULL COMMENT 'openmano version',
+  `comments` varchar(2000) DEFAULT NULL COMMENT 'changes to database',
+  `date` date DEFAULT NULL,
+  PRIMARY KEY (`version_int`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='database schema control version';
+/*!40101 SET character_set_client = @saved_cs_client */;
+
 --
 -- Table structure for table `tenants_datacenters`
 --
@@ -406,18 +557,18 @@ CREATE TABLE `tenants_datacenters` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `nfvo_tenant_id` varchar(36) NOT NULL,
   `datacenter_id` varchar(36) NOT NULL,
-  `vim_tenant_id` varchar(36) NOT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `datacenter_tenant_id` varchar(36) NOT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`id`),
   UNIQUE KEY `datacenter_nfvo_tenant` (`datacenter_id`,`nfvo_tenant_id`),
   KEY `FK_nfvo_tenants_datacenters` (`datacenter_id`),
-  KEY `FK_nfvo_tenants_vim_tenants` (`vim_tenant_id`),
+  KEY `FK_nfvo_tenants_vim_tenants` (`datacenter_tenant_id`),
   KEY `FK_tenants_datacenters_nfvo_tenants` (`nfvo_tenant_id`),
+  CONSTRAINT `FK_tenants_datacenters_datacenter_tenants` FOREIGN KEY (`datacenter_tenant_id`) REFERENCES `datacenter_tenants` (`uuid`),
   CONSTRAINT `FK_tenants_datacenters_datacenters` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`uuid`),
-  CONSTRAINT `FK_tenants_datacenters_nfvo_tenants` FOREIGN KEY (`nfvo_tenant_id`) REFERENCES `nfvo_tenants` (`uuid`),
-  CONSTRAINT `FK_tenants_datacenters_vim_tenants` FOREIGN KEY (`vim_tenant_id`) REFERENCES `vim_tenants` (`uuid`)
-) ENGINE=InnoDB AUTO_INCREMENT=85 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Scenarios defined by the user';
+  CONSTRAINT `FK_tenants_datacenters_nfvo_tenants` FOREIGN KEY (`nfvo_tenant_id`) REFERENCES `nfvo_tenants` (`uuid`)
+) ENGINE=InnoDB AUTO_INCREMENT=86 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Scenarios defined by the user';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
 --
@@ -430,32 +581,12 @@ DROP TABLE IF EXISTS `uuids`;
 CREATE TABLE `uuids` (
   `uuid` varchar(36) NOT NULL,
   `root_uuid` varchar(36) DEFAULT NULL COMMENT 'Some related UUIDs can be grouped by this field, so that they can be deleted at once',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `used_at` enum('nfvo_tenants','datacenters','vim_tenants','vnfs','vms','interfaces','nets','scenarios','sce_vnfs','sce_interfaces','sce_nets','instance_scenarios','instance_vnfs','instance_vms','instance_nets','instance_interfaces') DEFAULT NULL COMMENT 'Table that uses this UUID',
+  `created_at` double NOT NULL,
+  `used_at` varchar(36) DEFAULT NULL COMMENT 'Table that uses this UUID',
   PRIMARY KEY (`uuid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Table with all unique IDs used to avoid UUID repetitions among different elements';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
---
--- Table structure for table `vim_tenants`
---
-
-DROP TABLE IF EXISTS `vim_tenants`;
-/*!40101 SET @saved_cs_client     = @@character_set_client */;
-/*!40101 SET character_set_client = utf8 */;
-CREATE TABLE `vim_tenants` (
-  `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
-  `vim_tenant_id` varchar(36) NOT NULL COMMENT 'Tenant ID in the VIM DB',
-  `created` enum('true','false') NOT NULL DEFAULT 'false' COMMENT 'Indicates if this tenant has been created by openmano, or it existed on VIM',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
-  PRIMARY KEY (`uuid`),
-  UNIQUE KEY `name` (`name`),
-  UNIQUE KEY `vim_tenant_id` (`vim_tenant_id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='Scenarios defined by the user';
-/*!40101 SET character_set_client = @saved_cs_client */;
-
 --
 -- Table structure for table `vms`
 --
@@ -465,17 +596,21 @@ DROP TABLE IF EXISTS `vms`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `vms` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
+  `name` varchar(255) NOT NULL,
   `vnf_id` varchar(36) NOT NULL,
-  `vim_flavor_id` varchar(36) NOT NULL COMMENT 'Flavor ID in the VIM DB',
-  `vim_image_id` varchar(36) NOT NULL COMMENT 'Image ID in the VIM DB',
+  `flavor_id` varchar(36) NOT NULL COMMENT 'Link to flavor table',
+  `image_id` varchar(36) NOT NULL COMMENT 'Link to image table',
   `image_path` varchar(100) NOT NULL COMMENT 'Path where the image of the VM is located',
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   PRIMARY KEY (`uuid`),
   UNIQUE KEY `name_vnf_id` (`name`,`vnf_id`),
   KEY `FK_vms_vnfs` (`vnf_id`),
+  KEY `FK_vms_images` (`image_id`),
+  KEY `FK_vms_flavors` (`flavor_id`),
+  CONSTRAINT `FK_vms_flavors` FOREIGN KEY (`flavor_id`) REFERENCES `flavors` (`uuid`),
+  CONSTRAINT `FK_vms_images` FOREIGN KEY (`image_id`) REFERENCES `images` (`uuid`),
   CONSTRAINT `FK_vms_vnfs` FOREIGN KEY (`vnf_id`) REFERENCES `vnfs` (`uuid`) ON DELETE CASCADE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='VM definitions. It contains the set of VMs used by the VNF definitions.';
 /*!40101 SET character_set_client = @saved_cs_client */;
@@ -489,17 +624,18 @@ DROP TABLE IF EXISTS `vnfs`;
 /*!40101 SET character_set_client = utf8 */;
 CREATE TABLE `vnfs` (
   `uuid` varchar(36) NOT NULL,
-  `name` varchar(36) NOT NULL,
-  `path` varchar(100) DEFAULT NULL COMMENT 'Path where the YAML descriptor of the VNF can be found. NULL if it is a physical network function.',
+  `name` varchar(255) NOT NULL,
+  `tenant_id` varchar(36) DEFAULT NULL,
   `physical` enum('true','false') NOT NULL DEFAULT 'false',
-  `public` enum('true','false') NOT NULL DEFAULT 'true',
-  `description` varchar(100) DEFAULT NULL,
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  `modified_at` timestamp NULL DEFAULT NULL,
+  `public` enum('true','false') NOT NULL DEFAULT 'false',
+  `description` varchar(255) DEFAULT NULL,
+  `created_at` double NOT NULL,
+  `modified_at` double DEFAULT NULL,
   `class` varchar(36) DEFAULT 'MISC',
+  `descriptor` text COMMENT 'Original text descriptor used for create the VNF',
   PRIMARY KEY (`uuid`),
-  UNIQUE KEY `name` (`name`),
-  UNIQUE KEY `path` (`path`)
+  KEY `FK_vnfs_nfvo_tenants` (`tenant_id`),
+  CONSTRAINT `FK_vnfs_nfvo_tenants` FOREIGN KEY (`tenant_id`) REFERENCES `nfvo_tenants` (`uuid`) ON DELETE SET NULL ON UPDATE CASCADE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='VNF definitions. This is the catalogue of VNFs. It also includes Physical Network Functions or Physical Elements.\r\n';
 /*!40101 SET character_set_client = @saved_cs_client */;
 
@@ -516,4 +652,46 @@ CREATE TABLE `vnfs` (
 /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
 /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
 
--- Dump completed on 2015-03-11 17:34:28
+-- Dump completed on 2016-05-13 12:23:52
+
+
+
+
+
+-- MySQL dump 10.13  Distrib 5.5.43, for debian-linux-gnu (x86_64)
+--
+-- Host: localhost    Database: mano_db
+-- ------------------------------------------------------
+-- Server version	5.5.43-0ubuntu0.14.04.1
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8 */;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+
+--
+-- Dumping data for table `schema_version`
+--
+
+LOCK TABLES `schema_version` WRITE;
+/*!40000 ALTER TABLE `schema_version` DISABLE KEYS */;
+INSERT INTO `schema_version` VALUES (1,'0.1','0.2.2','insert schema_version','2015-05-08'),(2,'0.2','0.2.5','new tables images,flavors','2015-07-13'),(3,'0.3','0.3.3','alter vim_tenant tables','2015-07-28'),(4,'0.4','0.3.5','enlarge graph field at sce_vnfs/nets','2015-10-20'),(5,'0.5','0.4.1','Add mac address for bridge interfaces','2015-12-14'),(6,'0.6','0.4.2','Adding VIM status info','2015-12-22'),(7,'0.7','0.4.3','Changing created_at time at database','2016-01-25'),(8,'0.8','0.4.32','Enlarging name at database','2016-02-01'),(9,'0.9','0.4.33','Add ACTIVE:NoMgmtIP to instance_vms table','2016-02-05'),(10,'0.10','0.4.36','tenant management of vnfs,scenarios','2016-03-08');
+/*!40000 ALTER TABLE `schema_version` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
+
+-- Dump completed on 2016-05-13 12:23:52
diff --git a/httpserver.py b/httpserver.py
old mode 100755
new mode 100644
index 29af42dc..0e60b3d2
--- a/httpserver.py
+++ b/httpserver.py
@@ -783,7 +783,7 @@ def http_post_deploy(tenant_id):
     '''post topology deploy.'''
     print "http_post_deploy by tenant " + tenant_id 
 
-    http_content, used_schema = format_in( nsd_schema_v01, ("version",), {"v0.2": nsd_schema_v02})
+    http_content, used_schema = format_in( nsd_schema_v01, ("schema_version",), {2: nsd_schema_v02})
     #r = af.remove_extra_items(http_content, used_schema)
     #if r is not None: print "http_post_deploy: Warning: remove extra items ", r
     print "http_post_deploy input: ",  http_content
@@ -816,7 +816,7 @@ def http_post_verify(tenant_id):
 def http_post_scenarios(tenant_id):
     '''add a scenario into the catalogue. Creates the scenario and its internal structure in the OPENMANO DB'''
     print "http_post_scenarios by tenant " + tenant_id 
-    http_content, used_schema = format_in( nsd_schema_v01, ("schema_version",), {"0.2": nsd_schema_v02})
+    http_content, used_schema = format_in( nsd_schema_v01, ("schema_version",), {2: nsd_schema_v02})
     #r = af.remove_extra_items(http_content, used_schema)
     #if r is not None: print "http_post_scenarios: Warning: remove extra items ", r
     print "http_post_scenarios input: ",  http_content
diff --git a/nfvo.py b/nfvo.py
index 1c76984e..1a97fa2d 100644
--- a/nfvo.py
+++ b/nfvo.py
@@ -140,14 +140,11 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, vi
                 return -HTTP_Bad_Request, "Unknown vim type %s" % vim["type"]
 
         try:
-            tenant=vim.get('vim_tenant_id')
-            if not tenant:
-                tenant=vim.get('vim_tenant_name')
             #if not tenant:
             #    return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM  %s" % ( vim["type"])
             vim_dict[ vim['datacenter_id'] ] = vimconn_imported[ vim["type"] ].vimconnector(
                             uuid=vim['datacenter_id'], name=vim['datacenter_name'],
-                            tenant=tenant, 
+                            tenant_id=vim.get('vim_tenant_id'), tenant_name=vim.get('vim_tenant_name'),
                             url=vim['vim_url'], url_admin=vim['vim_url_admin'], 
                             user=vim.get('user'), passwd=vim.get('passwd'),
                             config=extra
@@ -1094,12 +1091,15 @@ def new_scenario(mydb, tenant_id, topo):
 
 #2: insert scenario. filling tables scenarios,sce_vnfs,sce_interfaces,sce_nets
     r,c = mydb.new_scenario( { 'vnfs':vnfs, 'nets':net_list,
-        'tenant_id':tenant_id, 'name':topo['name'], 'description':topo.get('description',topo['name']) } )
+        'tenant_id':tenant_id, 'name':topo['name'],
+         'description':topo.get('description',topo['name']),
+         'public': topo.get('public', False)
+         })
     
     return r,c
 
-def new_scenario_v02(mydb, tenant_id, scenario):
-
+def new_scenario_v02(mydb, tenant_id, scenario_dict):
+    scenario = scenario_dict["scenario"]
     if tenant_id != "any":
         if not check_tenant(mydb, tenant_id): 
             print 'nfvo.new_scenario_v02() tenant %s not found' % tenant_id
@@ -1119,9 +1119,9 @@ def new_scenario_v02(mydb, tenant_id, scenario):
         if 'vnf_id' in vnf:
             error_text += " 'vnf_id' " +  vnf['vnf_id']
             WHERE_['uuid'] = vnf['vnf_id']
-        if 'vnf_model' in vnf:
-            error_text += " 'vnf_model' " +  vnf['vnf_model']
-            WHERE_['name'] = vnf['vnf_model']
+        if 'vnf_name' in vnf:
+            error_text += " 'vnf_name' " +  vnf['vnf_name']
+            WHERE_['name'] = vnf['vnf_name']
         if len(WHERE_) == 0:
             return -HTTP_Bad_Request, "needed a 'vnf_id' or 'VNF model' at " + error_pos
         r,vnf_db = mydb.get_table(SELECT=('uuid','name','description'), FROM='vnfs', WHERE=WHERE_)
@@ -1215,7 +1215,7 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc
         print "start_scenario error. Several datacenters available, you must concrete"
         return -HTTP_Bad_Request, "Several datacenters available, you must concrete"
     myvim = vims.values()[0]
-    myvim_tenant = myvim['tenant']
+    myvim_tenant = myvim['tenant_id']
     datacenter_id = myvim['id']
     datacenter_name = myvim['name']
     datacenter_tenant_id = myvim['config']['datacenter_tenant_id']
@@ -1460,7 +1460,7 @@ def create_instance(mydb, tenant_id, instance_dict):
         print "start_scenario error. Several datacenters available, you must concrete"
         return -HTTP_Bad_Request, "Several datacenters available, you must concrete"
     myvim = vims.values()[0]
-    #myvim_tenant = myvim['tenant']
+    #myvim_tenant = myvim['tenant_id']
     datacenter_id = myvim['id']
     datacenter_name = myvim['name']
     datacenter_tenant_id = myvim['config']['datacenter_tenant_id']
@@ -2294,8 +2294,8 @@ def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None):
         filter_dict["shared"] = True
     
     result, content = myvim.get_network_list(filter_dict=filter_dict)
-    print content
-    if result != 200:
+    print result, content
+    if result <0:
         print " Not possible to get_network_list from VIM: %s " % (content)
         return -HTTP_Internal_Server_Error, content
     elif len(content)>1 and action_dict:
@@ -2348,7 +2348,7 @@ def vim_action_get(mydb, tenant_id, datacenter, item, name):
         else:
             filter_dict["name"] = name
     if item=="networks":
-        filter_dict['tenant_id'] = myvim["tenant"]
+        #filter_dict['tenant_id'] = myvim['tenant_id']
         result, content = myvim.get_network_list(filter_dict=filter_dict)
     elif item=="tenants":
         result, content = myvim.get_tenant_list(filter_dict=filter_dict)
@@ -2367,6 +2367,9 @@ def vim_action_get(mydb, tenant_id, datacenter, item, name):
     
 def vim_action_delete(mydb, tenant_id, datacenter, item, name):
     #get datacenter info
+    if tenant_id == "any":
+        tenant_id=None
+
     if af.check_valid_uuid(datacenter): 
         result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
     else:
@@ -2381,20 +2384,19 @@ def vim_action_delete(mydb, tenant_id, datacenter, item, name):
         return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid"
     datacenter_id=vims.keys()[0]
     myvim=vims[datacenter_id]
-    #get uuid
-    if not af.check_valid_uuid(name):
-        result, content = vim_action_get(mydb, tenant_id, datacenter, item, name)
-        print content
-        if result < 0:
-            return result, content
-        items = content.values()[0]
-        if type(items)==list and len(items)==0:
-            return -HTTP_Not_Found, "Not found " + item
-        elif type(items)==list and len(items)>1:
-            return -HTTP_Not_Found, "Found more than one %s with this name. Use uuid." % item
-        else: # it is a dict
-            item_id = items["id"]
-            item_name = str(items.get("name"))
+    #get uuid name
+    result, content = vim_action_get(mydb, tenant_id, datacenter, item, name)
+    print content
+    if result < 0:
+        return result, content
+    items = content.values()[0]
+    if type(items)==list and len(items)==0:
+        return -HTTP_Not_Found, "Not found " + item
+    elif type(items)==list and len(items)>1:
+        return -HTTP_Not_Found, "Found more than one %s with this name. Use uuid." % item
+    else: # it is a dict
+        item_id = items["id"]
+        item_name = str(items.get("name"))
         
     if item=="networks":
         result, content = myvim.delete_tenant_network(item_id)
@@ -2410,6 +2412,9 @@ def vim_action_delete(mydb, tenant_id, datacenter, item, name):
 def vim_action_create(mydb, tenant_id, datacenter, item, descriptor):
     #get datacenter info
     print "vim_action_create descriptor", descriptor
+    if tenant_id == "any":
+        tenant_id=None
+
     if af.check_valid_uuid(datacenter): 
         result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
     else:
diff --git a/nfvo_db.py b/nfvo_db.py
index 7104ca8b..1bf3e4bc 100644
--- a/nfvo_db.py
+++ b/nfvo_db.py
@@ -730,7 +730,9 @@ class nfvo_db():
                     tenant_id = scenario_dict.get('tenant_id')
                     #scenario
                     INSERT_={'tenant_id': tenant_id,
-                    'name': scenario_dict['name'],'description': scenario_dict['description']}
+                    'name': scenario_dict['name'],
+                    'description': scenario_dict['description'],
+                    'public': scenario_dict.get('public', "false")}
                     
                     r,scenario_uuid =  self._new_row_internal('scenarios', INSERT_, tenant_id, True, None, True,created_time)
                     if r<0:
diff --git a/openmano b/openmano
index 938d13da..b207d291 100755
--- a/openmano
+++ b/openmano
@@ -766,7 +766,7 @@ def tenant_create(args):
 def tenant_list(args):
     #print "tenant-list",args
     if args.name:
-        toshow = _get_item_uuid("vnfs", args.name)
+        toshow = _get_item_uuid("tenants", args.name)
         URLrequest = "http://%s:%s/openmano/tenants/%s" %(mano_host, mano_port, toshow)
     else:
         URLrequest = "http://%s:%s/openmano/tenants" %(mano_host, mano_port)
diff --git a/openmano_schemas.py b/openmano_schemas.py
index 8ab251bf..a563b1a9 100644
--- a/openmano_schemas.py
+++ b/openmano_schemas.py
@@ -28,6 +28,7 @@ __author__="Alfonso Tierno, Gerardo Garcia"
 __date__ ="$09-oct-2014 09:09:48$"
 
 #Basis schemas
+patern_name="^[ -~]+$"
 passwd_schema={"type" : "string", "minLength":1, "maxLength":60}
 nameshort_schema={"type" : "string", "minLength":1, "maxLength":60, "pattern" : "^[^,;()'\"]+$"}
 name_schema={"type" : "string", "minLength":1, "maxLength":255, "pattern" : "^[^,;()'\"]+$"}
@@ -41,7 +42,7 @@ bandwidth_schema={"type":"string", "pattern" : "^[0-9]+ *([MG]bps)?$"}
 memory_schema={"type":"string", "pattern" : "^[0-9]+ *([MG]i?[Bb])?$"}
 integer0_schema={"type":"integer","minimum":0}
 integer1_schema={"type":"integer","minimum":1}
-path_schema={"type":"string", "pattern":"^(\.(\.?))?(/[^/"":{}\ \(\)]+)+$"}
+path_schema={"type":"string", "pattern":"^(\.){0,2}(/[^/\"':{}\(\)]+)+$"}
 vlan_schema={"type":"integer","minimum":1,"maximum":4095}
 vlan1000_schema={"type":"integer","minimum":1000,"maximum":4095}
 mac_schema={"type":"string", "pattern":"^[0-9a-fA-F][02468aceACE](:[0-9a-fA-F]{2}){5}$"}  #must be unicast LSB bit of MSB byte ==0 
@@ -49,6 +50,7 @@ mac_schema={"type":"string", "pattern":"^[0-9a-fA-F][02468aceACE](:[0-9a-fA-F]{2
 ip_schema={"type":"string","pattern":"^([0-9]{1,3}.){3}[0-9]{1,3}$"}
 port_schema={"type":"integer","minimum":1,"maximum":65534}
 object_schema={"type":"object"}
+schema_version_2={"type":"integer","minimum":2,"maximum":2}
 
 metadata_schema={
     "type":"object",
@@ -433,7 +435,7 @@ vnfd_schema_v02 = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "type":"object",
     "properties":{
-        "version": {"type": "string", "pattern":"^v0.2$"},
+        "schema_version": schema_version_2,
         "vnf":{
             "type":"object",
             "properties":{
@@ -443,7 +445,7 @@ vnfd_schema_v02 = {
             "additionalProperties": True
         }
     },
-    "required": ["vnf", "version"],
+    "required": ["vnf", "schema_version"],
     "additionalProperties": False
 }
 
@@ -481,6 +483,7 @@ nsd_schema_v01 = {
         "name":name_schema,
         "description": description_schema,
         "tenant_id": id_schema, #only valid for admin
+        "public": {"type": "boolean"},
         "topology":{
             "type":"object",
             "properties":{
@@ -530,40 +533,50 @@ nsd_schema_v02 = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "type":"object",
     "properties":{
-        "schema_version": {"type": "string", "enum": ["0.2"]},
-        "name":name_schema,
-        "description": description_schema,
-        "tenant_id": id_schema, #only valid for admin
-        "vnfs": {
-            "type":"object",
-            "patternProperties":{
-                ".": {
-                    "type": "object",
-                    "properties":{
-                        "vnf_id": id_schema,
-                        "graph": graph_schema,
-                        "vnf_model": name_schema,
-                    },
-                }
-            },
-            "minProperties": 1
-        },
-        "networks": {
+        "schema_version": schema_version_2,
+        "scenario":{
             "type":"object",
-            "patternProperties":{
-                ".": {
-                    "type": "object",
-                    "properties":{
-                        "interfaces":{"type":"array", "minLength":1},
-                        "type": {"type": "string", "enum":["link", "external_network", "dataplane_net", "bridge_net"]},
-                        "graph": graph_schema
+            "properties":{
+                "name":name_schema,
+                "description": description_schema,
+                "tenant_id": id_schema, #only valid for admin
+                "public": {"type": "boolean"},
+                "vnfs": {
+                    "type":"object",
+                    "patternProperties":{
+                        ".": {
+                            "type": "object",
+                            "properties":{
+                                "vnf_id": id_schema,
+                                "graph": graph_schema,
+                                "vnf_name": name_schema,
+                            },
+                        }
                     },
-                    "required": ["interfaces"]
+                    "minProperties": 1
                 },
-            }
-        },
+                "networks": {
+                    "type":"object",
+                    "patternProperties":{
+                        ".": {
+                            "type": "object",
+                            "properties":{
+                                "interfaces":{"type":"array", "minLength":1},
+                                "type": {"type": "string", "enum":["dataplane", "bridge"]},
+                                "external" : {"type": "boolean"},
+                                "graph": graph_schema
+                            },
+                            "required": ["interfaces"]
+                        },
+                    }
+                },
+            
+            },
+            "required": ["vnfs", "networks","name"],
+            "additionalProperties": False
+        }
     },
-    "required": ["vnfs", "networks","name", "schema_version"],
+    "required": ["scenario","schema_version"],
     "additionalProperties": False
 }
 
diff --git a/openmanoclient.py b/openmanoclient.py
new file mode 100644
index 00000000..0d9aa4ae
--- /dev/null
+++ b/openmanoclient.py
@@ -0,0 +1,908 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+##
+# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+# This file is part of openmano
+# All Rights Reserved.
+#
+# 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.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+'''
+openmano python client used to interact with openmano-server  
+'''
+__author__="Alfonso Tierno"
+__date__ ="$09-Mar-2016 09:09:48$"
+__version__="0.0.1-r467"
+version_date="Mar 2016"
+
+import requests
+import json
+import yaml
+import logging
+import sys
+if  sys.version_info.major == 3:
+    from urllib.parse import quote
+elif sys.version_info.major == 2:
+    from urllib import quote
+
+class OpenmanoException(Exception):
+    '''Common Exception for all openmano client exceptions'''
+
+class OpenmanoBadParamsException(OpenmanoException):
+    '''Bad or missing input parameters'''
+
+class OpenmanoResponseException(OpenmanoException):
+    '''Unexpected response from openmano server'''
+
+class OpenmanoNotFoundException(OpenmanoException):
+    '''Not found at server'''
+
+# class vnf():
+#     def __init__(self, message):
+#         print "Error: %s" %message
+#         print
+#         self.print_usage()
+#         #self.print_help()
+#         print
+#         print "Type 'openmano -h' for help"
+
+class openmanoclient():
+    headers_req = {'Accept': 'application/yaml', 'content-type': 'application/yaml'}
+    
+    def __init__(self, **kwargs):
+        self.username = kwargs.get("username")
+        self.password = kwargs.get("password")
+        self.endpoint_url = kwargs.get("endpoint_url")
+        self.tenant_id = kwargs.get("tenant_id")
+        self.tenant_name = kwargs.get("tenant_name")
+        self.tenant = None
+        self.datacenter_id = kwargs.get("datacenter_id")
+        self.datacenter_name = kwargs.get("datacenter_name")
+        self.datacenter = None
+        self.logger = logging.getLogger('manoclient')
+        if kwargs.get("debug"):
+            self.logger.setLevel(logging.DEBUG)
+        
+    def __getitem__(self, index):
+        if index=='tenant_name':
+            return self.tenant_name
+        elif index=='tenant_id':
+            return self.tenant_id
+        elif index=='datacenter_name':
+            return self.datacenter_name
+        elif index=='datacenter_id':
+            return self.datacenter_id
+        elif index=='username':
+            return self.username
+        elif index=='password':
+            return self.password
+        elif index=='endpoint_url':
+            return self.endpoint_url
+        else:
+            raise KeyError("Invalid key '%s'" %str(index))
+        
+    def __setitem__(self,index, value):
+        if index=='tenant_name':
+            self.tenant_name = value
+        elif index=='tenant_id':
+            self.tenant_id = value
+        elif index=='datacenter_name':
+            self.datacenter_name = value
+        elif index=='datacenter_id':
+            self.datacenter_id = value
+        elif index=='username':
+            self.username = value
+        elif index=='password':
+            self.password = value
+        elif index=='endpoint_url':
+            self.endpoint_url = value
+        else:
+            raise KeyError("Invalid key '%s'" %str(index)) 
+        self.tenant = None # force to reload tenant with different credentials
+        self.datacenter = None # force to reload datacenter with different credentials
+    
+    def _parse(self, descriptor, descriptor_format, response=False):
+        #try yaml
+        if descriptor_format and descriptor_format != "json" and descriptor_format != "yaml":
+            raise  OpenmanoBadParamsException("'descriptor_format' must be a 'json' or 'yaml' text")
+        if descriptor_format != "json":
+            try:
+                return yaml.load(descriptor)
+            except yaml.YAMLError as exc:
+                error_pos = ""
+                if hasattr(exc, 'problem_mark'):
+                    mark = exc.problem_mark
+                    error_pos = " at line:{} column:{}s".format(mark.line+1, mark.column+1)
+                error_text = "yaml format error" + error_pos
+        elif descriptor_format != "yaml":
+            try:
+                return json.loads(descriptor) 
+            except Exception as e:
+                if response:
+                    error_text = "json format error" + str(e)
+
+        if response:
+            raise OpenmanoResponseException(error_text)
+        raise  OpenmanoBadParamsException(error_text)
+    
+    def _parse_yaml(self, descriptor, response=False):
+        try:
+            return yaml.load(descriptor)
+        except yaml.YAMLError as exc:
+            error_pos = ""
+            if hasattr(exc, 'problem_mark'):
+                mark = exc.problem_mark
+                error_pos = " at line:{} column:{}s".format(mark.line+1, mark.column+1)
+            error_text = "yaml format error" + error_pos
+            if response:
+                raise OpenmanoResponseException(error_text)
+            raise  OpenmanoBadParamsException(error_text)
+
+    
+    def _get_item_uuid(self, item, item_id=None, item_name=None, all_tenants=False):
+        if all_tenants == None:
+            tenant_text = ""
+        elif all_tenants == False:
+            tenant_text = "/" + self.tenant
+        else:
+            tenant_text = "/any"
+        URLrequest = "{}{}/{}".format(self.endpoint_url, tenant_text, item)
+        self.logger.debug("GET %s", URLrequest )
+        mano_response = requests.get(URLrequest, headers=self.headers_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+        content = self._parse_yaml(mano_response.text, response=True)
+        #print content
+        found = 0
+        if not item_id and not item_name:
+            raise OpenmanoResponseException("Missing either {0}_name or {0}_id".format(item[:-1]))
+        for i in content[item]:
+            if item_id and i["uuid"] == item_id:
+                return item_id
+            elif item_name and i["name"] == item_name:
+                uuid = i["uuid"]
+                found += 1
+            
+        if found == 0:
+            if item_id:
+                raise OpenmanoNotFoundException("No {} found with id '{}'".format(item[:-1], item_id))
+            else:
+                #print(item, item_name)
+                raise OpenmanoNotFoundException("No {} found with name '{}'".format(item[:-1], item_name) )
+        elif found > 1:
+            raise OpenmanoNotFoundException("{} {} found with name '{}'. uuid must be used".format(found, item, item_name))
+        return uuid
+
+    def _get_item(self, item, uuid=None, name=None, all_tenants=False):
+        if all_tenants:
+            tenant_text = "/any"
+        elif all_tenants==None:
+            tenant_text = ""
+        else:
+            tenant_text = "/"+self._get_tenant()
+        if not uuid:
+            #check that exist
+            uuid = self._get_item_uuid(item, uuid, name, all_tenants)
+        
+        URLrequest = "{}{}/{}/{}".format(self.endpoint_url, tenant_text, item, uuid)
+        self.logger.debug("GET %s", URLrequest )
+        mano_response = requests.get(URLrequest, headers=self.headers_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+
+    def _get_tenant(self):
+        if not self.tenant:
+            self.tenant = self._get_item_uuid("tenants", self.tenant_id, self.tenant_name, None)
+        return self.tenant
+    
+    def _get_datacenter(self):
+        if not self.tenant:
+            self._get_tenant()
+        if not self.datacenter:
+            self.datacenter = self._get_item_uuid("datacenters", self.datacenter_id, self.datacenter_name, False)
+        return self.datacenter
+
+    def _create_item(self, item, descriptor, all_tenants=False):
+        if all_tenants:
+            tenant_text = "/any"
+        elif all_tenants==None:
+            tenant_text = ""
+        else:
+            tenant_text = "/"+self._get_tenant()
+        payload_req = yaml.safe_dump(descriptor)
+            
+        #print payload_req
+            
+        URLrequest = "{}{}/{}".format(self.endpoint_url, tenant_text, item)
+        self.logger.debug("openmano POST %s %s", URLrequest, payload_req)
+        mano_response = requests.post(URLrequest, headers = self.headers_req, data=payload_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+
+    def _del_item(self, item, uuid=None, name=None, all_tenants=False):
+        if all_tenants:
+            tenant_text = "/any"
+        elif all_tenants==None:
+            tenant_text = ""
+        else:
+            tenant_text = "/"+self._get_tenant()
+        if not uuid:
+            #check that exist
+            uuid = self._get_item_uuid(item, uuid, name, all_tenants)
+        
+        URLrequest = "{}{}/{}/{}".format(self.endpoint_url, tenant_text, item, uuid)
+        self.logger.debug("DELETE %s", URLrequest )
+        mano_response = requests.delete(URLrequest, headers = self.headers_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+    
+    def _list_item(self, item, all_tenants=False, filter_dict=None):
+        if all_tenants:
+            tenant_text = "/any"
+        elif all_tenants==None:
+            tenant_text = ""
+        else:
+            tenant_text = "/"+self._get_tenant()
+        
+        URLrequest = "{}{}/{}".format(self.endpoint_url, tenant_text, item)
+        separator="?"
+        if filter_dict:
+            for k in filter_dict:
+                URLrequest += separator + quote(str(k)) + "=" + quote(str(filter_dict[k])) 
+                separator = "&"
+        self.logger.debug("openmano GET %s", URLrequest)
+        mano_response = requests.get(URLrequest, headers=self.headers_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+
+    def _edit_item(self, item, descriptor, uuid=None, name=None, all_tenants=False):
+        if all_tenants:
+            tenant_text = "/any"
+        elif all_tenants==None:
+            tenant_text = ""
+        else:
+            tenant_text = "/"+self._get_tenant()
+
+        if not uuid:
+            #check that exist
+            uuid = self._get_item_uuid("tenants", uuid, name, all_tenants)
+        
+        payload_req = yaml.safe_dump(descriptor)
+            
+        #print payload_req
+            
+        URLrequest = "{}{}/{}/{}".format(self.endpoint_url, tenant_text, item, uuid)
+        self.logger.debug("openmano PUT %s %s", URLrequest, payload_req)
+        mano_response = requests.put(URLrequest, headers = self.headers_req, data=payload_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+
+    #TENANTS
+    def list_tenants(self, **kwargs):
+        '''Obtain a list of tenants
+        Params: can be filtered by 'uuid','name','description'
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'tenants':[{tenant1_info},{tenant2_info},...]}}
+        '''
+        return self._list_item("tenants", all_tenants=None, filter_dict=kwargs)
+
+    def get_tenant(self, uuid=None, name=None):
+        '''Obtain the information of a tenant
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several
+                Obtain a dictionary with format {'tenant':{tenant_info}}
+        '''
+        return self._get_item("tenants", uuid, name, all_tenants=None)
+
+    def delete_tenant(self, uuid=None, name=None):
+        '''Delete a tenant
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several
+                Obtain a dictionary with format {'result': text indicating deleted}
+        '''
+        return self._del_item("tenants", uuid, name, all_tenants=None)
+
+    def create_tenant(self, descriptor=None, descriptor_format=None, name=None, description=None):
+        '''Creates a tenant
+        Params: must supply a descriptor or/and just a name
+            descriptor: with format {'tenant':{new_tenant_info}}
+                newtenant_info must contain 'name', and optionally 'description'
+                must be a dictionary or a json/yaml text.
+            name: the tenant name. Overwrite descriptor name if any
+            description: tenant descriptor.. Overwrite descriptor description if any
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'tenant':{new_tenant_info}}
+        '''
+        if isinstance(descriptor, str):
+            descriptor = self._parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif name:
+            descriptor={"tenant": {"name": name}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+
+        if 'tenant' not in descriptor or len(descriptor)!=1:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'tenant' field")
+        if name:
+            descriptor['tenant']['name'] = name
+        if description:
+            descriptor['tenant']['description'] = description
+
+        return self._create_item("tenants", descriptor, all_tenants=None)
+
+    def edit_tenant(self, uuid=None, name=None, descriptor=None, descriptor_format=None, new_name=None, new_description=None):
+        '''Edit the parameters of a tenant
+        Params: must supply a descriptor or/and a new_name or new_description
+            uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+            descriptor: with format {'tenant':{params to change info}}
+                must be a dictionary or a json/yaml text.
+            name: the tenant name. Overwrite descriptor name if any
+            description: tenant descriptor.. Overwrite descriptor description if any
+        Return: Raises an exception on error, not found or found several
+                Obtain a dictionary with format {'tenant':{newtenant_info}}
+        '''
+
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif new_name or new_description:
+            descriptor={"tenant": {}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+
+        if 'tenant' not in descriptor or len(descriptor)!=1:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'tenant' field")
+        if new_name:
+            descriptor['tenant']['name'] = new_name
+        if new_description:
+            descriptor['tenant']['description'] = new_description
+
+        return self._edit_item("tenants", descriptor, uuid, name, all_tenants=None)
+
+    #DATACENTERS
+
+    def list_datacenters(self, all_tenants=False, **kwargs):
+        '''Obtain a list of datacenters, that are the VIM information at openmano
+        Params: can be filtered by 'uuid','name','vim_url','type'
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'datacenters':[{datacenter1_info},{datacenter2_info},...]}}
+        '''
+        return self._list_item("datacenters", all_tenants, filter_dict=kwargs)
+
+    def get_datacenter(self, uuid=None, name=None, all_tenants=False):
+        '''Obtain the information of a datacenter
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several
+                Obtain a dictionary with format {'datacenter':{datacenter_info}}
+        '''
+        return self._get_item("datacenters", uuid, name, all_tenants)
+
+    def delete_datacenter(self, uuid=None, name=None):
+        '''Delete a datacenter
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several, not free
+                Obtain a dictionary with format {'result': text indicating deleted}
+        '''
+        return self._del_item("datacenters", uuid, name, all_tenants=True)
+
+    def create_datacenter(self, descriptor=None, descriptor_format=None, name=None, vim_url=None, **kwargs):
+#, type="openvim", public=False, description=None):
+        '''Creates a datacenter
+        Params: must supply a descriptor or/and just a name and vim_url
+            descriptor: with format {'datacenter':{new_datacenter_info}}
+                newdatacenter_info must contain 'name', 'vim_url', and optionally 'description'
+                must be a dictionary or a json/yaml text.
+            name: the datacenter name. Overwrite descriptor name if any
+            vim_url: the datacenter URL. Overwrite descriptor vim_url if any
+            vim_url_admin: the datacenter URL for administrative issues. Overwrite descriptor vim_url if any
+            vim_type: the datacenter type, can be openstack or openvim. Overwrite descriptor type if any
+            public: boolean, by default not public
+            description: datacenter description. Overwrite descriptor description if any
+            config: dictionary with extra configuration for the concrete datacenter
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'datacenter':{new_datacenter_info}}
+        '''
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif name and vim_url:
+            descriptor={"datacenter": {"name": name, "vim_url": vim_url}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor, or name and vim_url")
+        
+        if 'datacenter' not in descriptor or len(descriptor)!=1:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'datacenter' field")
+        if name:
+            descriptor['datacenter']['name'] = name
+        if vim_url:
+            descriptor['datacenter']['vim_url'] = vim_url
+        for param in kwargs:
+            descriptor['datacenter'][param] = kwargs[param]
+
+        return self._create_item("datacenters", descriptor, all_tenants=None)
+
+    def edit_datacenter(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs):
+        '''Edit the parameters of a datacenter
+        Params: must supply a descriptor or/and a parameter to change
+            uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+            descriptor: with format {'datacenter':{params to change info}}
+                must be a dictionary or a json/yaml text.
+            parameters to change can be supplyied by the descriptor or as parameters:
+                new_name: the datacenter name
+                vim_url: the datacenter URL
+                vim_url_admin: the datacenter URL for administrative issues
+                vim_type: the datacenter type, can be openstack or openvim.
+                public: boolean, available to other tenants
+                description: datacenter description
+        Return: Raises an exception on error, not found or found several
+                Obtain a dictionary with format {'datacenter':{new_datacenter_info}}
+        '''
+
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif kwargs:
+            descriptor={"datacenter": {}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+
+        if 'datacenter' not in descriptor or len(descriptor)!=1:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'datacenter' field")
+        for param in kwargs:
+            if param=='new_name':
+                descriptor['datacenter']['name'] = kwargs[param]
+            else:
+                descriptor['datacenter'][param] = kwargs[param]
+        return self._edit_item("datacenters", descriptor, uuid, name, all_tenants=None)
+    
+    def attach_datacenter(self, uuid=None, name=None, descriptor=None, descriptor_format=None,  vim_user=None, vim_password=None, vim_tenant_name=None, vim_tenant_id=None):
+        #check that exist
+        uuid = self._get_item_uuid("datacenters", uuid, name, all_tenants=True)
+        tenant_text = "/"+self._get_tenant()
+
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif vim_user or vim_password or vim_tenant_name or vim_tenant_id:
+            descriptor={"datacenter": {}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor or params")
+        
+        if vim_user or vim_password or vim_tenant_name or vim_tenant_id:
+            #print args.name
+            try:
+                if vim_user:
+                    descriptor['datacenter']['vim_user'] = vim_user
+                if vim_password:
+                    descriptor['datacenter']['vim_password'] = vim_password
+                if vim_tenant_name:
+                    descriptor['datacenter']['vim_tenant_name'] = vim_tenant_name
+                if vim_tenant_id:
+                    descriptor['datacenter']['vim_tenant'] = vim_tenant_id
+            except (KeyError, TypeError) as e:
+                if str(e)=='datacenter':           error_pos= "missing field 'datacenter'"
+                else:                       error_pos="wrong format"
+                raise OpenmanoBadParamsException("Wrong datacenter descriptor: " + error_pos)
+
+        payload_req = yaml.safe_dump(descriptor)
+        #print payload_req
+        URLrequest = "{}{}/datacenters/{}".format(self.endpoint_url, tenant_text, uuid)
+        self.logger.debug("openmano POST %s %s", URLrequest, payload_req)
+        mano_response = requests.post(URLrequest, headers = self.headers_req, data=payload_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+
+    def detach_datacenter(self, uuid=None, name=None):
+        if not uuid:
+            #check that exist
+            uuid = self._get_item_uuid("datacenters", uuid, name, all_tenants=False)
+        tenant_text = "/"+self._get_tenant()
+        URLrequest = "{}{}/datacenters/{}".format(self.endpoint_url, tenant_text, uuid)
+        self.logger.debug("openmano DELETE %s", URLrequest)
+        mano_response = requests.delete(URLrequest, headers = self.headers_req)
+        self.logger.debug("openmano response: %s", mano_response.text )
+    
+        content = self._parse_yaml(mano_response.text, response=True)
+        if mano_response.status_code==200:
+            return content
+        else:
+            raise OpenmanoResponseException(str(content))        
+
+    #VNFS
+    def list_vnfs(self, all_tenants=False, **kwargs):
+        '''Obtain a list of vnfs
+        Params: can be filtered by 'uuid','name','description','public', "tenant_id"
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'vnfs':[{vnf1_info},{vnf2_info},...]}}
+        '''
+        return self._list_item("vnfs", all_tenants, kwargs)
+
+    def get_vnf(self, uuid=None, name=None, all_tenants=False):
+        '''Obtain the information of a vnf
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several
+                Obtain a dictionary with format {'vnf':{vnf_info}}
+        '''
+        return self._get_item("vnfs", uuid, name, all_tenants)
+
+    def delete_vnf(self, uuid=None, name=None, all_tenants=False):
+        '''Delete a vnf
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several, not free
+                Obtain a dictionary with format {'result': text indicating deleted}
+        '''
+        return self._del_item("vnfs", uuid, name, all_tenants)
+
+    def create_vnf(self, descriptor=None, descriptor_format=None, **kwargs):
+        '''Creates a vnf
+        Params: must supply a descriptor
+            descriptor: with format {'vnf':{new_vnf_info}}
+                must be a dictionary or a json/yaml text.
+                must be a dictionary or a json/yaml text.
+            Other parameters can be:
+                name: the vnf name. Overwrite descriptor name if any
+                image_path: Can be a string or a string list. Overwrite the image_path at descriptor
+                description: vnf descriptor.. Overwrite descriptor description if any
+                public: boolean, available to other tenants
+                class: user text for vnf classification
+                tenant_id: Propietary tenant
+                ...
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'vnf':{new_vnf_info}}
+        '''
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+        
+        if 'vnf' not in descriptor or len(descriptor)>2:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'vnf' field, and an optional version")
+        for param in kwargs:
+            if param == 'image_path':
+                #print args.name
+                try:
+                    if isinstance(kwargs[param], str):
+                        descriptor['vnf']['VNFC'][0]['VNFC image']=kwargs[param]
+                    elif isinstance(kwargs[param], tuple) or isinstance(kwargs[param], list):
+                        index=0
+                        for image_path_ in kwargs[param]:
+                            #print "image-path", image_path_
+                            descriptor['vnf']['VNFC'][index]['VNFC image']=image_path_
+                            index=index+1
+                    else:
+                        raise OpenmanoBadParamsException("Wrong image_path type. Expected text or a text list")
+                except (KeyError, TypeError) as e:
+                    if str(e)=='vnf':           error_pos= "missing field 'vnf'"
+                    elif str(e)=='VNFC':        error_pos= "missing field  'vnf':'VNFC'"
+                    elif str(e)==str(index):    error_pos= "field  'vnf':'VNFC' must be an array"
+                    elif str(e)=='VNFC image':  error_pos= "missing field 'vnf':'VNFC'['VNFC image']"
+                    else:                       error_pos="wrong format"
+                    raise OpenmanoBadParamsException("Wrong VNF descriptor: " + error_pos)
+            else:
+                descriptor['vnf'][param] = kwargs[param]
+        return self._create_item("vnfs", descriptor)
+
+#     def edit_vnf(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs):
+#         '''Edit the parameters of a vnf
+#         Params: must supply a descriptor or/and a parameters to change
+#             uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+#             descriptor: with format {'vnf':{params to change info}}
+#             parameters to change can be supplyied by the descriptor or as parameters:
+#                 new_name: the vnf name
+#                 vim_url: the vnf URL
+#                 vim_url_admin: the vnf URL for administrative issues
+#                 vim_type: the vnf type, can be openstack or openvim.
+#                 public: boolean, available to other tenants
+#                 description: vnf description
+#         Return: Raises an exception on error, not found or found several
+#                 Obtain a dictionary with format {'vnf':{new_vnf_info}}
+#         '''
+# 
+#        if isinstance(descriptor, str):
+#            descriptor = self.parse(descriptor, descriptor_format)
+#        elif descriptor:
+#            pass
+#         elif kwargs:
+#             descriptor={"vnf": {}}
+#         else:
+#             raise OpenmanoBadParamsException("Missing descriptor")
+# 
+#         if 'vnf' not in descriptor or len(descriptor)>2:
+#             raise OpenmanoBadParamsException("Descriptor must contain only one 'vnf' field")
+#         for param in kwargs:
+#             if param=='new_name':
+#                 descriptor['vnf']['name'] = kwargs[param]
+#             else:
+#                 descriptor['vnf'][param] = kwargs[param]
+#         return self._edit_item("vnfs", descriptor, uuid, name, all_tenants=None)
+
+    #SCENARIOS
+    def list_scenarios(self, all_tenants=False, **kwargs):
+        '''Obtain a list of scenarios
+        Params: can be filtered by 'uuid','name','description','public', "tenant_id"
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'scenarios':[{scenario1_info},{scenario2_info},...]}}
+        '''
+        return self._list_item("scenarios", all_tenants, kwargs)
+
+    def get_scenario(self, uuid=None, name=None, all_tenants=False):
+        '''Obtain the information of a scenario
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several
+                Obtain a dictionary with format {'scenario':{scenario_info}}
+        '''
+        return self._get_item("scenarios", uuid, name, all_tenants)
+
+    def delete_scenario(self, uuid=None, name=None, all_tenants=False):
+        '''Delete a scenario
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several, not free
+                Obtain a dictionary with format {'result': text indicating deleted}
+        '''
+        return self._del_item("scenarios", uuid, name, all_tenants)
+
+    def create_scenario(self, descriptor=None, descriptor_format=None, **kwargs):
+        '''Creates a scenario
+        Params: must supply a descriptor
+            descriptor: with format {'scenario':{new_scenario_info}}
+                must be a dictionary or a json/yaml text.
+            Other parameters can be:
+                name: the scenario name. Overwrite descriptor name if any
+                description: scenario descriptor.. Overwrite descriptor description if any
+                public: boolean, available to other tenants
+                tenant_id. Propietary tenant
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'scenario':{new_scenario_info}}
+        '''
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+        
+        if 'scenario' not in descriptor or len(descriptor)>2:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'scenario' field, and an optional version")
+        for param in kwargs:
+            descriptor['scenario'][param] = kwargs[param]
+        return self._create_item("scenarios", descriptor)
+
+    def edit_scenario(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs):
+        '''Edit the parameters of a scenario
+        Params: must supply a descriptor or/and a parameters to change
+            uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+            descriptor: with format {'scenario':{params to change info}}
+                must be a dictionary or a json/yaml text.
+            parameters to change can be supplyied by the descriptor or as parameters:
+                new_name: the scenario name
+                public: boolean, available to other tenants
+                description: scenario description
+                tenant_id. Propietary tenant
+        Return: Raises an exception on error, not found or found several
+                Obtain a dictionary with format {'scenario':{new_scenario_info}}
+        '''
+ 
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif kwargs:
+            descriptor={"scenario": {}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+ 
+        if 'scenario' not in descriptor or len(descriptor)>2:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'scenario' field")
+        for param in kwargs:
+            if param=='new_name':
+                descriptor['scenario']['name'] = kwargs[param]
+            else:
+                descriptor['scenario'][param] = kwargs[param]
+        return self._edit_item("scenarios", descriptor, uuid, name, all_tenants=None)
+
+
+    #INSTANCE-SCENARIOS
+    def list_instances(self, all_tenants=False, **kwargs):
+        '''Obtain a list of instances
+        Params: can be filtered by 'uuid','name','description','scenario_id', "tenant_id"
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'instances':[{instance1_info},{instance2_info},...]}}
+        '''
+        return self._list_item("instances", all_tenants, kwargs)
+
+    def get_instance(self, uuid=None, name=None, all_tenants=False):
+        '''Obtain the information of a instance
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several
+                Obtain a dictionary with format {'instance':{instance_info}}
+        '''
+        return self._get_item("instances", uuid, name, all_tenants)
+
+    def delete_instance(self, uuid=None, name=None, all_tenants=False):
+        '''Delete a instance
+        Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised
+        Return: Raises an exception on error, not found, found several, not free
+                Obtain a dictionary with format {'result': text indicating deleted}
+        '''
+        return self._del_item("instances", uuid, name, all_tenants)
+
+    def create_instance(self, descriptor=None, descriptor_format=None, name=None, **kwargs):
+        '''Creates a instance
+        Params: must supply a descriptor or/and a name and scenario
+            descriptor: with format {'instance':{new_instance_info}}
+                must be a dictionary or a json/yaml text.
+            name: the instance name. Overwrite descriptor name if any
+            Other parameters can be:
+                description: instance descriptor.. Overwrite descriptor description if any
+                datacenter_name, datacenter_id: datacenter  where to be deployed
+                scenario_name, scenario_id: Scenario this instance is based on
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'instance':{new_instance_info}}
+        '''
+        if isinstance(descriptor, str):
+            descriptor = self.parse(descriptor, descriptor_format)
+        elif descriptor:
+            pass
+        elif name and ("scenario_name" in kwargs or "scenario_id" in kwargs):
+            descriptor = {"instance":{"name": name}}
+        else:
+            raise OpenmanoBadParamsException("Missing descriptor")
+        
+        if 'instance' not in descriptor or len(descriptor)>2:
+            raise OpenmanoBadParamsException("Descriptor must contain only one 'instance' field, and an optional version")
+        if name:
+            descriptor['instance']["name"] = name
+        if "scenario_name" in kwargs or "scenario_id" in kwargs:
+            descriptor['instance']["scenario"] = self._get_item_uuid("scenarios", kwargs.get("scenario_id"), kwargs.get("scenario_name"))
+        if "datacenter_name" in kwargs or "datacenter_id" in kwargs:
+            descriptor['instance']["datacenter"] = self._get_item_uuid("datacenters", kwargs.get("datacenter_id"), kwargs.get("datacenter_name"))
+        if "description" in kwargs:
+            descriptor['instance']["description"] = kwargs.get("description")
+        #for param in kwargs:
+        #    descriptor['instance'][param] = kwargs[param]
+        if "datacenter" not in descriptor['instance']:
+            descriptor['instance']["datacenter"] = self._get_datacenter()
+        return self._create_item("instances", descriptor)
+
+    #VIM ACTIONS
+    def vim_action(self, action, item, uuid=None, all_tenants=False, **kwargs):
+        '''Perform an action over a vim
+        Params: 
+            action: can be 'list', 'get'/'show', 'delete' or 'create'
+            item: can be 'tenants' or 'networks'
+            uuid: uuid of the tenant/net to show or to delete. Ignore otherwise
+            other parameters:
+                datacenter_name, datacenter_id: datacenters to act on, if missing uses classes store datacenter 
+                descriptor, descriptor_format: descriptor needed on creation, can be a dict or a yaml/json str 
+                    must be a dictionary or a json/yaml text.
+                name: for created tenant/net Overwrite descriptor name if any
+                description: tenant descriptor. Overwrite descriptor description if any
+                
+        Return: Raises an exception on error
+                Obtain a dictionary with format {'tenant':{new_tenant_info}}
+        '''
+        if item not in ("tenants", "networks"):
+            raise OpenmanoBadParamsException("Unknown value for item '{}', must be 'tenants' or 'nets'".format(str(item))) 
+
+        if all_tenants:
+            tenant_text = "/any"
+        else:
+            tenant_text = "/"+self._get_tenant()
+        
+        if "datacenter_id" in kwargs or "datacenter_name" in kwargs:
+            datacenter = self._get_item_uuid("datacenters", kwargs.get("datacenter_id"), kwargs.get("datacenter_name"), all_tenants=all_tenants)
+        else:
+            datacenter = self._get_datacenter()
+
+        if action=="list":
+            URLrequest = "{}{}/vim/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item)
+            self.logger.debug("GET %s", URLrequest )
+            mano_response = requests.get(URLrequest, headers=self.headers_req)
+            self.logger.debug("openmano response: %s", mano_response.text )
+            content = self._parse_yaml(mano_response.text, response=True)            
+            if mano_response.status_code==200:
+                return content
+            else:
+                raise OpenmanoResponseException(str(content))        
+        elif action=="get" or action=="show":
+            URLrequest = "{}{}/vim/{}/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item, uuid)
+            self.logger.debug("GET %s", URLrequest )
+            mano_response = requests.get(URLrequest, headers=self.headers_req)
+            self.logger.debug("openmano response: %s", mano_response.text )
+            content = self._parse_yaml(mano_response.text, response=True)            
+            if mano_response.status_code==200:
+                return content
+            else:
+                raise OpenmanoResponseException(str(content))        
+        elif action=="delete":
+            URLrequest = "{}{}/vim/{}/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item, uuid)
+            self.logger.debug("DELETE %s", URLrequest )
+            mano_response = requests.delete(URLrequest, headers=self.headers_req)
+            self.logger.debug("openmano response: %s", mano_response.text )
+            content = self._parse_yaml(mano_response.text, response=True)            
+            if mano_response.status_code==200:
+                return content
+            else:
+                raise OpenmanoResponseException(str(content))        
+        elif action=="create":
+            if "descriptor" in kwargs:
+                if isinstance(kwargs["descriptor"], str):
+                    descriptor = self._parse(kwargs["descriptor"], kwargs.get("descriptor_format") )
+                else:
+                    descriptor = kwargs["descriptor"]
+            elif "name" in kwargs:
+                descriptor={item[:-1]: {"name": kwargs["name"]}}
+            else:
+                raise OpenmanoResponseException("Missing descriptor")
+        
+            if item[:-1] not in descriptor or len(descriptor)!=1:
+                raise OpenmanoBadParamsException("Descriptor must contain only one 'tenant' field")
+            if "name" in kwargs:
+                descriptor[ item[:-1] ]['name'] = kwargs["name"]
+            if "description" in kwargs:
+                descriptor[ item[:-1] ]['description'] = kwargs["description"]
+            payload_req = yaml.safe_dump(descriptor)
+            #print payload_req
+            URLrequest = "{}{}/vim/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item)
+            self.logger.debug("openmano POST %s %s", URLrequest, payload_req)
+            mano_response = requests.post(URLrequest, headers = self.headers_req, data=payload_req)
+            self.logger.debug("openmano response: %s", mano_response.text )
+            content = self._parse_yaml(mano_response.text, response=True)
+            if mano_response.status_code==200:
+                return content
+            else:
+                raise OpenmanoResponseException(str(content))
+        else:
+            raise OpenmanoBadParamsException("Unknown value for action '{}".format(str(action))) 
+
diff --git a/scenarios/scenario-template2.yaml b/scenarios/scenario-template2.yaml
new file mode 100644
index 00000000..9612802e
--- /dev/null
+++ b/scenarios/scenario-template2.yaml
@@ -0,0 +1,35 @@
+---
+schema_version:  2
+scenario:
+  name:          insert a name for the scenario
+  description:   insert a description for the scenario
+  public:        false      # if available for other tenants
+  vnfs:
+    vnf1:                     # vnf name in the scenario
+      #identify an already openmano uploaded VNF either by vnf_id (uuid, prefered) or vnf_name
+      vnf_id:    fb356022-f664-11e5-a1e7-0800273e724c                  #prefered id method
+      #vnf_name:  openmano_vnf_name   #can fail if several vnfs matches this name 
+      #graph:     {"y":399,"x":332,"ifaces":{"left":[["xe0","d"],["xe1","d"]],"bottom":[["eth0","v"],["eth1","m"]]}}
+    vnf2:
+      vnf_name:  vnf_name_2 # can fail if several vnfs matches this name 
+      graph:     {"y":399,"x":632,"ifaces":{"left":[["xe0","d"],["xe1","d"]],"bottom":[["eth0","v"],["eth1","m"]]}}
+  networks:                
+    net1:                     # network name in the scenario
+      #optional type, deduced from interfaces
+      type:      dataplane # "dataplane", "bridge"  
+      #graph:     {}
+      interfaces:                  # nodes that will be connected: one or several vnfs
+      -  vnf1:   xe0            # First node and its interface to be connected (interfaces must match to one in the VNF descriptor)
+      -  vnf2:   xe0            # Second node and its interface
+    control net:
+      # Control plane connections must include a bridge network in the list of nodes
+      interfaces:
+      -   vnf1:  eth1
+      -   vnf2:  eth1
+    out:
+      # Connections based on external networks (datacenter nets) must include the external network in the list of nodes
+      type:      dataplane
+      external:  true       #this will be connected outside
+      interfaces:
+      -   vnf1:  xe1
+
diff --git a/vimconn.py b/vimconn.py
old mode 100755
new mode 100644
index 6702c5f8..7ae33592
--- a/vimconn.py
+++ b/vimconn.py
@@ -38,26 +38,31 @@ HTTP_Conflict = 409
 HTTP_Service_Unavailable = 503 
 HTTP_Internal_Server_Error = 500 
 
+class vimconnectorException(Exception):
+    pass
 
 class vimconnector():
     '''Abstract base class for all the VIM connector plugins
     These plugins must implement a vimconnector class deribed from this 
     and all these methods
     ''' 
-    def __init__(self, uuid, name, tenant, url, url_admin=None, user=None, passwd=None,debug=True,config={}):
+    def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,debug=True,config={}):
         self.id        = uuid
         self.name      = name
         self.url       = url
         self.url_admin = url_admin
-        self.tenant    = tenant
+        self.tenant_id = tenant_id
+        self.tenant_name = tenant_name
         self.user      = user
         self.passwd    = passwd
         self.config    = config
         self.debug     = debug
     
     def __getitem__(self,index):
-        if index=='tenant':
-            return self.tenant
+        if index=='tenant_id':
+            return self.tenant_id
+        if index=='tenant_name':
+            return self.tenant_name
         elif index=='id':
             return self.id
         elif index=='name':
@@ -76,8 +81,10 @@ class vimconnector():
             raise KeyError("Invalid key '%s'" %str(index))
         
     def __setitem__(self,index, value):
-        if index=='tenant':
-            self.tenant = value
+        if index=='tenant_id':
+            self.tenant_id = value
+        if index=='tenant_name':
+            self.tenant_name = value
         elif index=='id':
             self.id = value
         elif index=='name':
diff --git a/vimconn_openstack.py b/vimconn_openstack.py
index 3a323a83..242acb75 100644
--- a/vimconn_openstack.py
+++ b/vimconn_openstack.py
@@ -54,12 +54,12 @@ netStatus2manoFormat={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE',
                      }
 
 class vimconnector(vimconn.vimconnector):
-    def __init__(self, uuid, name, tenant, url, url_admin=None, user=None, passwd=None, debug=True, config={}):
+    def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, debug=True, config={}):
         '''using common constructor parameters. In this case 
         'url' is the keystone authorization url,
         'url_admin' is not use
         '''
-        vimconn.vimconnector.__init__(self, uuid, name, tenant, url, url_admin, user, passwd, debug, config)
+        vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, debug, config)
         
         self.k_creds={}
         self.n_creds={}
@@ -67,9 +67,12 @@ class vimconnector(vimconn.vimconnector):
             raise TypeError, 'url param can not be NoneType'
         self.k_creds['auth_url'] = url
         self.n_creds['auth_url'] = url
-        if tenant:
-            self.k_creds['tenant_name'] = tenant
-            self.n_creds['project_id']  = tenant
+        if tenant_name:
+            self.k_creds['tenant_name'] = tenant_name
+            self.n_creds['project_id']  = tenant_name
+        if tenant_id:
+            self.k_creds['tenant_id'] = tenant_id
+            self.n_creds['tenant_id']  = tenant_id
         if user:
             self.k_creds['username'] = user
             self.n_creds['username'] = user
@@ -82,9 +85,18 @@ class vimconnector(vimconn.vimconnector):
         '''Set individuals parameters 
         Throw TypeError, KeyError
         '''
-        if index=='tenant':
+        if index=='tenant_id':
+            self.reload_client=True
+            self.tenant_id = value
+            if value:
+                self.k_creds['tenant_id'] = value
+                self.n_creds['tenant_id']  = value
+            else:
+                del self.k_creds['tenant_name']
+                del self.n_creds['project_id']
+        elif index=='tenant_name':
             self.reload_client=True
-            self.tenant = value
+            self.tenant_name = value
             if value:
                 self.k_creds['tenant_name'] = value
                 self.n_creds['project_id']  = value
@@ -258,7 +270,7 @@ class vimconnector(vimconn.vimconnector):
         '''Adds a tenant network to VIM'''
         '''Returns the network identifier'''
         if self.debug:
-            print "osconnector: Adding a new tenant network to VIM (tenant: " + self.tenant + ", type: " + net_type + "): "+ net_name
+            print "osconnector: Adding a new tenant network to VIM (tenant: " + str(self.tenant_name) + ", type: " + net_type + "): "+ net_name
         try:
             self._reload_connection()
             network_dict = {'name': net_name, 'admin_state_up': True}
@@ -359,7 +371,7 @@ class vimconnector(vimconn.vimconnector):
         '''Deletes a tenant network from VIM'''
         '''Returns the network identifier'''
         if self.debug:
-            print "osconnector: Deleting a new tenant network from VIM tenant: " + self.tenant + ", id: " + net_id
+            print "osconnector: Deleting a new tenant network from VIM tenant: " + str(self.tenant_name) + ", id: " + net_id
         try:
             self._reload_connection()
             #delete VM ports attached to this networks before the network
diff --git a/vimconn_openvim.py b/vimconn_openvim.py
old mode 100755
new mode 100644
index 6dfd474c..e253b4e4
--- a/vimconn_openvim.py
+++ b/vimconn_openvim.py
@@ -306,9 +306,40 @@ get_processor_rankings_response_schema = {
 }
 
 class vimconnector(vimconn.vimconnector):
-    def __init__(self, uuid, name, tenant, url, url_admin=None, user=None, passwd=None,debug=True,config={}):
-        vimconn.vimconnector.__init__(self, uuid, name, tenant, url, url_admin, user, passwd, debug, config)
-    
+    def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,debug=True,config={}):
+        vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, debug, config)
+        self.tenant = None
+        self.headers_req = {'content-type': 'application/json'}
+        if tenant_id:
+            self.tenant = tenant_id
+
+    def __setitem__(self,index, value):
+        '''Set individuals parameters 
+        Throw TypeError, KeyError
+        '''
+        if index=='tenant_id':
+            self.tenant = value
+        elif index=='tenant_name':
+            self.tenant = None
+        vimconn.vimconnector.__setitem__(self,index, value)    
+
+    def _get_my_tenant(self):
+        '''Obtain uuid of my tenant from name
+        '''
+        if self.tenant:
+            return self.tenant
+
+        vim_response = requests.get(self.url+'/tenants?name='+ self.tenant_name, headers = self.headers_req)
+        if vim_response.status_code != 200:
+            raise vimconn.vimconnectorException ("_get_my_tenant response " + str(vim_response.status_code))
+        tenant_list = vim_response.json()["tenants"]
+        if len(tenant_list) == 0:
+            raise vimconn.vimconnectorException ("No tenant found for name '%s'" % str(self.tenant_name))
+        elif len(tenant_list) > 1:
+            raise vimconn.vimconnectorException ("More that one tenant found for name '%s'" % str(self.tenant_name))
+        self.tenant = tenant_list[0]["id"]
+        return self.tenant 
+
     def _format_jsonerror(self,http_response):
         try:
             data = http_response.json()
@@ -348,10 +379,9 @@ class vimconnector(vimconn.vimconnector):
         '''Adds a new host to VIM'''
         '''Returns status code of the VIM response'''
         print "VIMConnector: Adding a new host"
-        headers_req = {'content-type': 'application/json'}
         payload_req = host_data
         try:
-            vim_response = requests.post(self.url_admin+'/hosts', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url_admin+'/hosts', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_host Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -381,10 +411,9 @@ class vimconnector(vimconn.vimconnector):
         '''Adds a external port to VIM'''
         '''Returns the port identifier'''
         print "VIMConnector: Adding a new external port"
-        headers_req = {'content-type': 'application/json'}
         payload_req = port_data
         try:
-            vim_response = requests.post(self.url_admin+'/ports', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url_admin+'/ports', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_external_port Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -415,10 +444,9 @@ class vimconnector(vimconn.vimconnector):
         '''Returns the network identifier'''
         print "VIMConnector: Adding external shared network to VIM (type " + net_type + "): "+ net_name
         
-        headers_req = {'content-type': 'application/json'}
         payload_req = '{"network":{"name": "' + net_name + '","shared":true,"type": "' + net_type + '"}}'
         try:
-            vim_response = requests.post(self.url+'/networks', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url+'/networks', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_external_network Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -449,7 +477,6 @@ class vimconnector(vimconn.vimconnector):
         '''Returns status code of the VIM response'''
         print "VIMConnector: Connecting external port to network"
         
-        headers_req = {'content-type': 'application/json'}
         payload_req = '{"port":{"network_id":"' + network_id + '"}}'
         if admin:
             if self.url_admin==None:
@@ -458,7 +485,7 @@ class vimconnector(vimconn.vimconnector):
         else:
             url= self.url
         try:
-            vim_response = requests.put(url +'/ports/'+port_id, headers = headers_req, data=payload_req)
+            vim_response = requests.put(url +'/ports/'+port_id, headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "connect_port_network Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -488,13 +515,12 @@ class vimconnector(vimconn.vimconnector):
         '''Adds a new tenant to VIM'''
         '''Returns the tenant identifier'''
         print "VIMConnector: Adding a new tenant to VIM"
-        headers_req = {'content-type': 'application/json'}
         payload_dict = {"tenant": {"name":tenant_name,"description": tenant_description, "enabled": True}}
         payload_req = json.dumps(payload_dict)
         #print payload_req
 
         try:
-            vim_response = requests.post(self.url+'/tenants', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url+'/tenants', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_tenant Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -523,9 +549,8 @@ class vimconnector(vimconn.vimconnector):
         '''Delete a tenant from VIM'''
         '''Returns the tenant identifier'''
         print "VIMConnector: Deleting  a  tenant from VIM"
-        headers_req = {'content-type': 'application/json'}
         try:
-            vim_response = requests.delete(self.url+'/tenants/'+tenant_id, headers = headers_req)
+            vim_response = requests.delete(self.url+'/tenants/'+tenant_id, headers = self.headers_req)
         except requests.exceptions.RequestException, e:
             print "delete_tenant Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -542,16 +567,19 @@ class vimconnector(vimconn.vimconnector):
     def new_tenant_network(self,net_name,net_type,public=False, **vim_specific):
         '''Adds a tenant network to VIM'''
         '''Returns the network identifier'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "vim_specific", vim_specific
         if net_type=="bridge":
             net_type="bridge_data"
-        print "VIMConnector: Adding a new tenant network to VIM (tenant: " + self.tenant + ", type: " + net_type + "): "+ net_name
+        print "VIMConnector: Adding a new tenant network to VIM (tenant: " + str(self.tenant) + ", type: " + net_type + "): "+ net_name
 
-        headers_req = {'content-type': 'application/json'}
         payload_req = {"name": net_name, "type": net_type, "tenant_id": self.tenant, "shared": public}
         payload_req.update(vim_specific)
         try:
-            vim_response = requests.post(self.url+'/networks', headers = headers_req, data=json.dumps({"network": payload_req}) )
+            vim_response = requests.post(self.url+'/networks', headers = self.headers_req, data=json.dumps({"network": payload_req}) )
         except requests.exceptions.RequestException, e:
             print "new_tenant_network Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -591,10 +619,9 @@ class vimconnector(vimconn.vimconnector):
             filterquery.append(str(k)+'='+str(v))
         if len(filterquery)>0:
             filterquery_text='?'+ '&'.join(filterquery)
-        headers_req = {'content-type': 'application/json'}
         try:
             print self.url+'/tenants'+filterquery_text
-            vim_response = requests.get(self.url+'/tenants'+filterquery_text, headers = headers_req)
+            vim_response = requests.get(self.url+'/tenants'+filterquery_text, headers = self.headers_req)
         except requests.exceptions.RequestException, e:
             print "get_tenant_list Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -624,6 +651,8 @@ class vimconnector(vimconn.vimconnector):
             status: 'ACTIVE'
         Returns the network list of dictionaries
         '''
+        
+        filter_dict["tenant_id"] = self._get_my_tenant()
         print "VIMConnector.get_network_list: Getting tenant network from VIM (filter: " + str(filter_dict) + "): "
         filterquery=[]
         filterquery_text=''
@@ -631,10 +660,9 @@ class vimconnector(vimconn.vimconnector):
             filterquery.append(str(k)+'='+str(v))
         if len(filterquery)>0:
             filterquery_text='?'+ '&'.join(filterquery)
-        headers_req = {'content-type': 'application/json'}
         try:
             print self.url+'/networks'+filterquery_text
-            vim_response = requests.get(self.url+'/networks'+filterquery_text, headers = headers_req)
+            vim_response = requests.get(self.url+'/networks'+filterquery_text, headers = self.headers_req)
         except requests.exceptions.RequestException, e:
             print "get_network_list Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -673,11 +701,14 @@ class vimconnector(vimconn.vimconnector):
     def delete_tenant_network(self, net_id):
         '''Deletes a tenant network from VIM'''
         '''Returns the network identifier'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Deleting a new tenant network from VIM tenant: " + self.tenant + ", id: " + net_id
 
-        headers_req = {'content-type': 'application/json'}
         try:
-            vim_response = requests.delete(self.url+'/networks/'+net_id, headers=headers_req)
+            vim_response = requests.delete(self.url+'/networks/'+net_id, headers=self.headers_req)
         except requests.exceptions.RequestException, e:
             print "delete_tenant_network Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -703,13 +734,16 @@ class vimconnector(vimconn.vimconnector):
         '''Obtain flavor details from the  VIM
             Returns the flavor dict details
         '''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Getting flavor from VIM"
         #print "VIM URL:",self.url
         #print "Tenant id:",self.tenant
         #print "Flavor:",flavor_data
-        headers_req = {'content-type': 'application/json'}
         try:
-            vim_response = requests.get(self.url+'/'+self.tenant+'/flavors/'+flavor_id, headers = headers_req)
+            vim_response = requests.get(self.url+'/'+self.tenant+'/flavors/'+flavor_id, headers = self.headers_req)
         except requests.exceptions.RequestException, e:
             print "get_tenant_flavor Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -739,14 +773,17 @@ class vimconnector(vimconn.vimconnector):
     def new_tenant_flavor(self, flavor_data):
         '''Adds a tenant flavor to VIM'''
         '''Returns the flavor identifier'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Adding a new flavor to VIM"
         #print "VIM URL:",self.url
         #print "Tenant id:",self.tenant
         #print "Flavor:",flavor_data
-        headers_req = {'content-type': 'application/json'}
         payload_req = json.dumps({'flavor': flavor_data})
         try:
-            vim_response = requests.post(self.url+'/'+self.tenant+'/flavors', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url+'/'+self.tenant+'/flavors', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_tenant_flavor Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -776,11 +813,14 @@ class vimconnector(vimconn.vimconnector):
     def delete_tenant_flavor(self,flavor_id):
         '''Deletes a tenant flavor from VIM'''
         '''Returns the HTTP response code and a message indicating details of the success or fail'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Deleting a flavor from VIM"
         print "VIM URL:",self.url
         print "Tenant id:",self.tenant
         print "Flavor id:",flavor_id
-        #headers_req = {'content-type': 'application/json'}
         #payload_req = flavor_data
         try:
             vim_response = requests.delete(self.url+'/'+self.tenant+'/flavors/'+flavor_id)
@@ -806,8 +846,11 @@ class vimconnector(vimconn.vimconnector):
             200, image-id        if the image is created
             <0, message          if there is an error
         '''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Adding a new image to VIM", image_dict['location']
-        headers_req = {'content-type': 'application/json'}
         new_image_dict={'name': image_dict['name']}
         if 'description' in image_dict and image_dict['description'] != None:
             new_image_dict['description'] = image_dict['description']
@@ -818,7 +861,7 @@ class vimconnector(vimconn.vimconnector):
         payload_req = json.dumps({"image":new_image_dict})
         url=self.url + '/' + self.tenant + '/images'
         try:
-            vim_response = requests.post(url, headers = headers_req, data=payload_req)
+            vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_tenant_image Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -847,8 +890,11 @@ class vimconnector(vimconn.vimconnector):
     def delete_tenant_image(self, image_id):
         '''Deletes a tenant image from VIM'''
         '''Returns the HTTP response code and a message indicating details of the success or fail'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Deleting an image from VIM"
-        #headers_req = {'content-type': 'application/json'}
         #payload_req = flavor_data
         url=self.url + '/'+ self.tenant +'/images/'+image_id
         try:
@@ -871,11 +917,14 @@ class vimconnector(vimconn.vimconnector):
     def new_tenant_vminstancefromJSON(self, vm_data):
         '''Adds a VM instance to VIM'''
         '''Returns the instance identifier'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Adding a new VM instance from JSON to VIM"
-        headers_req = {'content-type': 'application/json'}
         payload_req = vm_data
         try:
-            vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_tenant_vminstancefromJSON Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -919,8 +968,11 @@ class vimconnector(vimconn.vimconnector):
         Returns >=0, the instance identifier
                 <0, error_text
         '''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Adding a new VM instance to VIM"
-        headers_req = {'content-type': 'application/json'}
         
 #         net_list = []
 #         for k,v in net_dict.items():
@@ -949,7 +1001,7 @@ class vimconnector(vimconn.vimconnector):
         payload_req = json.dumps({"server": payload_dict})
         print self.url+'/'+self.tenant+'/servers'+payload_req
         try:
-            vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = headers_req, data=payload_req)
+            vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = self.headers_req, data=payload_req)
         except requests.exceptions.RequestException, e:
             print "new_tenant_vminstance Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -1007,13 +1059,16 @@ class vimconnector(vimconn.vimconnector):
         
     def get_tenant_vminstance(self,vm_id):
         '''Returns the VM instance information from VIM'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Getting tenant VM instance information from VIM"
-        headers_req = {'content-type': 'application/json'}
         
         url = self.url+'/'+self.tenant+'/servers/'+vm_id
         print url
         try:
-            vim_response = requests.get(url, headers = headers_req)
+            vim_response = requests.get(url, headers = self.headers_req)
         except requests.exceptions.RequestException, e:
             print "get_tenant_vminstance Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -1038,11 +1093,14 @@ class vimconnector(vimconn.vimconnector):
     def delete_tenant_vminstance(self, vm_id):
         '''Removes a VM instance from VIM'''
         '''Returns the instance identifier'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Delete a VM instance from VIM " + vm_id
-        headers_req = {'content-type': 'application/json'}
         
         try:
-            vim_response = requests.delete(self.url+'/'+self.tenant+'/servers/'+vm_id, headers = headers_req)
+            vim_response = requests.delete(self.url+'/'+self.tenant+'/servers/'+vm_id, headers = self.headers_req)
         except requests.exceptions.RequestException, e:
             print "delete_tenant_vminstance Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -1066,6 +1124,10 @@ class vimconnector(vimconn.vimconnector):
                       <0 if error (foreseen)
             - error_msg: text with reference to possible errors
         '''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         #vms_refreshed = []
         #nets_refreshed = []
         vms_unrefreshed = []
@@ -1073,12 +1135,11 @@ class vimconnector(vimconn.vimconnector):
         for vm_id in vmDict:
             vmDict[vm_id]={'error_msg':None, 'vim_info':None}
             print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
-            headers_req = {'content-type': 'application/json'}
         
             url = self.url+'/'+self.tenant+'/servers/'+ vm_id
             print url
             try:
-                vim_response = requests.get(url, headers = headers_req)
+                vim_response = requests.get(url, headers = self.headers_req)
             except requests.exceptions.RequestException, e:
                 print "VIMConnector refresh_tenant_elements. Exception: ", e.args
                 vmDict[vm_id]['status'] = "VIM_ERROR"
@@ -1102,7 +1163,7 @@ class vimconnector(vimconn.vimconnector):
                         #get interfaces info
                         url2 = self.url+'/ports?device_id='+ vm_id
                         try:
-                            vim_response2 = requests.get(url2, headers = headers_req)
+                            vim_response2 = requests.get(url2, headers = self.headers_req)
                             if vim_response.status_code == 200:
                                 client_data = vim_response2.json()
                                 for port in client_data.get("ports"):
@@ -1148,7 +1209,6 @@ class vimconnector(vimconn.vimconnector):
         for net_id in netDict:
             netDict[net_id] = {'error_msg':None, 'vim_info':None}
             print "VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
-            headers_req = {'content-type': 'application/json'}
             r,c = self.get_tenant_network(net_id)
             if r<0:
                 print "VIMconnector refresh_tenant_network. Error getting net_id '%s' status: %s" % (net_id, c)
@@ -1185,14 +1245,17 @@ class vimconnector(vimconn.vimconnector):
     def action_tenant_vminstance(self, vm_id, action_dict):
         '''Send and action over a VM instance from VIM'''
         '''Returns the status'''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         print "VIMConnector: Action over VM instance from VIM " + vm_id
-        headers_req = {'content-type': 'application/json'}
         
         try:
             if "console" in action_dict:
                 return -vimconn.HTTP_Service_Unavailable, "getting console is not available at openvim"
             
-            vim_response = requests.post(self.url+'/'+self.tenant+'/servers/'+vm_id+"/action", headers = headers_req, data=json.dumps(action_dict) )
+            vim_response = requests.post(self.url+'/'+self.tenant+'/servers/'+vm_id+"/action", headers = self.headers_req, data=json.dumps(action_dict) )
         except requests.exceptions.RequestException, e:
             print "action_tenant_vminstance Exception: ", e.args
             return -vimconn.HTTP_Not_Found, str(e.args[0])
@@ -1358,6 +1421,10 @@ class vimconnector(vimconn.vimconnector):
              1,image-id            if there is one image with that path
              <0,message            if there was an error (Image not found, error contacting VIM, more than 1 image with that path, etc.) 
         '''
+        try:
+            self._get_my_tenant()
+        except Exception as e:
+            return -vimconn.HTTP_Not_Found, str(e)
         url=self.url + '/' + self.tenant + '/images?path='+path
         try:
             vim_response = requests.get(url)