| #!/usr/bin/env python |
| # -*- coding: utf-8 -*- |
| # PYTHON_ARGCOMPLETE_OK |
| |
| ## |
| # 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 client used to interact with openmano-server (openmanod) |
| """ |
| __author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes" |
| __date__ = "$09-oct-2014 09:09:48$" |
| __version__ = "0.4.20-r530" |
| version_date = "Sep 2017" |
| |
| from argcomplete.completers import FilesCompleter |
| import os |
| import argparse |
| import argcomplete |
| import requests |
| import json |
| import yaml |
| import logging |
| #from jsonschema import validate as js_v, exceptions as js_e |
| |
| class ArgumentParserError(Exception): pass |
| |
| class OpenmanoCLIError(Exception): pass |
| |
| class ThrowingArgumentParser(argparse.ArgumentParser): |
| def error(self, message): |
| print "Error: %s" %message |
| print |
| self.print_usage() |
| #self.print_help() |
| print |
| print "Type 'openmano -h' for help" |
| raise ArgumentParserError |
| |
| |
| def config(args): |
| print "OPENMANO_HOST: %s" %mano_host |
| print "OPENMANO_PORT: %s" %mano_port |
| if args.n: |
| logger.debug("resolving tenant and datacenter names") |
| mano_tenant_id = "None" |
| mano_tenant_name = "None" |
| mano_datacenter_id = "None" |
| mano_datacenter_name = "None" |
| try: |
| mano_tenant_id = _get_item_uuid("tenants", mano_tenant) |
| URLrequest = "http://%s:%s/openmano/tenants/%s" %(mano_host, mano_port, mano_tenant_id) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| mano_tenant_name = content["tenant"]["name"] |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s" %(mano_host, mano_port, mano_tenant_id, mano_datacenter) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| if "error" not in content: |
| mano_datacenter_id = content["datacenter"]["uuid"] |
| mano_datacenter_name = content["datacenter"]["name"] |
| except OpenmanoCLIError: |
| pass |
| print "OPENMANO_TENANT: %s" %mano_tenant |
| print " Id: %s" %mano_tenant_id |
| print " Name: %s" %mano_tenant_name |
| print "OPENMANO_DATACENTER: %s" %str (mano_datacenter) |
| print " Id: %s" %mano_datacenter_id |
| print " Name: %s" %mano_datacenter_name |
| else: |
| print "OPENMANO_TENANT: %s" %mano_tenant |
| print "OPENMANO_DATACENTER: %s" %str (mano_datacenter) |
| |
| def _print_verbose(mano_response, verbose_level=0): |
| content = mano_response.json() |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| if type(content)!=dict or len(content)!=1: |
| #print "Non expected format output" |
| print str(content) |
| return result |
| |
| val=content.values()[0] |
| if type(val)==str: |
| print val |
| return result |
| elif type(val) == list: |
| content_list = val |
| elif type(val)==dict: |
| content_list = [val] |
| else: |
| #print "Non expected dict/list format output" |
| print str(content) |
| return result |
| |
| #print content_list |
| if verbose_level==None: |
| verbose_level=0 |
| if verbose_level >= 3: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| |
| if mano_response.status_code == 200: |
| uuid = None |
| for content in content_list: |
| if "uuid" in content: |
| uuid = content['uuid'] |
| elif "id" in content: |
| uuid = content['id'] |
| elif "vim_id" in content: |
| uuid = content['vim_id'] |
| name = content.get('name'); |
| if not uuid: |
| uuid = "" |
| if not name: |
| name = "" |
| myoutput = "%s %s" %(uuid.ljust(38),name.ljust(20)) |
| if content.get("status"): |
| myoutput += " " + content['status'].ljust(20) |
| elif "enabled" in content and not content["enabled"]: |
| myoutput += " enabled=False".ljust(20) |
| if verbose_level >=1: |
| if content.get('created_at'): |
| myoutput += " " + content['created_at'].ljust(20) |
| if content.get('sdn_attached_ports'): |
| #myoutput += " " + str(content['sdn_attached_ports']).ljust(20) |
| myoutput += "\nsdn_attached_ports:\n" + yaml.safe_dump(content['sdn_attached_ports'], indent=4, default_flow_style=False) |
| if verbose_level >=2: |
| new_line='\n' |
| if content.get('type'): |
| myoutput += new_line + " Type: " + content['type'].ljust(29) |
| new_line='' |
| if content.get('description'): |
| myoutput += new_line + " Description: " + content['description'].ljust(20) |
| print myoutput |
| else: |
| print content['error']['description'] |
| return result |
| |
| def parser_json_yaml(file_name): |
| try: |
| f = file(file_name, "r") |
| text = f.read() |
| f.close() |
| except Exception as e: |
| return (False, str(e)) |
| |
| #Read and parse file |
| if file_name[-5:]=='.yaml' or file_name[-4:]=='.yml' or (file_name[-5:]!='.json' and '\t' not in text): |
| try: |
| config = yaml.load(text) |
| except yaml.YAMLError as exc: |
| error_pos = "" |
| if hasattr(exc, 'problem_mark'): |
| mark = exc.problem_mark |
| error_pos = " at line:%s column:%s" % (mark.line+1, mark.column+1) |
| return (False, "Error loading file '"+file_name+"' yaml format error" + error_pos) |
| else: #json |
| try: |
| config = json.loads(text) |
| except Exception as e: |
| return (False, "Error loading file '"+file_name+"' json format error " + str(e) ) |
| |
| return True, config |
| |
| def _load_file_or_yaml(content): |
| ''' |
| 'content' can be or a yaml/json file or a text containing a yaml/json text format |
| This function autodetect, trying to load and parse the file, |
| if fails trying to parse the 'content' text |
| Returns the dictionary once parsed, or print an error and finish the program |
| ''' |
| #Check config file exists |
| if os.path.isfile(content): |
| r,payload = parser_json_yaml(content) |
| if not r: |
| print payload |
| exit(-1) |
| elif "{" in content or ":" in content: |
| try: |
| payload = yaml.load(content) |
| except yaml.YAMLError as exc: |
| error_pos = "" |
| if hasattr(exc, 'problem_mark'): |
| mark = exc.problem_mark |
| error_pos = " at position: (%s:%s)" % (mark.line+1, mark.column+1) |
| print "Error loading yaml/json text"+error_pos |
| exit (-1) |
| else: |
| print "'%s' is neither a valid file nor a yaml/json content" % content |
| exit(-1) |
| return payload |
| |
| def _get_item_uuid(item, item_name_id, tenant=None): |
| if tenant: |
| URLrequest = "http://%s:%s/openmano/%s/%s" %(mano_host, mano_port, tenant, item) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s" %(mano_host, mano_port, item) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| #print content |
| found = 0 |
| for i in content[item]: |
| if i["uuid"] == item_name_id: |
| return item_name_id |
| if i["name"] == item_name_id: |
| uuid = i["uuid"] |
| found += 1 |
| if item_name_id.startswith("osm_id=") and i.get("osm_id") == item_name_id[7:]: |
| uuid = i["uuid"] |
| found += 1 |
| if found == 0: |
| raise OpenmanoCLIError("No %s found with name/uuid '%s'" %(item[:-1], item_name_id)) |
| elif found > 1: |
| raise OpenmanoCLIError("%d %s found with name '%s'. uuid must be used" %(found, item, item_name_id)) |
| return uuid |
| # |
| # def check_valid_uuid(uuid): |
| # id_schema = {"type" : "string", "pattern": "^[a-fA-F0-9]{8}(-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}$"} |
| # try: |
| # js_v(uuid, id_schema) |
| # return True |
| # except js_e.ValidationError: |
| # return False |
| |
| def _get_tenant(tenant_name_id = None): |
| if not tenant_name_id: |
| tenant_name_id = mano_tenant |
| if not mano_tenant: |
| raise OpenmanoCLIError("'OPENMANO_TENANT' environment variable is not set") |
| return _get_item_uuid("tenants", tenant_name_id) |
| |
| def _get_datacenter(datacenter_name_id = None, tenant = "any"): |
| if not datacenter_name_id: |
| datacenter_name_id = mano_datacenter |
| if not datacenter_name_id: |
| raise OpenmanoCLIError("neither 'OPENMANO_DATACENTER' environment variable is set nor --datacenter option is used") |
| return _get_item_uuid("datacenters", datacenter_name_id, tenant) |
| |
| def vnf_create(args): |
| #print "vnf-create",args |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| tenant = _get_tenant() |
| myvnf = _load_file_or_yaml(args.file) |
| api_version = "" |
| if "vnfd:vnfd-catalog" in myvnf or "vnfd-catalog" in myvnf: |
| api_version = "/v3" |
| token = "vnfd" |
| vnfd_catalog = myvnf.get("vnfd:vnfd-catalog") |
| if not vnfd_catalog: |
| vnfd_catalog = myvnf.get("vnfd-catalog") |
| vnfds = vnfd_catalog.get("vnfd:vnfd") |
| if not vnfds: |
| vnfds = vnfd_catalog.get("vnfd") |
| vnfd = vnfds[0] |
| vdu_list = vnfd["vdu"] |
| |
| else: # old API |
| api_version = "" |
| token = "vnfs" |
| vnfd = myvnf['vnf'] |
| vdu_list = vnfd["VNFC"] |
| |
| if args.name or args.description or args.image_path or args.image_name or args.image_checksum: |
| # TODO, change this for API v3 |
| # print args.name |
| try: |
| if args.name: |
| vnfd['name'] = args.name |
| if args.description: |
| vnfd['description'] = args.description |
| if args.image_path: |
| index = 0 |
| for image_path_ in args.image_path.split(","): |
| # print "image-path", image_path_ |
| if api_version == "/v3": |
| if vdu_list[index].get("image"): |
| vdu_list[index]['image'] = image_path_ |
| if "image-checksum" in vdu_list[index]: |
| del vdu_list[index]["image-checksum"] |
| else: # image name in volumes |
| vdu_list[index]["volumes"][0]["image"] = image_path_ |
| if "image-checksum" in vdu_list[index]["volumes"][0]: |
| del vdu_list[index]["volumes"][0]["image-checksum"] |
| else: |
| vdu_list[index]['VNFC image'] = image_path_ |
| if "image name" in vdu_list[index]: |
| del vdu_list[index]["image name"] |
| if "image checksum" in vdu_list[index]: |
| del vdu_list[index]["image checksum"] |
| index += 1 |
| if args.image_name: # image name precedes if both are supplied |
| index = 0 |
| for image_name_ in args.image_name.split(","): |
| if api_version == "/v3": |
| if vdu_list[index].get("image"): |
| vdu_list[index]['image'] = image_name_ |
| if "image-checksum" in vdu_list[index]: |
| del vdu_list[index]["image-checksum"] |
| else: # image name in volumes |
| vdu_list[index]["volumes"][0]["image"] = image_name_ |
| if "image-checksum" in vdu_list[index]["volumes"][0]: |
| del vdu_list[index]["volumes"][0]["image-checksum"] |
| else: |
| vdu_list[index]['image name'] = image_name_ |
| if "VNFC image" in vdu_list[index]: |
| del vdu_list[index]["VNFC image"] |
| index += 1 |
| if args.image_checksum: |
| index = 0 |
| for image_checksum_ in args.image_checksum.split(","): |
| if api_version == "/v3": |
| if vdu_list[index].get("image"): |
| vdu_list[index]['image-checksum'] = image_checksum_ |
| else: # image name in volumes |
| vdu_list[index]["volumes"][0]["image-checksum"] = image_checksum_ |
| else: |
| vdu_list[index]['image checksum'] = image_checksum_ |
| index += 1 |
| except (KeyError, TypeError), e: |
| if str(e) == 'vnf': error_pos= "missing field 'vnf'" |
| elif str(e) == 'name': error_pos= "missing field 'vnf':'name'" |
| elif str(e) == 'description': error_pos= "missing field 'vnf':'description'" |
| 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']" |
| elif str(e) == 'image name': error_pos= "missing field 'vnf':'VNFC'['image name']" |
| elif str(e) == 'image checksum': error_pos= "missing field 'vnf':'VNFC'['image checksum']" |
| else: error_pos="wrong format" |
| print "Wrong VNF descriptor: " + error_pos |
| return -1 |
| payload_req = json.dumps(myvnf) |
| |
| #print payload_req |
| |
| URLrequest = "http://{}:{}/openmano{}/{}/{token}".format(mano_host, mano_port, api_version, tenant, token=token) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| |
| return _print_verbose(mano_response, args.verbose) |
| |
| def vnf_list(args): |
| #print "vnf-list",args |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| if args.name: |
| toshow = _get_item_uuid("vnfs", args.name, tenant) |
| URLrequest = "http://%s:%s/openmano/%s/vnfs/%s" %(mano_host, mano_port, tenant, toshow) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s/vnfs" %(mano_host, mano_port, tenant) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| # print json.dumps(content, indent=4) |
| if args.verbose==None: |
| args.verbose=0 |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| if mano_response.status_code == 200: |
| if not args.name: |
| if args.verbose >= 3: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| if len(content['vnfs']) == 0: |
| print "No VNFs were found." |
| return 404 # HTTP_Not_Found |
| for vnf in content['vnfs']: |
| myoutput = "{:38} {:20}".format(vnf['uuid'], vnf['name']) |
| if vnf.get('osm_id') or args.verbose >= 1: |
| myoutput += " osm_id={:20}".format(vnf.get('osm_id')) |
| if args.verbose >= 1: |
| myoutput += " {}".format(vnf['created_at']) |
| print (myoutput) |
| if args.verbose >= 2: |
| print (" Description: {}".format(vnf['description'])) |
| # print (" VNF descriptor file: {}".format(vnf['path'])) |
| else: |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| vnf = content['vnf'] |
| print ("{:38} {:20} osm_id={:20} {:20}".format(vnf['uuid'], vnf['name'], vnf.get('osm_id'), |
| vnf['created_at'])) |
| print (" Description: {}".format(vnf['description'])) |
| # print " VNF descriptor file: %s" %vnf['path'] |
| print (" VMs:") |
| for vm in vnf['VNFC']: |
| print (" {:20} osm_id={:20} {}".format(vm['name'], vm.get('osm_id'), vm['description'])) |
| if len(vnf['nets']) > 0: |
| print (" Internal nets:") |
| for net in vnf['nets']: |
| print (" {:20} {}".format(net['name'], net['description'])) |
| if len(vnf['external-connections']) > 0: |
| print (" External interfaces:") |
| for interface in vnf['external-connections']: |
| print (" {:20} {:20} {:20} {:14}".format( |
| interface['external_name'], interface['vm_name'], |
| interface['internal_name'], |
| interface.get('vpci') if interface.get('vpci') else "")) |
| else: |
| print content['error']['description'] |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| |
| def vnf_delete(args): |
| #print "vnf-delete",args |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| todelete = _get_item_uuid("vnfs", args.name, tenant=tenant) |
| if not args.force: |
| r = raw_input("Delete VNF %s (y/N)? " %(todelete)) |
| if not (len(r)>0 and r[0].lower()=="y"): |
| return 0 |
| URLrequest = "http://%s:%s/openmano/%s/vnfs/%s" %(mano_host, mano_port, tenant, todelete) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| def scenario_create(args): |
| # print "scenario-create",args |
| tenant = _get_tenant() |
| headers_req = {'content-type': 'application/yaml'} |
| myscenario = _load_file_or_yaml(args.file) |
| if "nsd:nsd-catalog" in myscenario or "nsd-catalog" in myscenario: |
| api_version = "/v3" |
| token = "nsd" |
| nsd_catalog = myscenario.get("nsd:nsd-catalog") |
| if not nsd_catalog: |
| nsd_catalog = myscenario.get("nsd-catalog") |
| nsds = nsd_catalog.get("nsd:nsd") |
| if not nsds: |
| nsds = nsd_catalog.get("nsd") |
| nsd = nsds[0] |
| else: # API<v3 |
| api_version = "" |
| token = "scenarios" |
| if "scenario" in myscenario: |
| nsd = myscenario["scenario"] |
| else: |
| nsd = myscenario |
| # TODO modify for API v3 |
| if args.name: |
| nsd['name'] = args.name |
| if args.description: |
| nsd['description'] = args.description |
| payload_req = yaml.safe_dump(myscenario, explicit_start=True, indent=4, default_flow_style=False, tags=False, |
| encoding='utf-8', allow_unicode=True) |
| |
| # print payload_req |
| URLrequest = "http://{host}:{port}/openmano{api}/{tenant}/{token}".format( |
| host=mano_host, port=mano_port, api=api_version, tenant=tenant, token=token) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| return _print_verbose(mano_response, args.verbose) |
| |
| def scenario_list(args): |
| #print "scenario-list",args |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| if args.name: |
| toshow = _get_item_uuid("scenarios", args.name, tenant) |
| URLrequest = "http://%s:%s/openmano/%s/scenarios/%s" %(mano_host, mano_port, tenant, toshow) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s/scenarios" %(mano_host, mano_port, tenant) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if args.verbose==None: |
| args.verbose=0 |
| |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| if mano_response.status_code == 200: |
| if not args.name: |
| if args.verbose >= 3: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| if len(content['scenarios']) == 0: |
| print "No scenarios were found." |
| return 404 #HTTP_Not_Found |
| for scenario in content['scenarios']: |
| myoutput = "{:38} {:20}".format(scenario['uuid'], scenario['name']) |
| if scenario.get('osm_id') or args.verbose >= 1: |
| myoutput += " osm_id={:20}".format(scenario.get('osm_id')) |
| if args.verbose >= 1: |
| myoutput += " {}".format(scenario['created_at']) |
| print (myoutput) |
| if args.verbose >=2: |
| print (" Description: {}".format(scenario['description'])) |
| else: |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| scenario = content['scenario'] |
| print ("{:38} {:20} osm_id={:20} {:20}".format(scenario['uuid'], scenario['name'], scenario.get('osm_id'), |
| scenario['created_at'])) |
| print (" Description: {}".format(scenario['description'])) |
| print (" VNFs:") |
| for vnf in scenario['vnfs']: |
| print (" {:38} {:20} vnf_index={} {}".format(vnf['vnf_id'], vnf['name'], vnf.get("member_vnf_index"), |
| vnf['description'])) |
| if len(scenario['nets']) > 0: |
| print (" nets:") |
| for net in scenario['nets']: |
| description = net['description'] |
| if not description: # if description does not exist, description is "-". Valid for external and internal nets. |
| description = '-' |
| vim_id = "" |
| if net.get('vim_id'): |
| vim_id = " vim_id=" + net["vim_id"] |
| external = "" |
| if net["external"]: |
| external = " external" |
| print (" {:20} {:38} {:30}{}{}".format(net['name'], net['uuid'], description, vim_id, external)) |
| else: |
| print (content['error']['description']) |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| |
| def scenario_delete(args): |
| #print "scenario-delete",args |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| todelete = _get_item_uuid("scenarios", args.name, tenant=tenant) |
| if not args.force: |
| r = raw_input("Delete scenario %s (y/N)? " %(args.name)) |
| if not (len(r)>0 and r[0].lower()=="y"): |
| return 0 |
| URLrequest = "http://%s:%s/openmano/%s/scenarios/%s" %(mano_host, mano_port, tenant, todelete) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| def scenario_deploy(args): |
| print "This command is deprecated, use 'openmano instance-scenario-create --scenario %s --name %s' instead!!!" % (args.scenario, args.name) |
| print |
| args.file = None |
| args.netmap_use = None |
| args.netmap_create = None |
| args.keypair = None |
| args.keypair_auto = None |
| return instance_create(args) |
| |
| # #print "scenario-deploy",args |
| # headers_req = {'content-type': 'application/json'} |
| # action = {} |
| # actionCmd="start" |
| # if args.nostart: |
| # actionCmd="reserve" |
| # action[actionCmd] = {} |
| # action[actionCmd]["instance_name"] = args.name |
| # if args.datacenter != None: |
| # action[actionCmd]["datacenter"] = args.datacenter |
| # elif mano_datacenter != None: |
| # action[actionCmd]["datacenter"] = mano_datacenter |
| # |
| # if args.description: |
| # action[actionCmd]["description"] = args.description |
| # payload_req = json.dumps(action, indent=4) |
| # #print payload_req |
| # |
| # URLrequest = "http://%s:%s/openmano/%s/scenarios/%s/action" %(mano_host, mano_port, mano_tenant, args.scenario) |
| # logger.debug("openmano request: %s", payload_req) |
| # mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| # logger.debug("openmano response: %s", mano_response.text ) |
| # if args.verbose==None: |
| # args.verbose=0 |
| # |
| # result = 0 if mano_response.status_code==200 else mano_response.status_code |
| # content = mano_response.json() |
| # #print json.dumps(content, indent=4) |
| # if args.verbose >= 3: |
| # print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| # return result |
| # |
| # if mano_response.status_code == 200: |
| # myoutput = "%s %s" %(content['uuid'].ljust(38),content['name'].ljust(20)) |
| # if args.verbose >=1: |
| # myoutput = "%s %s" %(myoutput, content['created_at'].ljust(20)) |
| # if args.verbose >=2: |
| # myoutput = "%s %s %s" %(myoutput, content['description'].ljust(30)) |
| # print myoutput |
| # print "" |
| # print "To check the status, run the following command:" |
| # print "openmano instance-scenario-list <instance_id>" |
| # else: |
| # print content['error']['description'] |
| # return result |
| |
| def scenario_verify(args): |
| #print "scenario-verify",args |
| tenant = _get_tenant() |
| headers_req = {'content-type': 'application/json'} |
| action = {} |
| action["verify"] = {} |
| action["verify"]["instance_name"] = "scen-verify-return5" |
| payload_req = json.dumps(action, indent=4) |
| #print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/%s/scenarios/%s/action" %(mano_host, mano_port, tenant, args.scenario) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| def instance_create(args): |
| tenant = _get_tenant() |
| headers_req = {'content-type': 'application/yaml'} |
| myInstance={"instance": {}, "schema_version": "0.1"} |
| if args.file: |
| instance_dict = _load_file_or_yaml(args.file) |
| if "instance" not in instance_dict: |
| myInstance = {"instance": instance_dict, "schema_version": "0.1"} |
| else: |
| myInstance = instance_dict |
| if args.name: |
| myInstance["instance"]['name'] = args.name |
| if args.description: |
| myInstance["instance"]['description'] = args.description |
| if args.nostart: |
| myInstance["instance"]['action'] = "reserve" |
| #datacenter |
| datacenter = myInstance["instance"].get("datacenter") |
| if args.datacenter != None: |
| datacenter = args.datacenter |
| myInstance["instance"]["datacenter"] = _get_datacenter(datacenter, tenant) |
| #scenario |
| scenario = myInstance["instance"].get("scenario") |
| if args.scenario != None: |
| scenario = args.scenario |
| if not scenario: |
| print "you must provide a scenario in the file descriptor or with --scenario" |
| return -1 |
| myInstance["instance"]["scenario"] = _get_item_uuid("scenarios", scenario, tenant) |
| if args.netmap_use: |
| if "networks" not in myInstance["instance"]: |
| myInstance["instance"]["networks"] = {} |
| for net in args.netmap_use: |
| net_comma_list = net.split(",") |
| for net_comma in net_comma_list: |
| net_tuple = net_comma.split("=") |
| if len(net_tuple) != 2: |
| print "error at netmap-use. Expected net-scenario=net-datacenter. (%s)?" % net_comma |
| return |
| net_scenario = net_tuple[0].strip() |
| net_datacenter = net_tuple[1].strip() |
| if net_scenario not in myInstance["instance"]["networks"]: |
| myInstance["instance"]["networks"][net_scenario] = {} |
| if "sites" not in myInstance["instance"]["networks"][net_scenario]: |
| myInstance["instance"]["networks"][net_scenario]["sites"] = [ {} ] |
| myInstance["instance"]["networks"][net_scenario]["sites"][0]["netmap-use"] = net_datacenter |
| if args.netmap_create: |
| if "networks" not in myInstance["instance"]: |
| myInstance["instance"]["networks"] = {} |
| for net in args.netmap_create: |
| net_comma_list = net.split(",") |
| for net_comma in net_comma_list: |
| net_tuple = net_comma.split("=") |
| if len(net_tuple) == 1: |
| net_scenario = net_tuple[0].strip() |
| net_datacenter = None |
| elif len(net_tuple) == 2: |
| net_scenario = net_tuple[0].strip() |
| net_datacenter = net_tuple[1].strip() |
| else: |
| print "error at netmap-create. Expected net-scenario=net-datacenter or net-scenario. (%s)?" % net_comma |
| return |
| if net_scenario not in myInstance["instance"]["networks"]: |
| myInstance["instance"]["networks"][net_scenario] = {} |
| if "sites" not in myInstance["instance"]["networks"][net_scenario]: |
| myInstance["instance"]["networks"][net_scenario]["sites"] = [ {} ] |
| myInstance["instance"]["networks"][net_scenario]["sites"][0]["netmap-create"] = net_datacenter |
| if args.keypair: |
| if "cloud-config" not in myInstance["instance"]: |
| myInstance["instance"]["cloud-config"] = {} |
| cloud_config = myInstance["instance"]["cloud-config"] |
| for key in args.keypair: |
| index = key.find(":") |
| if index<0: |
| if "key-pairs" not in cloud_config: |
| cloud_config["key-pairs"] = [] |
| cloud_config["key-pairs"].append(key) |
| else: |
| user = key[:index] |
| key_ = key[index+1:] |
| key_list = key_.split(",") |
| if "users" not in cloud_config: |
| cloud_config["users"] = [] |
| cloud_config["users"].append({"name": user, "key-pairs": key_list }) |
| if args.keypair_auto: |
| try: |
| keys=[] |
| home = os.getenv("HOME") |
| user = os.getenv("USER") |
| files = os.listdir(home+'/.ssh') |
| for file in files: |
| if file[-4:] == ".pub": |
| with open(home+'/.ssh/'+file, 'r') as f: |
| keys.append(f.read()) |
| if not keys: |
| print "Cannot obtain any public ssh key from '{}'. Try not using --keymap-auto".format(home+'/.ssh') |
| return 1 |
| except Exception as e: |
| print "Cannot obtain any public ssh key. Error '{}'. Try not using --keymap-auto".format(str(e)) |
| return 1 |
| |
| if "cloud-config" not in myInstance["instance"]: |
| myInstance["instance"]["cloud-config"] = {} |
| cloud_config = myInstance["instance"]["cloud-config"] |
| if "key-pairs" not in cloud_config: |
| cloud_config["key-pairs"] = [] |
| if user: |
| if "users" not in cloud_config: |
| cloud_config["users"] = [] |
| cloud_config["users"].append({"name": user, "key-pairs": keys }) |
| |
| payload_req = yaml.safe_dump(myInstance, explicit_start=True, indent=4, default_flow_style=False, tags=False, encoding='utf-8', allow_unicode=True) |
| logger.debug("openmano request: %s", payload_req) |
| URLrequest = "http://%s:%s/openmano/%s/instances" %(mano_host, mano_port, tenant) |
| mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| if args.verbose==None: |
| args.verbose=0 |
| |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if args.verbose >= 3: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| |
| if mano_response.status_code == 200: |
| myoutput = "%s %s" %(content['uuid'].ljust(38),content['name'].ljust(20)) |
| if args.verbose >=1: |
| myoutput = "%s %s" %(myoutput, content['created_at'].ljust(20)) |
| if args.verbose >=2: |
| myoutput = "%s %s %s" %(myoutput, content['description'].ljust(30)) |
| print myoutput |
| else: |
| print content['error']['description'] |
| return result |
| |
| def instance_scenario_list(args): |
| #print "instance-scenario-list",args |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| if args.name: |
| toshow = _get_item_uuid("instances", args.name, tenant) |
| URLrequest = "http://%s:%s/openmano/%s/instances/%s" %(mano_host, mano_port, tenant, toshow) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s/instances" %(mano_host, mano_port, tenant) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if args.verbose==None: |
| args.verbose=0 |
| |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| if mano_response.status_code == 200: |
| if not args.name: |
| if args.verbose >= 3: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| if len(content['instances']) == 0: |
| print "No scenario instances were found." |
| return result |
| for instance in content['instances']: |
| myoutput = "%s %s" %(instance['uuid'].ljust(38),instance['name'].ljust(20)) |
| if args.verbose >=1: |
| myoutput = "%s %s" %(myoutput, instance['created_at'].ljust(20)) |
| print myoutput |
| if args.verbose >=2: |
| print "Description: %s" %instance['description'] |
| else: |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| instance = content |
| print "%s %s %s" %(instance['uuid'].ljust(38),instance['name'].ljust(20),instance['created_at'].ljust(20)) |
| print "Description: %s" %instance['description'] |
| print "Template scenario id: %s" %instance['scenario_id'] |
| print "Template scenario name: %s" %instance['scenario_name'] |
| print "---------------------------------------" |
| print "VNF instances: %d" %len(instance['vnfs']) |
| for vnf in instance['vnfs']: |
| #print " %s %s Template vnf name: %s Template vnf id: %s" %(vnf['uuid'].ljust(38), vnf['name'].ljust(20), vnf['vnf_name'].ljust(20), vnf['vnf_id'].ljust(38)) |
| print " %s %s Template vnf id: %s" %(vnf['uuid'].ljust(38), vnf['vnf_name'].ljust(20), vnf['vnf_id'].ljust(38)) |
| if len(instance['nets'])>0: |
| print "---------------------------------------" |
| print "Internal nets:" |
| for net in instance['nets']: |
| if net['created']: |
| print " %s %s VIM ID: %s" %(net['uuid'].ljust(38), net['status'].ljust(12), net['vim_net_id']) |
| print "---------------------------------------" |
| print "External nets:" |
| for net in instance['nets']: |
| if not net['created']: |
| print " %s %s VIM ID: %s" %(net['uuid'].ljust(38), net['status'].ljust(12), net['vim_net_id']) |
| print "---------------------------------------" |
| print "VM instances:" |
| for vnf in instance['vnfs']: |
| for vm in vnf['vms']: |
| print " %s %s %s %s VIM ID: %s" %(vm['uuid'].ljust(38), vnf['vnf_name'].ljust(20), vm['name'].ljust(20), vm['status'].ljust(12), vm['vim_vm_id']) |
| else: |
| print content['error']['description'] |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| |
| def instance_scenario_status(args): |
| print "instance-scenario-status" |
| return 0 |
| |
| def instance_scenario_delete(args): |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| todelete = _get_item_uuid("instances", args.name, tenant=tenant) |
| #print "instance-scenario-delete",args |
| if not args.force: |
| r = raw_input("Delete scenario instance %s (y/N)? " %(args.name)) |
| if not (len(r)>0 and r[0].lower()=="y"): |
| return |
| URLrequest = "http://%s:%s/openmano/%s/instances/%s" %(mano_host, mano_port, tenant, todelete) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| def instance_scenario_action(args): |
| #print "instance-scenario-action", args |
| tenant = _get_tenant() |
| toact = _get_item_uuid("instances", args.name, tenant=tenant) |
| action={} |
| action[ args.action ] = args.param |
| if args.vnf: |
| action["vnfs"] = args.vnf |
| if args.vm: |
| action["vms"] = args.vm |
| |
| headers_req = {'content-type': 'application/json'} |
| payload_req = json.dumps(action, indent=4) |
| URLrequest = "http://%s:%s/openmano/%s/instances/%s/action" %(mano_host, mano_port, tenant, toact) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| if args.verbose: |
| print yaml.safe_dump(content, indent=4, default_flow_style=False) |
| return result |
| for uuid,c in content.iteritems(): |
| print "%s %s %s" %(uuid.ljust(38), c['name'].ljust(20),c['description'].ljust(20)) |
| else: |
| print content['error']['description'] |
| return result |
| |
| |
| def instance_vnf_list(args): |
| print "instance-vnf-list" |
| return 0 |
| |
| def instance_vnf_status(args): |
| print "instance-vnf-status" |
| return 0 |
| |
| def tenant_create(args): |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| tenant_dict={"name": args.name} |
| if args.description!=None: |
| tenant_dict["description"] = args.description |
| payload_req = json.dumps( {"tenant": tenant_dict }) |
| |
| #print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/tenants" %(mano_host, mano_port) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| return _print_verbose(mano_response, args.verbose) |
| |
| def tenant_list(args): |
| #print "tenant-list",args |
| if 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) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| if args.verbose==None: |
| args.verbose=0 |
| if args.name!=None: |
| args.verbose += 1 |
| return _print_verbose(mano_response, args.verbose) |
| |
| def tenant_delete(args): |
| #print "tenant-delete",args |
| todelete = _get_item_uuid("tenants", args.name) |
| if not args.force: |
| r = raw_input("Delete tenant %s (y/N)? " %(args.name)) |
| if not (len(r)>0 and r[0].lower()=="y"): |
| return 0 |
| URLrequest = "http://%s:%s/openmano/tenants/%s" %(mano_host, mano_port, todelete) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| def datacenter_attach(args): |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.name) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| |
| datacenter_dict={} |
| if args.vim_tenant_id != None: |
| datacenter_dict['vim_tenant'] = args.vim_tenant_id |
| if args.vim_tenant_name != None: |
| datacenter_dict['vim_tenant_name'] = args.vim_tenant_name |
| if args.user != None: |
| datacenter_dict['vim_username'] = args.user |
| if args.password != None: |
| datacenter_dict['vim_password'] = args.password |
| if args.config!=None: |
| datacenter_dict["config"] = _load_file_or_yaml(args.config) |
| payload_req = json.dumps( {"datacenter": datacenter_dict }) |
| |
| #print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s" %(mano_host, mano_port, tenant, datacenter) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = _print_verbose(mano_response, args.verbose) |
| #provide addional information if error |
| if mano_response.status_code != 200: |
| content = mano_response.json() |
| if "already in use for 'name'" in content['error']['description'] and \ |
| "to database vim_tenants table" in content['error']['description']: |
| print "Try to specify a different name with --vim-tenant-name" |
| return result |
| |
| |
| def datacenter_edit_vim_tenant(args): |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.name) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| |
| if not (args.vim_tenant_id or args.vim_tenant_name or args.user or args.password or args.config): |
| raise OpenmanoCLIError("Error. At least one parameter must be updated.") |
| |
| datacenter_dict = {} |
| if args.vim_tenant_id != None: |
| datacenter_dict['vim_tenant'] = args.vim_tenant_id |
| if args.vim_tenant_name != None: |
| datacenter_dict['vim_tenant_name'] = args.vim_tenant_name |
| if args.user != None: |
| datacenter_dict['vim_username'] = args.user |
| if args.password != None: |
| datacenter_dict['vim_password'] = args.password |
| if args.config != None: |
| datacenter_dict["config"] = _load_file_or_yaml(args.config) |
| payload_req = json.dumps({"datacenter": datacenter_dict}) |
| |
| # print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s" % (mano_host, mano_port, tenant, datacenter) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.put(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text) |
| result = _print_verbose(mano_response, args.verbose) |
| |
| return result |
| |
| def datacenter_detach(args): |
| if args.all: |
| tenant = "any" |
| else: |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.name, tenant) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s" %(mano_host, mano_port, tenant, datacenter) |
| mano_response = requests.delete(URLrequest, headers=headers_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| def datacenter_create(args): |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| datacenter_dict={"name": args.name, "vim_url": args.url} |
| if args.description!=None: |
| datacenter_dict["description"] = args.description |
| if args.type!=None: |
| datacenter_dict["type"] = args.type |
| if args.url!=None: |
| datacenter_dict["vim_url_admin"] = args.url_admin |
| if args.config!=None: |
| datacenter_dict["config"] = _load_file_or_yaml(args.config) |
| if args.sdn_controller!=None: |
| tenant = _get_tenant() |
| sdn_controller = _get_item_uuid("sdn_controllers", args.sdn_controller, tenant) |
| if not 'config' in datacenter_dict: |
| datacenter_dict['config'] = {} |
| datacenter_dict['config']['sdn-controller'] = sdn_controller |
| payload_req = json.dumps( {"datacenter": datacenter_dict }) |
| |
| #print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/datacenters" %(mano_host, mano_port) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| return _print_verbose(mano_response, args.verbose) |
| |
| def datacenter_delete(args): |
| #print "datacenter-delete",args |
| todelete = _get_item_uuid("datacenters", args.name, "any") |
| if not args.force: |
| r = raw_input("Delete datacenter %s (y/N)? " %(args.name)) |
| if not (len(r)>0 and r[0].lower()=="y"): |
| return 0 |
| URLrequest = "http://%s:%s/openmano/datacenters/%s" %(mano_host, mano_port, todelete) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| |
| |
| def datacenter_list(args): |
| #print "datacenter-list",args |
| tenant='any' if args.all else _get_tenant() |
| |
| if args.name: |
| toshow = _get_item_uuid("datacenters", args.name, tenant) |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s" %(mano_host, mano_port, tenant, toshow) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s/datacenters" %(mano_host, mano_port, tenant) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| if args.verbose==None: |
| args.verbose=0 |
| if args.name!=None: |
| args.verbose += 1 |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def datacenter_sdn_port_mapping_set(args): |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.name, tenant) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| |
| if not args.file: |
| raise OpenmanoCLIError( |
| "No yaml/json has been provided specifying the SDN port mapping") |
| sdn_port_mapping = _load_file_or_yaml(args.file) |
| payload_req = json.dumps({"sdn_port_mapping": sdn_port_mapping}) |
| |
| # read |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s/sdn_mapping" % (mano_host, mano_port, tenant, datacenter) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text) |
| port_mapping = mano_response.json() |
| if mano_response.status_code != 200: |
| str(mano_response.json()) |
| raise OpenmanoCLIError("openmano client error: {}".format(port_mapping['error']['description'])) |
| if len(port_mapping["sdn_port_mapping"]["ports_mapping"]) > 0: |
| if not args.force: |
| r = raw_input("Datacenter %s already contains a port mapping. Overwrite? (y/N)? " % (datacenter)) |
| if not (len(r) > 0 and r[0].lower() == "y"): |
| return 0 |
| |
| # clear |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s/sdn_mapping" % (mano_host, mano_port, tenant, datacenter) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text) |
| if mano_response.status_code != 200: |
| return _print_verbose(mano_response, args.verbose) |
| |
| # set |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s/sdn_mapping" % (mano_host, mano_port, tenant, datacenter) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text) |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def datacenter_sdn_port_mapping_list(args): |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.name, tenant) |
| |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s/sdn_mapping" % (mano_host, mano_port, tenant, datacenter) |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text) |
| |
| return _print_verbose(mano_response, 4) |
| |
| |
| def datacenter_sdn_port_mapping_clear(args): |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.name, tenant) |
| |
| if not args.force: |
| r = raw_input("Clean SDN port mapping for datacenter %s (y/N)? " %(datacenter)) |
| if not (len(r) > 0 and r[0].lower() == "y"): |
| return 0 |
| |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s/sdn_mapping" % (mano_host, mano_port, tenant, datacenter) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text) |
| |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def sdn_controller_create(args): |
| tenant = _get_tenant() |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| |
| error_msg=[] |
| if not args.ip: error_msg.append("'ip'") |
| if not args.port: error_msg.append("'port'") |
| if not args.dpid: error_msg.append("'dpid'") |
| if not args.type: error_msg.append("'type'") |
| if error_msg: |
| raise OpenmanoCLIError("The following arguments are required: " + ",".join(error_msg)) |
| |
| controller_dict = {} |
| controller_dict['name'] = args.name |
| controller_dict['ip'] = args.ip |
| controller_dict['port'] = int(args.port) |
| controller_dict['dpid'] = args.dpid |
| controller_dict['type'] = args.type |
| if args.description != None: |
| controller_dict['description'] = args.description |
| if args.user != None: |
| controller_dict['user'] = args.user |
| if args.password != None: |
| controller_dict['password'] = args.password |
| |
| payload_req = json.dumps({"sdn_controller": controller_dict}) |
| |
| # print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/%s/sdn_controllers" % (mano_host, mano_port, tenant) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text) |
| result = _print_verbose(mano_response, args.verbose) |
| return result |
| |
| |
| def sdn_controller_edit(args): |
| tenant = _get_tenant() |
| controller_uuid = _get_item_uuid("sdn_controllers", args.name, tenant) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| |
| controller_dict = {} |
| if args.new_name: |
| controller_dict['name'] = args.new_name |
| if args.ip: |
| controller_dict['ip'] = args.ip |
| if args.port: |
| controller_dict['port'] = int(args.port) |
| if args.dpid: |
| controller_dict['dpid'] = args.dpid |
| if args.type: |
| controller_dict['type'] = args.type |
| if args.description: |
| controller_dict['description'] = args.description |
| if args.user: |
| controller_dict['user'] = args.user |
| if args.password: |
| controller_dict['password'] = args.password |
| |
| if not controller_dict: |
| raise OpenmanoCLIError("At least one parameter must be edited") |
| |
| if not args.force: |
| r = raw_input("Update SDN controller {} (y/N)? ".format(args.name)) |
| if not (len(r) > 0 and r[0].lower() == "y"): |
| return 0 |
| |
| payload_req = json.dumps({"sdn_controller": controller_dict}) |
| # print payload_req |
| |
| URLrequest = "http://%s:%s/openmano/%s/sdn_controllers/%s" % (mano_host, mano_port, tenant, controller_uuid) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.put(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text) |
| result = _print_verbose(mano_response, args.verbose) |
| return result |
| |
| |
| def sdn_controller_list(args): |
| tenant = _get_tenant() |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| |
| if args.name: |
| toshow = _get_item_uuid("sdn_controllers", args.name, tenant) |
| URLrequest = "http://%s:%s/openmano/%s/sdn_controllers/%s" %(mano_host, mano_port, tenant, toshow) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s/sdn_controllers" %(mano_host, mano_port, tenant) |
| #print URLrequest |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| if args.verbose==None: |
| args.verbose=0 |
| if args.name!=None: |
| args.verbose += 1 |
| |
| # json.dumps(mano_response.json(), indent=4) |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def sdn_controller_delete(args): |
| tenant = _get_tenant() |
| controller_uuid = _get_item_uuid("sdn_controllers", args.name, tenant) |
| |
| if not args.force: |
| r = raw_input("Delete SDN controller %s (y/N)? " % (args.name)) |
| if not (len(r) > 0 and r[0].lower() == "y"): |
| return 0 |
| |
| URLrequest = "http://%s:%s/openmano/%s/sdn_controllers/%s" % (mano_host, mano_port, tenant, controller_uuid) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text) |
| return _print_verbose(mano_response, args.verbose) |
| |
| def vim_action(args): |
| #print "datacenter-net-action",args |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.datacenter, tenant) |
| if args.verbose==None: |
| args.verbose=0 |
| if args.action=="list": |
| URLrequest = "http://%s:%s/openmano/%s/vim/%s/%ss" %(mano_host, mano_port, tenant, datacenter, args.item) |
| if args.name!=None: |
| args.verbose += 1 |
| URLrequest += "/" + args.name |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| return _print_verbose(mano_response, args.verbose) |
| elif args.action=="delete": |
| URLrequest = "http://%s:%s/openmano/%s/vim/%s/%ss/%s" %(mano_host, mano_port, tenant, datacenter, args.item, args.name) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| result = 0 if mano_response.status_code==200 else mano_response.status_code |
| content = mano_response.json() |
| #print json.dumps(content, indent=4) |
| if mano_response.status_code == 200: |
| print content['result'] |
| else: |
| print content['error']['description'] |
| return result |
| elif args.action=="create": |
| headers_req = {'content-type': 'application/yaml'} |
| if args.file: |
| create_dict = _load_file_or_yaml(args.file) |
| if args.item not in create_dict: |
| create_dict = {args.item: create_dict} |
| else: |
| create_dict = {args.item:{}} |
| if args.name: |
| create_dict[args.item]['name'] = args.name |
| #if args.description: |
| # create_dict[args.item]['description'] = args.description |
| if args.item=="network": |
| if args.bind_net: |
| create_dict[args.item]['bind_net'] = args.bind_net |
| if args.type: |
| create_dict[args.item]['type'] = args.type |
| if args.shared: |
| create_dict[args.item]['shared'] = args.shared |
| if "name" not in create_dict[args.item]: |
| print "You must provide a name in the descriptor file or with the --name option" |
| return |
| payload_req = yaml.safe_dump(create_dict, explicit_start=True, indent=4, default_flow_style=False, tags=False, encoding='utf-8', allow_unicode=True) |
| logger.debug("openmano request: %s", payload_req) |
| URLrequest = "http://%s:%s/openmano/%s/vim/%s/%ss" %(mano_host, mano_port, tenant, datacenter, args.item) |
| mano_response = requests.post(URLrequest, headers = headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| if args.verbose==None: |
| args.verbose=0 |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def _get_items(item, item_name_id=None, datacenter=None, tenant=None): |
| URLrequest = "http://%s:%s/openmano" %(mano_host, mano_port) |
| if tenant: |
| URLrequest += "/" + tenant |
| if datacenter: |
| URLrequest += "/vim/" + datacenter |
| if item: |
| URLrequest += "/" + item +"s" |
| if item_name_id: |
| URLrequest += "/" + item_name_id |
| mano_response = requests.get(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text ) |
| |
| return mano_response |
| |
| |
| def vim_net_sdn_attach(args): |
| #Verify the network exists in the vim |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.datacenter, tenant) |
| result = _get_items('network', item_name_id=args.vim_net, datacenter=datacenter, tenant=tenant) |
| content = yaml.load(result.content) |
| if 'networks' in content: |
| raise OpenmanoCLIError('More than one network in the vim named ' + args.vim_net + '. Use uuid instead') |
| if 'error' in content: |
| raise OpenmanoCLIError(yaml.safe_dump(content)) |
| network_uuid = content['network']['id'] |
| |
| #Make call to attach the dataplane port to the SND network associated to the vim network |
| headers_req = {'content-type': 'application/yaml'} |
| payload_req = {'port': args.port} |
| if args.vlan: |
| payload_req['vlan'] = int(args.vlan) |
| if args.mac: |
| payload_req['mac'] = args.mac |
| |
| URLrequest = "http://%s:%s/openmano/%s/vim/%s/network/%s/attach" % (mano_host, mano_port, tenant, datacenter, network_uuid) |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.post(URLrequest, headers=headers_req, data=json.dumps(payload_req)) |
| logger.debug("openmano response: %s", mano_response.text) |
| result = _print_verbose(mano_response, args.verbose) |
| return result |
| |
| |
| def vim_net_sdn_detach(args): |
| if not args.all and not args.id: |
| print "--all or --id must be used" |
| return 1 |
| |
| # Verify the network exists in the vim |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.datacenter, tenant) |
| result = _get_items('network', item_name_id=args.vim_net, datacenter=datacenter, tenant=tenant) |
| content = yaml.load(result.content) |
| if 'networks' in content: |
| raise OpenmanoCLIError('More than one network in the vim named ' + args.vim_net + '. Use uuid instead') |
| if 'error' in content: |
| raise OpenmanoCLIError(yaml.safe_dump(content)) |
| network_uuid = content['network']['id'] |
| |
| if not args.force: |
| r = raw_input("Confirm action' (y/N)? ") |
| if len(r) == 0 or r[0].lower() != "y": |
| return 0 |
| |
| if args.id: |
| URLrequest = "http://%s:%s/openmano/%s/vim/%s/network/%s/detach/%s" % ( |
| mano_host, mano_port, tenant, datacenter, network_uuid, args.id) |
| else: |
| URLrequest = "http://%s:%s/openmano/%s/vim/%s/network/%s/detach" % ( |
| mano_host, mano_port, tenant, datacenter, network_uuid) |
| mano_response = requests.delete(URLrequest) |
| logger.debug("openmano response: %s", mano_response.text) |
| result = _print_verbose(mano_response, args.verbose) |
| return result |
| |
| |
| def datacenter_net_action(args): |
| if args.action == "net-update": |
| print "This command is deprecated, use 'openmano datacenter-netmap-delete --all' and 'openmano datacenter-netmap-import' instead!!!" |
| print |
| args.action = "netmap-delete" |
| args.netmap = None |
| args.all = True |
| r = datacenter_netmap_action(args) |
| if r == 0: |
| args.force = True |
| args.action = "netmap-import" |
| r = datacenter_netmap_action(args) |
| return r |
| |
| if args.action == "net-edit": |
| args.netmap = args.net |
| args.name = None |
| elif args.action == "net-list": |
| args.netmap = None |
| elif args.action == "net-delete": |
| args.netmap = args.net |
| args.all = False |
| |
| args.action = "netmap" + args.action[3:] |
| args.vim_name=None |
| args.vim_id=None |
| print "This command is deprecated, use 'openmano datacenter-%s' instead!!!" % args.action |
| print |
| return datacenter_netmap_action(args) |
| |
| def datacenter_netmap_action(args): |
| tenant = _get_tenant() |
| datacenter = _get_datacenter(args.datacenter, tenant) |
| #print "datacenter_netmap_action",args |
| payload_req = None |
| if args.verbose==None: |
| args.verbose=0 |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| URLrequest = "http://%s:%s/openmano/%s/datacenters/%s/netmaps" %(mano_host, mano_port, tenant, datacenter) |
| |
| if args.action=="netmap-list": |
| if args.netmap: |
| URLrequest += "/" + args.netmap |
| args.verbose += 1 |
| mano_response = requests.get(URLrequest) |
| |
| elif args.action=="netmap-delete": |
| if args.netmap and args.all: |
| print "you can not use a netmap name and the option --all at the same time" |
| return 1 |
| if args.netmap: |
| force_text= "Delete default netmap '%s' from datacenter '%s' (y/N)? " % (args.netmap, datacenter) |
| URLrequest += "/" + args.netmap |
| elif args.all: |
| force_text="Delete all default netmaps from datacenter '%s' (y/N)? " % (datacenter) |
| else: |
| print "you must specify a netmap name or the option --all" |
| return 1 |
| if not args.force: |
| r = raw_input(force_text) |
| if len(r)>0 and r[0].lower()=="y": |
| pass |
| else: |
| return 0 |
| mano_response = requests.delete(URLrequest, headers=headers_req) |
| elif args.action=="netmap-import": |
| if not args.force: |
| r = raw_input("Create all the available networks from datacenter '%s' as default netmaps (y/N)? " % (datacenter)) |
| if len(r)>0 and r[0].lower()=="y": |
| pass |
| else: |
| return 0 |
| URLrequest += "/upload" |
| mano_response = requests.post(URLrequest, headers=headers_req) |
| elif args.action=="netmap-edit" or args.action=="netmap-create": |
| if args.file: |
| payload = _load_file_or_yaml(args.file) |
| else: |
| payload = {} |
| if "netmap" not in payload: |
| payload = {"netmap": payload} |
| if args.name: |
| payload["netmap"]["name"] = args.name |
| if args.vim_id: |
| payload["netmap"]["vim_id"] = args.vim_id |
| if args.action=="netmap-create" and args.vim_name: |
| payload["netmap"]["vim_name"] = args.vim_name |
| payload_req = json.dumps(payload) |
| logger.debug("openmano request: %s", payload_req) |
| |
| if args.action=="netmap-edit" and not args.force: |
| if len(payload["netmap"]) == 0: |
| print "You must supply some parameter to edit" |
| return 1 |
| r = raw_input("Edit default netmap '%s' from datacenter '%s' (y/N)? " % (args.netmap, datacenter)) |
| if len(r)>0 and r[0].lower()=="y": |
| pass |
| else: |
| return 0 |
| URLrequest += "/" + args.netmap |
| mano_response = requests.put(URLrequest, headers=headers_req, data=payload_req) |
| else: #netmap-create |
| if "vim_name" not in payload["netmap"] and "vim_id" not in payload["netmap"]: |
| print "You must supply either --vim-id or --vim-name option; or include one of them in the file descriptor" |
| return 1 |
| mano_response = requests.post(URLrequest, headers=headers_req, data=payload_req) |
| |
| logger.debug("openmano response: %s", mano_response.text ) |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def element_edit(args): |
| element = _get_item_uuid(args.element, args.name) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| URLrequest = "http://%s:%s/openmano/%s/%s" %(mano_host, mano_port, args.element, element) |
| payload=_load_file_or_yaml(args.file) |
| if args.element[:-1] not in payload: |
| payload = {args.element[:-1]: payload } |
| payload_req = json.dumps(payload) |
| |
| #print payload_req |
| if not args.force or (args.name==None and args.filer==None): |
| r = raw_input(" Edit " + args.element[:-1] + " " + args.name + " (y/N)? ") |
| if len(r)>0 and r[0].lower()=="y": |
| pass |
| else: |
| return 0 |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.put(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text ) |
| if args.verbose==None: |
| args.verbose=0 |
| if args.name!=None: |
| args.verbose += 1 |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def datacenter_edit(args): |
| tenant = _get_tenant() |
| element = _get_item_uuid('datacenters', args.name, tenant) |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| URLrequest = "http://%s:%s/openmano/datacenters/%s" % (mano_host, mano_port, element) |
| |
| has_arguments = False |
| if args.file != None: |
| has_arguments = True |
| payload = _load_file_or_yaml(args.file) |
| else: |
| payload = {} |
| |
| if args.sdn_controller != None: |
| has_arguments = True |
| if not 'config' in payload: |
| payload['config'] = {} |
| if not 'sdn-controller' in payload['config']: |
| payload['config']['sdn-controller'] = {} |
| if args.sdn_controller == 'null': |
| payload['config']['sdn-controller'] = None |
| else: |
| payload['config']['sdn-controller'] = _get_item_uuid("sdn_controllers", args.sdn_controller, tenant) |
| |
| if not has_arguments: |
| raise OpenmanoCLIError("At least one argument must be provided to modify the datacenter") |
| |
| if 'datacenter' not in payload: |
| payload = {'datacenter': payload} |
| payload_req = json.dumps(payload) |
| |
| # print payload_req |
| if not args.force or (args.name == None and args.filer == None): |
| r = raw_input(" Edit datacenter " + args.name + " (y/N)? ") |
| if len(r) > 0 and r[0].lower() == "y": |
| pass |
| else: |
| return 0 |
| logger.debug("openmano request: %s", payload_req) |
| mano_response = requests.put(URLrequest, headers=headers_req, data=payload_req) |
| logger.debug("openmano response: %s", mano_response.text) |
| if args.verbose == None: |
| args.verbose = 0 |
| if args.name != None: |
| args.verbose += 1 |
| return _print_verbose(mano_response, args.verbose) |
| |
| |
| def version(args): |
| headers_req = {'Accept': 'application/json', 'content-type': 'application/json'} |
| URLrequest = "http://%s:%s/openmano/version" % (mano_host, mano_port) |
| |
| mano_response = requests.get(URLrequest, headers=headers_req) |
| logger.debug("openmano response: %s", mano_response.text) |
| print mano_response.text |
| |
| |
| global mano_host |
| global mano_port |
| global mano_tenant |
| |
| if __name__=="__main__": |
| |
| mano_tenant = os.getenv('OPENMANO_TENANT', None) |
| mano_host = os.getenv('OPENMANO_HOST',"localhost") |
| mano_port = os.getenv('OPENMANO_PORT',"9090") |
| mano_datacenter = os.getenv('OPENMANO_DATACENTER',None) |
| |
| main_parser = ThrowingArgumentParser(description='User program to interact with OPENMANO-SERVER (openmanod)') |
| main_parser.add_argument('--version', action='version', help="get version of this client", |
| version='%(prog)s client version ' + __version__ + |
| " (Note: use '%(prog)s version' to get server version)") |
| |
| subparsers = main_parser.add_subparsers(help='commands') |
| |
| parent_parser = argparse.ArgumentParser(add_help=False) |
| parent_parser.add_argument('--verbose', '-v', action='count', help="increase verbosity level. Use several times") |
| parent_parser.add_argument('--debug', '-d', action='store_true', help="show debug information") |
| |
| config_parser = subparsers.add_parser('config', parents=[parent_parser], help="prints configuration values") |
| config_parser.add_argument("-n", action="store_true", help="resolves tenant and datacenter names") |
| config_parser.set_defaults(func=config) |
| |
| version_parser = subparsers.add_parser('version', parents=[parent_parser], help="get server version") |
| version_parser.set_defaults(func=version) |
| |
| vnf_create_parser = subparsers.add_parser('vnf-create', parents=[parent_parser], help="adds a vnf into the catalogue") |
| vnf_create_parser.add_argument("file", action="store", help="location of the JSON file describing the VNF").completer = FilesCompleter |
| vnf_create_parser.add_argument("--name", action="store", help="name of the VNF (if it exists in the VNF descriptor, it is overwritten)") |
| vnf_create_parser.add_argument("--description", action="store", help="description of the VNF (if it exists in the VNF descriptor, it is overwritten)") |
| vnf_create_parser.add_argument("--image-path", action="store", help="change image path locations (overwritten)") |
| vnf_create_parser.add_argument("--image-name", action="store", help="change image name (overwritten)") |
| vnf_create_parser.add_argument("--image-checksum", action="store", help="change image checksum (overwritten)") |
| vnf_create_parser.set_defaults(func=vnf_create) |
| |
| vnf_list_parser = subparsers.add_parser('vnf-list', parents=[parent_parser], help="lists information about a vnf") |
| vnf_list_parser.add_argument("name", nargs='?', help="name of the VNF") |
| vnf_list_parser.add_argument("-a", "--all", action="store_true", help="shows all vnfs, not only the owned or public ones") |
| #vnf_list_parser.add_argument('--descriptor', help="prints the VNF descriptor", action="store_true") |
| vnf_list_parser.set_defaults(func=vnf_list) |
| |
| vnf_delete_parser = subparsers.add_parser('vnf-delete', parents=[parent_parser], help="deletes a vnf from the catalogue") |
| vnf_delete_parser.add_argument("name", action="store", help="name or uuid of the VNF to be deleted") |
| vnf_delete_parser.add_argument("-f", "--force", action="store_true", help="forces deletion without asking") |
| vnf_delete_parser.add_argument("-a", "--all", action="store_true", help="allow delete not owned or privated one") |
| vnf_delete_parser.set_defaults(func=vnf_delete) |
| |
| scenario_create_parser = subparsers.add_parser('scenario-create', parents=[parent_parser], help="adds a scenario into the OPENMANO DB") |
| scenario_create_parser.add_argument("file", action="store", help="location of the YAML file describing the scenario").completer = FilesCompleter |
| scenario_create_parser.add_argument("--name", action="store", help="name of the scenario (if it exists in the YAML scenario, it is overwritten)") |
| scenario_create_parser.add_argument("--description", action="store", help="description of the scenario (if it exists in the YAML scenario, it is overwritten)") |
| scenario_create_parser.set_defaults(func=scenario_create) |
| |
| scenario_list_parser = subparsers.add_parser('scenario-list', parents=[parent_parser], help="lists information about a scenario") |
| scenario_list_parser.add_argument("name", nargs='?', help="name of the scenario") |
| #scenario_list_parser.add_argument('--descriptor', help="prints the scenario descriptor", action="store_true") |
| scenario_list_parser.add_argument("-a", "--all", action="store_true", help="shows all scenarios, not only the owned or public ones") |
| scenario_list_parser.set_defaults(func=scenario_list) |
| |
| scenario_delete_parser = subparsers.add_parser('scenario-delete', parents=[parent_parser], help="deletes a scenario from the OPENMANO DB") |
| scenario_delete_parser.add_argument("name", action="store", help="name or uuid of the scenario to be deleted") |
| scenario_delete_parser.add_argument("-f", "--force", action="store_true", help="forces deletion without asking") |
| scenario_delete_parser.add_argument("-a", "--all", action="store_true", help="allow delete not owned or privated one") |
| scenario_delete_parser.set_defaults(func=scenario_delete) |
| |
| scenario_deploy_parser = subparsers.add_parser('scenario-deploy', parents=[parent_parser], help="deploys a scenario") |
| scenario_deploy_parser.add_argument("scenario", action="store", help="name or uuid of the scenario to be deployed") |
| scenario_deploy_parser.add_argument("name", action="store", help="name of the instance") |
| scenario_deploy_parser.add_argument("--nostart", action="store_true", help="does not start the vms, just reserve resources") |
| scenario_deploy_parser.add_argument("--datacenter", action="store", help="specifies the datacenter. Needed if several datacenters are available") |
| scenario_deploy_parser.add_argument("--description", action="store", help="description of the instance") |
| scenario_deploy_parser.set_defaults(func=scenario_deploy) |
| |
| scenario_deploy_parser = subparsers.add_parser('scenario-verify', help="verifies if a scenario can be deployed (deploys it and deletes it)") |
| scenario_deploy_parser.add_argument("scenario", action="store", help="name or uuid of the scenario to be verified") |
| scenario_deploy_parser.add_argument('--debug', '-d', action='store_true', help="show debug information") |
| scenario_deploy_parser.set_defaults(func=scenario_verify) |
| |
| instance_scenario_create_parser = subparsers.add_parser('instance-scenario-create', parents=[parent_parser], help="deploys a scenario") |
| instance_scenario_create_parser.add_argument("file", nargs='?', help="descriptor of the instance. Must be a file or yaml/json text") |
| instance_scenario_create_parser.add_argument("--scenario", action="store", help="name or uuid of the scenario to be deployed") |
| instance_scenario_create_parser.add_argument("--name", action="store", help="name of the instance") |
| instance_scenario_create_parser.add_argument("--nostart", action="store_true", help="does not start the vms, just reserve resources") |
| instance_scenario_create_parser.add_argument("--datacenter", action="store", help="specifies the datacenter. Needed if several datacenters are available") |
| instance_scenario_create_parser.add_argument("--netmap-use", action="append", type=str, dest="netmap_use", help="indicates a datacenter network to map a scenario network 'scenario-network=datacenter-network'. Can be used several times") |
| instance_scenario_create_parser.add_argument("--netmap-create", action="append", type=str, dest="netmap_create", help="the scenario network must be created at datacenter 'scenario-network[=datacenter-network-name]' . Can be used several times") |
| instance_scenario_create_parser.add_argument("--keypair", action="append", type=str, dest="keypair", help="public key for ssh access. Format '[user:]key1[,key2...]'. Can be used several times") |
| instance_scenario_create_parser.add_argument("--keypair-auto", action="store_true", dest="keypair_auto", help="Inject the user ssh-keys found at $HOME/.ssh directory") |
| instance_scenario_create_parser.add_argument("--description", action="store", help="description of the instance") |
| instance_scenario_create_parser.set_defaults(func=instance_create) |
| |
| instance_scenario_list_parser = subparsers.add_parser('instance-scenario-list', parents=[parent_parser], help="lists information about a scenario instance") |
| instance_scenario_list_parser.add_argument("name", nargs='?', help="name of the scenario instance") |
| instance_scenario_list_parser.add_argument("-a", "--all", action="store_true", help="shows all instance-scenarios, not only the owned") |
| instance_scenario_list_parser.set_defaults(func=instance_scenario_list) |
| |
| instance_scenario_delete_parser = subparsers.add_parser('instance-scenario-delete', parents=[parent_parser], help="deletes a scenario instance (and deletes all VM and net instances in VIM)") |
| instance_scenario_delete_parser.add_argument("name", action="store", help="name or uuid of the scenario instance to be deleted") |
| instance_scenario_delete_parser.add_argument("-f", "--force", action="store_true", help="forces deletion without asking") |
| instance_scenario_delete_parser.add_argument("-a", "--all", action="store_true", help="allow delete not owned or privated one") |
| instance_scenario_delete_parser.set_defaults(func=instance_scenario_delete) |
| |
| instance_scenario_action_parser = subparsers.add_parser('instance-scenario-action', parents=[parent_parser], help="invoke an action over part or the whole scenario instance") |
| instance_scenario_action_parser.add_argument("name", action="store", help="name or uuid of the scenario instance") |
| instance_scenario_action_parser.add_argument("action", action="store", type=str, \ |
| choices=["start","pause","resume","shutoff","shutdown","forceOff","rebuild","reboot", "console"],\ |
| help="action to send") |
| instance_scenario_action_parser.add_argument("param", nargs='?', help="addional param of the action. e.g. console type (novnc, ...), reboot type (TODO)") |
| instance_scenario_action_parser.add_argument("--vnf", action="append", help="VNF to act on (can use several entries)") |
| instance_scenario_action_parser.add_argument("--vm", action="append", help="VM to act on (can use several entries)") |
| instance_scenario_action_parser.set_defaults(func=instance_scenario_action) |
| |
| #instance_scenario_status_parser = subparsers.add_parser('instance-scenario-status', help="show the status of a scenario instance") |
| #instance_scenario_status_parser.add_argument("name", action="store", help="name or uuid of the scenario instance") |
| #instance_scenario_status_parser.set_defaults(func=instance_scenario_status) |
| |
| tenant_create_parser = subparsers.add_parser('tenant-create', parents=[parent_parser], help="creates a new tenant") |
| tenant_create_parser.add_argument("name", action="store", help="name for the tenant") |
| tenant_create_parser.add_argument("--description", action="store", help="description of the tenant") |
| tenant_create_parser.set_defaults(func=tenant_create) |
| |
| tenant_delete_parser = subparsers.add_parser('tenant-delete', parents=[parent_parser], help="deletes a tenant from the catalogue") |
| tenant_delete_parser.add_argument("name", action="store", help="name or uuid of the tenant to be deleted") |
| tenant_delete_parser.add_argument("-f", "--force", action="store_true", help="forces deletion without asking") |
| tenant_delete_parser.set_defaults(func=tenant_delete) |
| |
| tenant_list_parser = subparsers.add_parser('tenant-list', parents=[parent_parser], help="lists information about a tenant") |
| tenant_list_parser.add_argument("name", nargs='?', help="name or uuid of the tenant") |
| tenant_list_parser.set_defaults(func=tenant_list) |
| |
| element_edit_parser = subparsers.add_parser('tenant-edit', parents=[parent_parser], help="edits one tenant") |
| element_edit_parser.add_argument("name", help="name or uuid of the tenant") |
| element_edit_parser.add_argument("file", help="json/yaml text or file with the changes").completer = FilesCompleter |
| element_edit_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation") |
| element_edit_parser.set_defaults(func=element_edit, element='tenants') |
| |
| datacenter_create_parser = subparsers.add_parser('datacenter-create', parents=[parent_parser], help="creates a new datacenter") |
| datacenter_create_parser.add_argument("name", action="store", help="name for the datacenter") |
| datacenter_create_parser.add_argument("url", action="store", help="url for the datacenter") |
| datacenter_create_parser.add_argument("--url_admin", action="store", help="url for administration for the datacenter") |
| datacenter_create_parser.add_argument("--type", action="store", help="datacenter type: openstack or openvim (default)") |
| datacenter_create_parser.add_argument("--config", action="store", help="aditional configuration in json/yaml format") |
| datacenter_create_parser.add_argument("--description", action="store", help="description of the datacenter") |
| datacenter_create_parser.add_argument("--sdn-controller", action="store", help="Name or uuid of the SDN controller to be used", dest='sdn_controller') |
| datacenter_create_parser.set_defaults(func=datacenter_create) |
| |
| datacenter_delete_parser = subparsers.add_parser('datacenter-delete', parents=[parent_parser], help="deletes a datacenter from the catalogue") |
| datacenter_delete_parser.add_argument("name", action="store", help="name or uuid of the datacenter to be deleted") |
| datacenter_delete_parser.add_argument("-f", "--force", action="store_true", help="forces deletion without asking") |
| datacenter_delete_parser.set_defaults(func=datacenter_delete) |
| |
| datacenter_edit_parser = subparsers.add_parser('datacenter-edit', parents=[parent_parser], help="Edit datacenter") |
| datacenter_edit_parser.add_argument("name", help="name or uuid of the datacenter") |
| datacenter_edit_parser.add_argument("--file", help="json/yaml text or file with the changes").completer = FilesCompleter |
| datacenter_edit_parser.add_argument("--sdn-controller", action="store", |
| help="Name or uuid of the SDN controller to be used. Specify 'null' to clear entry", dest='sdn_controller') |
| datacenter_edit_parser.add_argument("-f", "--force", action="store_true", help="do not prompt for confirmation") |
| datacenter_edit_parser.set_defaults(func=datacenter_edit) |
| |
| datacenter_list_parser = subparsers.add_parser('datacenter-list', parents=[parent_parser], help="lists information about a datacenter") |
| datacenter_list_parser.add_argument("name", nargs='?', help="name or uuid of the datacenter") |
| datacenter_list_parser.add_argument("-a", "--all", action="store_true", help="shows all datacenters, not only datacenters attached to tenant") |
| datacenter_list_parser.set_defaults(func=datacenter_list) |
| |
| datacenter_attach_parser = subparsers.add_parser('datacenter-attach', parents=[parent_parser], help="associates a datacenter to the operating tenant") |
| datacenter_attach_parser.add_argument("name", help="name or uuid of the datacenter") |
| datacenter_attach_parser.add_argument('--vim-tenant-id', action='store', help="specify a datacenter tenant to use. A new one is created by default") |
| datacenter_attach_parser.add_argument('--vim-tenant-name', action='store', help="specify a datacenter tenant name.") |
| datacenter_attach_parser.add_argument("--user", action="store", help="user credentials for the datacenter") |
| datacenter_attach_parser.add_argument("--password", action="store", help="password credentials for the datacenter") |
| datacenter_attach_parser.add_argument("--config", action="store", help="aditional configuration in json/yaml format") |
| datacenter_attach_parser.set_defaults(func=datacenter_attach) |
| |
| datacenter_edit_vim_tenant_parser = subparsers.add_parser('datacenter-edit-vim-tenant', parents=[parent_parser], |
| help="Edit the association of a datacenter to the operating tenant") |
| datacenter_edit_vim_tenant_parser.add_argument("name", help="name or uuid of the datacenter") |
| datacenter_edit_vim_tenant_parser.add_argument('--vim-tenant-id', action='store', |
| help="specify a datacenter tenant to use. A new one is created by default") |
| datacenter_edit_vim_tenant_parser.add_argument('--vim-tenant-name', action='store', help="specify a datacenter tenant name.") |
| datacenter_edit_vim_tenant_parser.add_argument("--user", action="store", help="user credentials for the datacenter") |
| datacenter_edit_vim_tenant_parser.add_argument("--password", action="store", help="password credentials for the datacenter") |
| datacenter_edit_vim_tenant_parser.add_argument("--config", action="store", |
| help="aditional configuration in json/yaml format") |
| datacenter_edit_vim_tenant_parser.set_defaults(func=datacenter_edit_vim_tenant) |
| |
| datacenter_detach_parser = subparsers.add_parser('datacenter-detach', parents=[parent_parser], help="removes the association between a datacenter and the operating tenant") |
| datacenter_detach_parser.add_argument("name", help="name or uuid of the datacenter") |
| datacenter_detach_parser.add_argument("-a", "--all", action="store_true", help="removes all associations from this datacenter") |
| datacenter_detach_parser.set_defaults(func=datacenter_detach) |
| |
| #=======================datacenter_sdn_port_mapping_xxx section======================= |
| #datacenter_sdn_port_mapping_set |
| datacenter_sdn_port_mapping_set_parser = subparsers.add_parser('datacenter-sdn-port-mapping-set', |
| parents=[parent_parser], |
| help="Load a file with the mapping of physical ports " |
| "and the ports of the dataplaneswitch controlled " |
| "by a datacenter") |
| datacenter_sdn_port_mapping_set_parser.add_argument("name", action="store", help="specifies the datacenter") |
| datacenter_sdn_port_mapping_set_parser.add_argument("file", |
| help="json/yaml text or file with the port mapping").completer = FilesCompleter |
| datacenter_sdn_port_mapping_set_parser.add_argument("-f", "--force", action="store_true", |
| help="forces overwriting without asking") |
| datacenter_sdn_port_mapping_set_parser.set_defaults(func=datacenter_sdn_port_mapping_set) |
| |
| #datacenter_sdn_port_mapping_list |
| datacenter_sdn_port_mapping_list_parser = subparsers.add_parser('datacenter-sdn-port-mapping-list', |
| parents=[parent_parser], |
| help="Show the SDN port mapping in a datacenter") |
| datacenter_sdn_port_mapping_list_parser.add_argument("name", action="store", help="specifies the datacenter") |
| datacenter_sdn_port_mapping_list_parser.set_defaults(func=datacenter_sdn_port_mapping_list) |
| |
| # datacenter_sdn_port_mapping_clear |
| datacenter_sdn_port_mapping_clear_parser = subparsers.add_parser('datacenter-sdn-port-mapping-clear', |
| parents=[parent_parser], |
| help="Clean the the SDN port mapping in a datacenter") |
| datacenter_sdn_port_mapping_clear_parser.add_argument("name", action="store", |
| help="specifies the datacenter") |
| datacenter_sdn_port_mapping_clear_parser.add_argument("-f", "--force", action="store_true", |
| help="forces clearing without asking") |
| datacenter_sdn_port_mapping_clear_parser.set_defaults(func=datacenter_sdn_port_mapping_clear) |
| # ======================= |
| |
| # =======================sdn_controller_xxx section======================= |
| # sdn_controller_create |
| sdn_controller_create_parser = subparsers.add_parser('sdn-controller-create', parents=[parent_parser], |
| help="Creates an SDN controller entity within RO") |
| sdn_controller_create_parser.add_argument("name", help="name of the SDN controller") |
| sdn_controller_create_parser.add_argument("--description", action="store", help="description of the SDN controller") |
| sdn_controller_create_parser.add_argument("--ip", action="store", help="IP of the SDN controller") |
| sdn_controller_create_parser.add_argument("--port", action="store", help="Port of the SDN controller") |
| sdn_controller_create_parser.add_argument("--dpid", action="store", |
| help="DPID of the dataplane switch controlled by this SDN controller") |
| sdn_controller_create_parser.add_argument("--type", action="store", |
| help="Specify the SDN controller type. Valid types are 'opendaylight' and 'floodlight'") |
| sdn_controller_create_parser.add_argument("--user", action="store", help="user credentials for the SDN controller") |
| sdn_controller_create_parser.add_argument("--passwd", action="store", dest='password', |
| help="password credentials for the SDN controller") |
| sdn_controller_create_parser.set_defaults(func=sdn_controller_create) |
| |
| # sdn_controller_edit |
| sdn_controller_edit_parser = subparsers.add_parser('sdn-controller-edit', parents=[parent_parser], |
| help="Update one or more options of a SDN controller") |
| sdn_controller_edit_parser.add_argument("name", help="name or uuid of the SDN controller", ) |
| sdn_controller_edit_parser.add_argument("--name", action="store", help="Update the name of the SDN controller", |
| dest='new_name') |
| sdn_controller_edit_parser.add_argument("--description", action="store", help="description of the SDN controller") |
| sdn_controller_edit_parser.add_argument("--ip", action="store", help="IP of the SDN controller") |
| sdn_controller_edit_parser.add_argument("--port", action="store", help="Port of the SDN controller") |
| sdn_controller_edit_parser.add_argument("--dpid", action="store", |
| help="DPID of the dataplane switch controlled by this SDN controller") |
| sdn_controller_edit_parser.add_argument("--type", action="store", |
| help="Specify the SDN controller type. Valid types are 'opendaylight' and 'floodlight'") |
| sdn_controller_edit_parser.add_argument("--user", action="store", help="user credentials for the SDN controller") |
| sdn_controller_edit_parser.add_argument("--password", action="store", |
| help="password credentials for the SDN controller", dest='password') |
| sdn_controller_edit_parser.add_argument("-f", "--force", action="store_true", help="do not prompt for confirmation") |
| #TODO: include option --file |
| sdn_controller_edit_parser.set_defaults(func=sdn_controller_edit) |
| |
| #sdn_controller_list |
| sdn_controller_list_parser = subparsers.add_parser('sdn-controller-list', |
| parents=[parent_parser], |
| help="List the SDN controllers") |
| sdn_controller_list_parser.add_argument("name", nargs='?', help="name or uuid of the SDN controller") |
| sdn_controller_list_parser.set_defaults(func=sdn_controller_list) |
| |
| # sdn_controller_delete |
| sdn_controller_delete_parser = subparsers.add_parser('sdn-controller-delete', |
| parents=[parent_parser], |
| help="Delete the the SDN controller") |
| sdn_controller_delete_parser.add_argument("name", help="name or uuid of the SDN controller") |
| sdn_controller_delete_parser.add_argument("-f", "--force", action="store_true", help="forces deletion without asking") |
| sdn_controller_delete_parser.set_defaults(func=sdn_controller_delete) |
| # ======================= |
| |
| action_dict={'net-update': 'retrieves external networks from datacenter', |
| 'net-edit': 'edits an external network', |
| 'net-delete': 'deletes an external network', |
| 'net-list': 'lists external networks from a datacenter' |
| } |
| for item in action_dict: |
| datacenter_action_parser = subparsers.add_parser('datacenter-'+item, parents=[parent_parser], help=action_dict[item]) |
| datacenter_action_parser.add_argument("datacenter", help="name or uuid of the datacenter") |
| if item=='net-edit' or item=='net-delete': |
| datacenter_action_parser.add_argument("net", help="name or uuid of the datacenter net") |
| if item=='net-edit': |
| datacenter_action_parser.add_argument("file", help="json/yaml text or file with the changes").completer = FilesCompleter |
| if item!='net-list': |
| datacenter_action_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation") |
| datacenter_action_parser.set_defaults(func=datacenter_net_action, action=item) |
| |
| |
| action_dict={'netmap-import': 'create network senario netmap base on the datacenter networks', |
| 'netmap-create': 'create a new network senario netmap', |
| 'netmap-edit': 'edit name of a network senario netmap', |
| 'netmap-delete': 'deletes a network scenario netmap (--all for clearing all)', |
| 'netmap-list': 'list/show network scenario netmaps' |
| } |
| for item in action_dict: |
| datacenter_action_parser = subparsers.add_parser('datacenter-'+item, parents=[parent_parser], help=action_dict[item]) |
| datacenter_action_parser.add_argument("--datacenter", help="name or uuid of the datacenter") |
| #if item=='net-add': |
| # datacenter_action_parser.add_argument("net", help="name of the network") |
| if item=='netmap-delete': |
| datacenter_action_parser.add_argument("netmap", nargs='?',help="name or uuid of the datacenter netmap to delete") |
| datacenter_action_parser.add_argument("--all", action="store_true", help="delete all netmap of this datacenter") |
| datacenter_action_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation") |
| if item=='netmap-edit': |
| datacenter_action_parser.add_argument("netmap", help="name or uuid of the datacenter netmap do edit") |
| datacenter_action_parser.add_argument("file", nargs='?', help="json/yaml text or file with the changes").completer = FilesCompleter |
| datacenter_action_parser.add_argument("--name", action='store', help="name to assign to the datacenter netmap") |
| datacenter_action_parser.add_argument('--vim-id', action='store', help="specify vim network uuid") |
| datacenter_action_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation") |
| if item=='netmap-list': |
| datacenter_action_parser.add_argument("netmap", nargs='?',help="name or uuid of the datacenter netmap to show") |
| if item=='netmap-create': |
| datacenter_action_parser.add_argument("file", nargs='?', help="json/yaml text or file descriptor with the changes").completer = FilesCompleter |
| datacenter_action_parser.add_argument("--name", action='store', help="name to assign to the datacenter netmap, by default same as vim-name") |
| datacenter_action_parser.add_argument('--vim-id', action='store', help="specify vim network uuid") |
| datacenter_action_parser.add_argument('--vim-name', action='store', help="specify vim network name") |
| if item=='netmap-import': |
| datacenter_action_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation") |
| datacenter_action_parser.set_defaults(func=datacenter_netmap_action, action=item) |
| |
| # =======================vim_net_sdn_xxx section======================= |
| # vim_net_sdn_attach |
| vim_net_sdn_attach_parser = subparsers.add_parser('vim-net-sdn-attach', |
| parents=[parent_parser], |
| help="Specify the port to access to an external network using SDN") |
| vim_net_sdn_attach_parser.add_argument("vim_net", action="store", |
| help="Name/id of the network in the vim that will be used to connect to the external network") |
| vim_net_sdn_attach_parser.add_argument("port", action="store", help="Specifies the port in the dataplane switch to access to the external network") |
| vim_net_sdn_attach_parser.add_argument("--vlan", action="store", help="Specifies the vlan (if any) to use in the defined port") |
| vim_net_sdn_attach_parser.add_argument("--mac", action="store", help="Specifies the MAC (if known) of the physical device that will be reachable by this external port") |
| vim_net_sdn_attach_parser.add_argument("--datacenter", action="store", help="specifies the datacenter") |
| vim_net_sdn_attach_parser.set_defaults(func=vim_net_sdn_attach) |
| |
| # vim_net_sdn_detach |
| vim_net_sdn_detach_parser = subparsers.add_parser('vim-net-sdn-detach', |
| parents=[parent_parser], |
| help="Remove the port information to access to an external network using SDN") |
| |
| vim_net_sdn_detach_parser.add_argument("vim_net", action="store", help="Name/id of the vim network") |
| vim_net_sdn_detach_parser.add_argument("--id", action="store",help="Specify the uuid of the external ports from this network to be detached") |
| vim_net_sdn_detach_parser.add_argument("--all", action="store_true", help="Detach all external ports from this network") |
| vim_net_sdn_detach_parser.add_argument("-f", "--force", action="store_true", help="forces clearing without asking") |
| vim_net_sdn_detach_parser.add_argument("--datacenter", action="store", help="specifies the datacenter") |
| vim_net_sdn_detach_parser.set_defaults(func=vim_net_sdn_detach) |
| # ======================= |
| |
| for item in ("network", "tenant", "image"): |
| if item=="network": |
| command_name = 'vim-net' |
| else: |
| command_name = 'vim-'+item |
| vim_item_list_parser = subparsers.add_parser(command_name + '-list', parents=[parent_parser], help="list the vim " + item + "s") |
| vim_item_list_parser.add_argument("name", nargs='?', help="name or uuid of the " + item + "s") |
| vim_item_list_parser.add_argument("--datacenter", action="store", help="specifies the datacenter") |
| vim_item_list_parser.set_defaults(func=vim_action, item=item, action="list") |
| |
| vim_item_del_parser = subparsers.add_parser(command_name + '-delete', parents=[parent_parser], help="list the vim " + item + "s") |
| vim_item_del_parser.add_argument("name", help="name or uuid of the " + item + "s") |
| vim_item_del_parser.add_argument("--datacenter", action="store", help="specifies the datacenter") |
| vim_item_del_parser.set_defaults(func=vim_action, item=item, action="delete") |
| |
| if item == "network" or item == "tenant": |
| vim_item_create_parser = subparsers.add_parser(command_name + '-create', parents=[parent_parser], help="create a "+item+" at vim") |
| vim_item_create_parser.add_argument("file", nargs='?', help="descriptor of the %s. Must be a file or yaml/json text" % item).completer = FilesCompleter |
| vim_item_create_parser.add_argument("--name", action="store", help="name of the %s" % item ) |
| vim_item_create_parser.add_argument("--datacenter", action="store", help="specifies the datacenter") |
| if item=="network": |
| vim_item_create_parser.add_argument("--type", action="store", help="type of network, data, ptp, bridge") |
| vim_item_create_parser.add_argument("--shared", action="store_true", help="Private or shared") |
| vim_item_create_parser.add_argument("--bind-net", action="store", help="For openvim datacenter type, net to be bind to, for vlan type, use sufix ':<vlan_tag>'") |
| else: |
| vim_item_create_parser.add_argument("--description", action="store", help="description of the %s" % item) |
| vim_item_create_parser.set_defaults(func=vim_action, item=item, action="create") |
| |
| argcomplete.autocomplete(main_parser) |
| |
| try: |
| args = main_parser.parse_args() |
| #logging info |
| level = logging.CRITICAL |
| streamformat = "%(asctime)s %(name)s %(levelname)s: %(message)s" |
| if "debug" in args and args.debug: |
| level = logging.DEBUG |
| logging.basicConfig(format=streamformat, level= level) |
| logger = logging.getLogger('mano') |
| logger.setLevel(level) |
| result = args.func(args) |
| if result == None: |
| result = 0 |
| #for some reason it fails if call exit inside try instance. Need to call exit at the end !? |
| except (requests.exceptions.ConnectionError): |
| print "Connection error: not possible to contact OPENMANO-SERVER (openmanod)" |
| result = -2 |
| except (KeyboardInterrupt): |
| print 'Exiting openmano' |
| result = -3 |
| except (SystemExit, ArgumentParserError): |
| result = -4 |
| except OpenmanoCLIError as e: |
| print str(e) |
| result = -5 |
| |
| #print result |
| exit(result) |
| |