##
+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"
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"
* 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 */;
/*!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`),
) 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`
--
/*!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`
--
`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`),
`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 */;
/*!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 */;
`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`),
`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 */;
/*!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`),
`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 */;
--
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
/*!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';
`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`),
/*!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
/*!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`),
/*!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`
--
`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 */;
--
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`
--
/*!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 */;
/*!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 */;
/*!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
'''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
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
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
#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
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_)
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']
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']
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:
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)
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:
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)
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:
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:
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)
__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" : "^[^,;()'\"]+$"}
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
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",
"$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":{
"additionalProperties": True
}
},
- "required": ["vnf", "version"],
+ "required": ["vnf", "schema_version"],
"additionalProperties": False
}
"name":name_schema,
"description": description_schema,
"tenant_id": id_schema, #only valid for admin
+ "public": {"type": "boolean"},
"topology":{
"type":"object",
"properties":{
"$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
}
--- /dev/null
+#!/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)))
+
--- /dev/null
+---
+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
+
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':
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':
}
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={}
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
'''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
'''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}
'''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
}
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()
'''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])
'''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])
'''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])
'''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:
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])
'''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])
'''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])
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])
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])
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=''
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])
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])
'''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])
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])
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)
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']
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])
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:
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])
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():
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])
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])
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])
<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 = []
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"
#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"):
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)
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])
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)
projects / osm / RO.git / commitdiff