#!/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 openvim
# 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
##

'''
This is a client for managing the openvim server.
Useful for human CLI management of items at openvim  
'''
__author__="Alfonso Tierno, Gerardo Garcia"
__date__ ="$26-nov-2014 19:09:29$"
__version__="0.4.0-r443"
version_date="Nov 2015"
name="openvim"

from argcomplete.completers import FilesCompleter
import os
import argparse
import argcomplete
import requests
import json
import yaml
from jsonschema import validate as js_v, exceptions as js_e

class ArgumentParserError(Exception): pass

class ThrowingArgumentParser(argparse.ArgumentParser):
    def error(self, message):
        print "Error: %s" %message
        print
        self.print_usage()
        #self.print_help()
        print
        print "Type 'openvim -h' for help"
        raise ArgumentParserError

global vim_config
config_items=("HOST", "PORT", "ADMIN_PORT", "TENANT")
show_at_verbose1=('status', 'created', 'path', 'last_error','description','hostId','progress',
                 'ram','vcpus','type','shared','admin_state_up', 'enabled', 'ip_name')

#template for creating new items
template={
    "port":{
        "${}":[
            "${name} provide a port name",
            "${net_id} provide the network uuid (null):",
            "${vlan} provide the vlan if any (null):",
            "${port} provide the attached switch port (Te0/47)",
            "${mac} provide the mac of external device if known (null):"
        ],
        "port":{
            "name": "${name}",
            "network_id": "${net_id null}",
            "type": "external",
            "binding:vlan": "${vlan null-int}",
            "binding:switch_port": "${port}",
            "mac_address": "${mac null}"
        },
    },
    "network":{
        "${}":[
            "${name} provide a network name",
            "${type} provide a type: bridge_data,bridge_man,data,ptp (data)",
            "${shared} external network: true,false (true)",
            "${phy} conected to: bridge:name,macvtap:iface,default (null)"
        ],
        "network":{
            "name": "${name}",
            "type": "${type}",
            "provider:physical": "${phy null}",
            "shared": "${shared bool}"
        }
    },
    "host": {
        "${}":[
            "${name} host name",
            "${user} host user (user)",
            "${ip_name} host access IP or name (${name})",
            "${description} host description (${name})"
        ],
    
        "host":{
            "name": "${name}",
            "user": "${user}",
            "ip_name": "${ip_name}",
            "description": "${description}"
        }
    },
    "flavor":{
        "${}":[
            "${name} flavor name",
            "${description} flavor description (${name})",
            "${processor_ranking} processor ranking (100)",
            "${memory} memory in GB (2)",
            "${threads} threads needed (2)"
        ],
        "flavor":{
            "name":"${name}",
            "description":"${description}",
            "extended":{
                "processor_ranking":"${processor_ranking int}",
                "numas":[
                    {
                        "memory":"${memory int}",
                        "threads":"${threads int}"
                    }
                ]
            }
        }
    },
    "tenant":{
        "${}":[
            "${name} tenant name",
            "${description} tenant description (${name})"
        ],
        "tenant":{
            "name": "${name}",
            "description": "${description}"
        }
    },
    "image":{
        "${}":[
            "${name} image name",
            "${path} image path (/path/to/shared/compute/host/folder/image.qcow2)",
            "${description} image description (${name})"
        ],
        "image":{
            "name":"${name}",
            "description":"${description}",
            "path":"${path}"
        }
    },
    "server":{
        "${}":[
            "${name} provide a name (VM)",
            "${description} provide a description (${name})",
            "${image_id} provide image_id uuid",
            "${flavor_id} provide flavor_id uuid",
            "${network0} provide a bridge network id; enter='default' (00000000-0000-0000-0000-000000000000)",
            "${network1} provide a bridge network id; enter='virbrMan' (60f5227e-195f-11e4-836d-52540030594e)"
        ],
        "server":{
            "networks":[
                {
                    "name":"mgmt0",
                    "vpci": "0000:00:0a.0",
                    "uuid":"${network0}"
                },
                {
                    "name":"ge0",
                    "vpci": "0000:00:0b.0",
                    "uuid":"${network1}"
                }
            ],
            "name":"${name}",
            "description":"${description}",
            "imageRef":  "${image_id}",
            "flavorRef": "${flavor_id}"
        }
    }
}

def check_configuration(*exception ):
    '''
    Check that the configuration variables are present.
    exception can contain variables that are not tested, normally because is not used for the command
    '''
    #print exception
    for item in config_items:
        if item not in exception and vim_config[item]==None:
            print "OPENVIM_"+item+" variable not defined. Try '" + name + " config file_cfg' or 'export OPENVIM_"+item+"=something'"
            exit(-401); #HTTP_Unauthorized

def check_valid_uuid(uuid):
    '''
    Determines if the param uuid is a well formed uuid. Otherwise it is consider a name
    '''
    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 _print_verbose(row_data, element, verbose=0):
    #print row_data
    data = row_data[element]
    if verbose==1 or verbose==2:
        data2= dict((k,v) for (k,v) in data.iteritems() if k in show_at_verbose1 and v!=None)
        if 'image' in data and 'id' in data['image']:
            data2['image'] = data['image']['id']
        if 'flavor' in data and 'id' in data['flavor']:
            data2['flavor'] = data['flavor']['id']
        if verbose==2:
            #TODO add more intems in a digest mode, extended, numas ...
            pass
            #if "numas" in data
            #if "extended" in data
    else:
        data2= data
    #print json.dumps(c2, indent=4)
#                     keys = data.keys()
#                     for key in keys:
#                         if data[key]==None: del data[key]
#                         elif key=='id' or key=='name' or key=='links': del data[key]
        
    #print json.dumps(data2, indent=4)
    data2={element: data2}
    print yaml.safe_dump(data2, indent=4, default_flow_style=False)
    
def vim_read(url):
    '''
    Send a GET http to VIM
    '''
    headers_req = {'content-type': 'application/json'}
    try:
        vim_response = requests.get(url, headers = headers_req)
        if vim_response.status_code == 200:
        #print vim_response.json()
        #print json.dumps(vim_response.json(), indent=4)
            content = vim_response.json()
            return 1, content
            #print http_content
        else:
            #print " Error. VIM response '%s': not possible to GET %s, error %s" % (vim_response.status_code, url, vim_response.text)
            return -vim_response.status_code, vim_response.text
    except requests.exceptions.RequestException, e:
        return -1, " Exception GET at '"+url+"' " + str(e.message)

def vim_delete(url):
    '''
    Send a DELETE http to VIM
    '''
    headers_req = {'content-type': 'application/json'}
    try:
        vim_response = requests.delete(url, headers = headers_req)
        if vim_response.status_code != 200:
            #print " Error. VIM response '%s': not possible to DELETE %s, error %s" % (vim_response.status_code, url, vim_response.text)
            return -vim_response.status_code, vim_response.text
    except requests.exceptions.RequestException, e:
        return -1, " Exception DELETE at '"+url+"' " + str(e.message)
    return 1, vim_response.json()

def vim_action(url, payload):
    '''
    Send a POST http to VIM
    '''
    headers_req = {'content-type': 'application/json'}
    try:
        vim_response = requests.post(url, data=json.dumps(payload), headers = headers_req)
        if vim_response.status_code != 200:
            #print " Error. VIM response '%s': not possible to POST %s, error %s" % (vim_response.status_code, url, vim_response.text)
            return -vim_response.status_code, vim_response.text
    except requests.exceptions.RequestException, e:
        return -1, " Exception POST at '"+url+"' " + str(e.message)
    return 1, vim_response.json()

def vim_edit(url, payload):
    headers_req = {'content-type': 'application/json'}
    try:
        vim_response = requests.put(url, data=json.dumps(payload), headers = headers_req)
        if vim_response.status_code != 200:
            #print " Error. VIM response '%s': not possible to PUT %s, error %s" % (vim_response.status_code, url, vim_response.text)
            return -vim_response.status_code, vim_response.text
    except requests.exceptions.RequestException, e:
        return -1, " Exception PUT at '"+url+"' " + str(e.message)
    return 1, vim_response.json()

def vim_create(url, payload):
    headers_req = {'Accept': 'application/json', 'content-type': 'application/json'}
    #print str(payload)
    try:
        vim_response = requests.post(url, data=json.dumps(payload), headers=headers_req)
        if vim_response.status_code != 200:
            #print " Error. VIM response '%s': not possible to POST %s, error %s" % (vim_response.status_code, url, vim_response.text)
            return -vim_response.status_code, vim_response.text
    except requests.exceptions.RequestException, e:
        return -1, " Exception POST at '"+url+"' " + str(e.message)
    return 1, vim_response.json()

def parse_yaml_json(text, file_name=None):
    parser_json=None
    if file_name:
        if file_name[-5:]=='.yaml' or file_name[-4:]=='.yml':
            parser_json = False
        elif file_name[-5:]=='.json':
            parser_json = True
    if parser_json==None:
        parser_json=True if '\t' in text else False
            
    if parser_json: #try parse in json format, because yaml does not admit tabs
        try:
            data = json.loads(text) 
            return 0, data
        except Exception as e:
            return -1, "Error json format: " + str(e)
    #try to parse in yaml format
    try:
        data = yaml.load(text)
        return 0, data
    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 -1, " Error yaml format error" + error_pos

def change_string(text, var_list):
    '''
    See change_var_recursively help
    Used for changed any '${var format}' content inside the 'text' string 
    into the corresponding value at 'var_list'[var]
    'format' is optional, string by default. Contain a - separated formats,ej, int-null
    '''
    end=0
    type_=None
    while True:
        ini = text.find("${", end)
        if ini<0: return text
        end = text.find("}", ini) 
        if end<0: return text
        end+=1
        
        var = text[ini:end]
        if ' ' in var:
            kk=var.split(" ")
            var=kk[0]+"}"
            type_=kk[-1][:-1]
        var = var_list.get(var, None)
        if var==None: return text
        
        text =  text[:ini] + var + text[end:]
        if type_ != None:
            if 'null' in type_ and text=="null":
                return None
            if 'int' in type_ : #and text.isnumeric():
                return int(text)
            if 'bool' in type_ : #and text.isnumeric():
                if text.lower()=="true": return True
                elif text.lower()=="false": return False
                else:
                    print "input boolean paramter must be 'true' or 'false'"
                    exit(1)
    return text

def chage_var_recursively(data, var_list):
    '''
    Check recursively the content of 'data', and look for "*${*}*" variables and changes  
    It assumes that this variables are not in the key of dictionary,
    The overall target is having json/yaml templates with this variables in the text. 
    The user is asked for a value that is replaced wherever appears 
    Attributes:
        'data': dictionary, or list. None or empty is considered valid
        'var_list': dictionary (name:change) pairs
    Return:
        None, data is modified
    '''
        
    if type(data) is dict:
        for k in data.keys():
            if type(data[k]) is dict or type(data[k]) is tuple or type(data[k]) is list:
                chage_var_recursively(data[k], var_list)
            elif type(data[k]) is str:
                data[k] = change_string(data[k], var_list)
    if type(data) is list:
        for k in range(0,len(data)):
            if type(data[k]) is dict or type(data[k]) is list:
                chage_var_recursively(data[k], var_list)
            elif type(data[k]) is str:
                data[k] = change_string(data[k], var_list)

def change_var(data, default_values={}):
    ''' Look for a text "${}" key at 'data' that indicates that this json contains 
    variables that must be ask for values to the user and changes in the text of 
    the dictionary
    'default_values' contain a dictionary of values that must be used and not be asked   
    Useful for creating templates
    "${}" entry contain a list with the text:
        ${var-name} prompt text to show user (Default value to allocate if user type CR)
    '''
    if type(data) is not dict:
        return -1, "Format error, not a object (dictionary)"
    if "${}" not in data:
        return 0, data

    var_list={}
    for var in data["${}"]:
        r = var.find("}",) + 1
        if r<=2 or var[:2] != '${':
            return -1, "Format error at '${}':" + var
        #change variables inside description text
        if "${" in var[r:]:
            var = var[:r] + change_string(var[r:], var_list)
        d_start = var.rfind("(",) + 1
        d_end   = var.rfind(")",) 
        if d_start>0 and d_end>=d_start:
            default = var[d_start:d_end]
        else: default=None
        if var[2:r-1] in default_values:
            var_list[ var[:r] ] = default_values[ var[2:r-1] ]
            continue
        v = raw_input(var[r:] + "? ")
        if v=="":
            if default != None:
                v = default
            else:
                v = raw_input("  empty string? try again: ")
        var_list[ var[:r] ] = str(v) 
    del data["${}"]
    chage_var_recursively(data, var_list)
    return 0, data

def load_file(file_, parse=False):
    try:
        f = open(file_, 'r')
        read_data = f.read()
        f.close()
        if not parse:
            return 0, read_data
    except IOError, e:
        return -1, " Error opening file '" + file_ + "': " + e.args[1]
    return parse_yaml_json(read_data, file_)

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 filename 'content',
    if fails trying to parse the 'content' as text
    Returns the dictionary once parsed, or print an error and finish the program
    '''
    r,payload = load_file(content, parse=True)
    if r<0:
        if r==-1 and "{" in content or ":" in content:
            #try to parse directly
            r,payload = parse_yaml_json(content)
            if r<0:
                print payload
                exit (-1)
        else:
            print payload
            exit (-1)
    return payload

def config(args):
    #print "config-list",args
    if args.file != None:
        try:
            f = open(args.file, 'r')
            read_data = f.read()
            f.close()
        except IOError, e:
            print " Error opening file '" + args.file + "': " + e.args[1]
            return -1
        try:
            data = yaml.load(read_data)
            #print data
            if "http_host" in data:
                print "  export OPENVIM_HOST="+ data["http_host"]
            if "http_port" in data:
                print "  export OPENVIM_PORT="+ str(data["http_port"])
                #vim_config[item] = data["OPENVIM_"+item]  #TODO find the way to change envioronment
                #os.setenv('OPENVIM_'+item, vim_config[item])
            if "http_admin_port" in data:
                print "  export OPENVIM_ADMIN_PORT="+ str(data["http_admin_port"])
            if "tenant_id" in data:
                print "  export OPENVIM_TENANT="+ data["tenant_id"]
            return 0
        except yaml.YAMLError, 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 yaml/json format error at '"+ args.file +"'"+error_pos
            return -1
        print args.file
    print "OPENVIM_HOST: %s" %vim_config["HOST"]
    print "OPENVIM_PORT: %s" %vim_config["PORT"]
    print "OPENVIM_ADMIN_PORT: %s" %vim_config["ADMIN_PORT"]
    print "OPENVIM_TENANT: %s" %vim_config["TENANT"]
    return 0

def element_new(args):
    #print args
    tenant=""
    if args.element in ('flavors','images','servers'):
        check_configuration( "ADMIN_PORT" )
        tenant="/"+vim_config["TENANT"]
    else:
        check_configuration("ADMIN_PORT", "TENANT")
        tenant=""
        
    default_values={}
    if args.name != None:
        default_values["name"] = args.name
    if "description" in args and args.description != None:
        default_values["description"] = args.description
    if "path" in args and args.path != None:
        default_values["path"] = args.path
    if args.file==None:
        payload= template[args.element[:-1] ]
        payload = yaml.load(str(payload))  #with this trick we make a completely copy of the data, so to not modified the original one
    else:
        payload=load_file_or_yaml(args.file)
    r,c= change_var(payload, default_values)
    if r<0:
        print "Template error", c
        return -1
    payload=c
    #print payload
    if args.element[:-1] not in payload:
        payload = {args.element[:-1]: payload }
    item = payload[args.element[:-1]]
        
    url = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["PORT"], tenant, args.element)
    if "ADMIN_PORT" in vim_config and vim_config["ADMIN_PORT"]!=None:
        url_admin = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["ADMIN_PORT"], tenant, args.element)
    else:
        url_admin = None
        
    if args.name != None:
        item["name"] = args.name
    if "description" in args and args.description != None:
        item["description"] = args.description
    if "path" in args and args.path != None:
        item["path"] = args.path
    

    r,c = vim_create(url, payload)
    if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
        url=url_admin
        r,c = vim_create(url, payload)
    if r<0:
        print c
        return -r
    else:
        #print c
        item=c[ args.element[:-1] ]
        uuid=item.get('id', None)
        if uuid is None:
            uuid=item.get('uuid', 'uuid-not-found?')
        name = item.get('name', '')
        print " " + uuid +"   "+ name.ljust(20) + " Created"
        for e in ('warning', 'error', 'last_error'):
            if e in item:    print e + "\n" + item[e]
        if args.verbose!=None:
            _print_verbose(c, args.element[:-1], args.verbose)
        return 0

def element_action(args):
    filter_qs = ""
    tenant=""
    if args.element in ('flavors','images','servers'):
        check_configuration( "ADMIN_PORT")
        tenant="/"+vim_config["TENANT"]
    else:
        check_configuration("ADMIN_PORT", "TENANT")
        tenant=""
    url = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["PORT"], tenant, args.element)
    if "ADMIN_PORT" in vim_config and vim_config["ADMIN_PORT"]!=None:
        url_admin = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["ADMIN_PORT"], tenant, args.element)
    else:
        url_admin = None

    if args.filter:
        filter_qs += "?" + args.filter
    if args.name!=None:
        if check_valid_uuid(args.name):
            if len(filter_qs) > 0:  filter_qs += "&" + "id=" + str(args.name)
            else:                   filter_qs += "?" + "id=" + str(args.name)
        else:
            if len(filter_qs) > 0:  filter_qs += "&" + "name=" + str(args.name)
            else:                   filter_qs += "?" + "name=" + str(args.name)
    

    r,c = vim_read(url + filter_qs)
    if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
        r,c = vim_read(url_admin + filter_qs)
    if r<0:           
        print "Error:", c
        return -r
    if args.action=='createImage':
        payload={ args.action: {"name":args.imageName} }
        if args.description != None:
            payload[args.action]["description"]=args.description
        if args.path != None:
            payload[args.action]["path"]=args.path
    else:
        payload={ args.action: None}
    #print json.dumps(c, indent=4)
    item_list = c[ args.element ]
    if len(item_list)==0 and args.name != None:
        print  " Not found " + args.element + " " + args.name
        return 404 #HTTP_Not_Found
    result = 0
    for item in item_list:
        uuid=item.get('id', None)
        if uuid is None:
            uuid=item.get('uuid', None)
        if uuid is None:
            print "Id not found"
            continue
        name = item.get('name', '')
        if not args.force:
            r = raw_input(" Action over " + args.element + " " + uuid + " " + name + " (y/N)? ")
            if  len(r)>0  and r[0].lower()=="y":
                pass
            else:
                continue
        r,c = vim_action(url + "/" + uuid + "/action", payload)
        if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
            url=url_admin
            r,c = vim_action(url + "/" + uuid + "/action", payload)
        if r<0:
            print " " + uuid +"   "+ name.ljust(20) + "   " + c
            result = -r
        else:
            if args.action == "createImage":  #response contain an {image: {...} }, not a {server: {...} }.
                print " " + c["image"]["id"] +"   "+ c["image"]["name"].ljust(20)
                args.element="images"
            else:
                print " " + uuid             +"   "+ name.ljust(20) + "   "+ args.action
            if "verbose" in args and args.verbose!=None:
                _print_verbose(c, args.element[:-1], args.verbose)
    return result

def element_edit(args):
    filter_qs = ""
    tenant=""
    if args.element in ('flavors','images','servers'):
        check_configuration( "ADMIN_PORT")
        tenant="/"+vim_config["TENANT"]
    else:
        check_configuration("ADMIN_PORT", "TENANT")
        tenant=""

    url = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["PORT"], tenant, args.element)
    if "ADMIN_PORT" in vim_config and vim_config["ADMIN_PORT"]!=None:
        url_admin = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["ADMIN_PORT"], tenant, args.element)
    else:
        url_admin = None
    
    if args.filter:
        filter_qs += "?" + args.filter
    if args.name!=None:
        if check_valid_uuid(args.name):
            if len(filter_qs) > 0:  filter_qs += "&" + "id=" + str(args.name)
            else:                   filter_qs += "?" + "id=" + str(args.name)
        else:
            if len(filter_qs) > 0:  filter_qs += "&" + "name=" + str(args.name)
            else:                   filter_qs += "?" + "name=" + str(args.name)
    

    r,c = vim_read(url + filter_qs)
    if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
        r,c = vim_read(url_admin + filter_qs)
    if r<0:           
        print "Error:", c
        return -r

    payload=load_file_or_yaml(args.file)
    r2,c2= change_var(payload)
    if r2<0:
        print "Template error", c2
        return -1
    payload=c2
    if args.element[:-1] not in payload:
        payload = {args.element[:-1]: payload }

    #print json.dumps(c, indent=4)
    item_list = c[ args.element ]
    if len(item_list)==0 and args.name != None:
        print  " Not found " + args.element + " " + args.name
        return 404 #HTTP_Not_Found
    result = 0
    for item in item_list:
        uuid=item.get('id', None)
        if uuid is None:
            uuid=item.get('uuid', None)
        if uuid is None:
            print "Id not found"
            continue
        name = item.get('name', '')
        if not args.force or (args.name==None and args.filer==None):
            r = raw_input(" Edit " + args.element + " " + uuid + " " + name + " (y/N)? ")
            if  len(r)>0  and r[0].lower()=="y":
                pass
            else:
                continue
        r,c = vim_edit(url + "/" + uuid, payload)
        if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
            url=url_admin
            r,c = vim_edit(url + "/" + uuid, payload)
        if r<0:
            print " " + uuid +"   "+ name.ljust(20) + " " + c
            result = -r
        else:
            print " " + uuid +"   "+ name.ljust(20) + " edited"
            if "verbose" in args and args.verbose!=None:
                _print_verbose(c, args.element[:-1], args.verbose)
    return result

def element_action_edit(args):
    #print args
    if args.element=='ports':
        if args.action=='attach':
            args.file='network_id: ' + args.network_id
        else: #args.action=='detach'
            args.file='network_id: null'
    if args.action=='up':
        args.file='admin_state_up: true'
    if args.action=='down':
        args.file='admin_state_up: false'
    return element_edit(args)
    
def element_delete(args):
    filter_qs = ""
    tenant=""
    if args.element in ('flavors','images','servers'):
        check_configuration("ADMIN_PORT" )
        tenant="/"+vim_config["TENANT"]
    else:
        check_configuration("ADMIN_PORT", "TENANT")
        tenant=""

    url = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["PORT"], tenant, args.element)
    if "ADMIN_PORT" in vim_config and vim_config["ADMIN_PORT"]!=None:
        url_admin = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["ADMIN_PORT"], tenant, args.element)
    else:
        url_admin = None

    if args.filter:
        filter_qs += "?" + args.filter
    if args.name!=None:
        if check_valid_uuid(args.name):
            if len(filter_qs) > 0:  filter_qs += "&" + "id=" + str(args.name)
            else:                   filter_qs += "?" + "id=" + str(args.name)
        else:
            if len(filter_qs) > 0:  filter_qs += "&" + "name=" + str(args.name)
            else:                   filter_qs += "?" + "name=" + str(args.name)
    

    r,c = vim_read(url + filter_qs)
    if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
        r,c = vim_read(url_admin + filter_qs)
    if r<0:           
        print "Error:", c
        return -r

    #print json.dumps(c, indent=4)
    item_list = c[ args.element ]
    if len(item_list)==0 and args.name != None:
        print  " Not found " + args.element + " " + args.name
        return 404 #HTTP_Not_Found
    result = 0
    for item in item_list:
        uuid=item.get('id', None)
        if uuid is None:
            uuid=item.get('uuid', None)
        if uuid is None:
            print "Id not found"
            result = -500
            continue
        name = item.get('name', '')
        if not args.force:
            r = raw_input(" Delete " + args.element + " " + uuid + " " + name + " (y/N)? ")
            if  len(r)>0  and r[0].lower()=="y":
                pass
            else:
                continue
        r,c = vim_delete(url + "/" + uuid)
        if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
            url=url_admin
            r,c = vim_delete(url + "/" + uuid)
        if r<0:
            print " " + uuid +"   "+ name.ljust(20) + " " + c
            result = -r
        else:
            print " " + uuid +"   "+ name.ljust(20) + " deleted"
    return result

def element_list(args):
    #print "element_list", args
    filter_qs = ""
    tenant=""
    if args.element in ('flavors','images','servers'):
        check_configuration( "ADMIN_PORT" )
        tenant="/"+vim_config["TENANT"]
    else:
        check_configuration( "ADMIN_PORT", "TENANT" )
        tenant=""
    #if args.name:
    #    what += "/" + args.name
    url = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["PORT"], tenant, args.element)
    if "ADMIN_PORT" in vim_config and vim_config["ADMIN_PORT"]!=None:
        url_admin = "http://%s:%s/openvim%s/%s" %(vim_config["HOST"], vim_config["ADMIN_PORT"], tenant, args.element)
    else:
        url_admin = None
    #print " get", what, "     >>>>>>>> ",
    if args.filter:
        filter_qs += "?" + args.filter
    if args.name!=None:
        if check_valid_uuid(args.name):
            if len(filter_qs) > 0:  filter_qs += "&" + "id=" + str(args.name)
            else:                   filter_qs += "?" + "id=" + str(args.name)
        else:
            if len(filter_qs) > 0:  filter_qs += "&" + "name=" + str(args.name)
            else:                   filter_qs += "?" + "name=" + str(args.name)
    

    r,c = vim_read(url + filter_qs)
    if r==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
        r,c = vim_read(url_admin + filter_qs)
    if r<0:           
        print "Error:", c
        return -r
    #print json.dumps(c, indent=4)
    result = 0
    item_list = c[ args.element ]
    verbose=0
    #if args.name!=None and len(item_list)==1:
    #    verbose+=1
    if args.verbose!=None:
        verbose += args.verbose
    for item in item_list:
        extra=""
        if args.element=="servers" or args.element=="networks": extra = " "+item['status']
        if args.element in ("hosts","networks","ports") and not item['admin_state_up']: extra += " admin_state_up=false"
        print item['id']+"   "+item['name'].ljust(20) + extra
        if verbose>0:
            r2,c2 = vim_read(url + "/"+ item['id'])
            if r2==-401 and url_admin!=None and url != url_admin: #Unauthorized, try with admin privileges
                url=url_admin
                r2,c2 = vim_read(url + "/"+ item['id'])
            if r2>0:
                _print_verbose(c2, args.element[:-1], verbose)

    return result

def openflow_action(args):
    if args.action=='port-list':
        url = "http://%s:%s/openvim/networks/openflow/ports" %(vim_config["HOST"], vim_config["PORT"])
        r,c = vim_read(url)
    elif args.action == 'port-mapping':
        url = "http://%s:%s/openvim/openflow/mapping" % (vim_config["HOST"], vim_config["PORT"])
        r, c = vim_read(url)
    elif args.action=='rules-list' or args.action=='reinstall':
        PORT = vim_config["PORT"]
        if args.action=='reinstall':
            if "ADMIN_PORT" not in vim_config:
                print "OPENVIM_ADMIN_PORT variable not defined"
                return 404 #HTTP_Not_Found
            PORT = vim_config["ADMIN_PORT"]
        if args.name!=None:
            url = "http://%s:%s/openvim/networks" %(vim_config["HOST"], PORT)
            if check_valid_uuid(args.name):
                url += "?id=" + str(args.name)
            else:
                url += "?name=" + str(args.name)
            r,c = vim_read(url)
            if r<0:           
                print "Error:", c
                return -r
            if len (c["networks"]) == 0:
                print "  Network not found"
                return 404 #HTTP_Not_Found
            if len (c["networks"]) > 1:
                print "  More than one net with this name found. Use uuid instead of name to concretize"
                return 404 #HTTP_Not_Found
            network = c["networks"][0]["id"]
        else:
            network="all"
        url = "http://%s:%s/openvim/networks/%s/openflow" %(vim_config["HOST"], PORT, network)
        if args.action=='reinstall':
            r,c = vim_edit(url, None)
        else:
            r,c = vim_read(url)
    elif args.action=='clear-all':
        if "ADMIN_PORT" not in vim_config:
            print "OPENVIM_ADMIN_PORT variable not defined"
            return 401 # HTTP_Unauthorized
        url = "http://%s:%s/openvim/networks/clear/openflow" %(vim_config["HOST"], vim_config["ADMIN_PORT"])
        r,c = vim_delete(url)
    else:
        return 400 #HTTP_Bad_Request
    if r<0:           
        print "Error:", c
        return -r
    else:
        print yaml.safe_dump(c, indent=4, default_flow_style=False)
        return 0

if __name__=="__main__":
    
    item_dict={'vm':'servers','host':'hosts','tenant':'tenants','image':'images','flavor':'flavors','net':'networks','port':'ports'}
    
    vim_config={}
    vim_config["HOST"] =       os.getenv('OPENVIM_HOST', 'localhost')
    vim_config["PORT"] =       os.getenv('OPENVIM_PORT', '9080')
    vim_config["ADMIN_PORT"] = os.getenv('OPENVIM_ADMIN_PORT', '9085')
    vim_config["TENANT"] =     os.getenv('OPENVIM_TENANT', None)
    
   
    main_parser = ThrowingArgumentParser(description='User program to interact with OPENVIM-SERVER (openvimd)')
    #main_parser = argparse.ArgumentParser(description='User program to interact with OPENVIM-SERVER (openvimd)')
    main_parser.add_argument('--version', action='version', version='%(prog)s ' + __version__ + ' '+version_date)
    
    subparsers = main_parser.add_subparsers(help='commands')
    
    config_parser = subparsers.add_parser('config', help="prints configuration values")
    config_parser.add_argument("file", nargs='?', help="configuration file to extract the configuration").completer = FilesCompleter
    config_parser.set_defaults(func=config)
    #HELP
    for item in item_dict:
        #LIST
        element_list_parser = subparsers.add_parser(item+'-list', help="lists information about "+item_dict[item])
        element_list_parser.add_argument("name", nargs='?', help="name or ID of the " + item)
        element_list_parser.add_argument("-F","--filter", action="store", help="filter query string")
        element_list_parser.add_argument('--verbose', '-v', action='count', help="increment the verbosity")
        element_list_parser.set_defaults(func=element_list, element=item_dict[item])
        #NEW
        if item=='host':
            element_new_parser = subparsers.add_parser(item+'-add', help="adds a new compute node")
        else:
            element_new_parser = subparsers.add_parser(item+'-create', help="creates a new "+item_dict[item][:-1])
        element_new_parser.add_argument("file", nargs='?', help="json/yaml text or file with content").completer = FilesCompleter
        element_new_parser.add_argument("--name", action="store", help="Use this name")
        if item!="network":
            element_new_parser.add_argument("--description", action="store", help="Use this descrition")
        if item=="image":
            element_new_parser.add_argument("--path", action="store", help="Use this path")
        element_new_parser.add_argument('--verbose', '-v', action='count', help="increment the verbosity")
        element_new_parser.set_defaults(func=element_new, element=item_dict[item])
        #DELETE
        if item=='host':
            element_del_parser = subparsers.add_parser(item+'-remove', help="removes a compute node")
        else:
            element_del_parser = subparsers.add_parser(item+'-delete', help="deletes one or several "+item_dict[item])
        element_del_parser.add_argument("name", nargs='?', help="name or ID of the "+item+", if missing means all")
        element_del_parser.add_argument("-F","--filter", action="store", help="filter query string")
        element_del_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
        element_del_parser.set_defaults(func=element_delete, element=item_dict[item])
        #EDIT
        element_edit_parser = subparsers.add_parser(item+'-edit', help="edits one or several "+item_dict[item])
        element_edit_parser.add_argument("name", help="name or ID of the "+item+"")
        element_edit_parser.add_argument("file", help="json/yaml text or file with the changes").completer = FilesCompleter
        element_edit_parser.add_argument("-F","--filter", action="store", help="filter query string")
        element_edit_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
        element_edit_parser.add_argument('--verbose', '-v', action='count', help="increment the verbosity")
        element_edit_parser.set_defaults(func=element_edit, element=item_dict[item])
        #ACTION
        if item=='vm':
            for item2 in ('shutdown', 'start', 'rebuild', 'reboot'):
                vm_action_parser = subparsers.add_parser("vm-"+item2, help="performs this action over the virtual machine")
                vm_action_parser.add_argument("name", nargs='?', help="name or ID of the server, if missing means all")
                vm_action_parser.add_argument("-F","--filter", action="store", help="filter query string")
                vm_action_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
                vm_action_parser.set_defaults(func=element_action, element="servers", action=item2 )
            vm_action_image_parser = subparsers.add_parser("vm-createImage", help="creates a snapshot of the virtual machine disk into a new image")
            vm_action_image_parser.add_argument("name", help="name or ID of the server")
            vm_action_image_parser.add_argument("imageName", help="image name")
            vm_action_image_parser.add_argument("--description", action="store", help="Provide a new image description")
            vm_action_image_parser.add_argument("--path", action="store", help="Provide a new image complete path")
            vm_action_image_parser.add_argument("-F","--filter", action="store", help="filter query string")
            vm_action_image_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
            vm_action_image_parser.add_argument('--verbose', '-v', action='count', help="increment the verbosity")
            vm_action_image_parser.set_defaults(func=element_action, element="servers", action="createImage" )
        #ACTION that are implemented with EDITION
        if item=='port':
            port_action_attach_parser = subparsers.add_parser("port-attach", help="connects a port to a network")
            port_action_attach_parser.add_argument("name", help="name or ID of the port")
            port_action_attach_parser.add_argument("network_id", help="ID of the network")
            port_action_attach_parser.add_argument("-F","--filter", action="store", help="filter query string")
            port_action_attach_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
            port_action_attach_parser.set_defaults(func=element_action_edit, element="ports", action="attach")

            port_action_detach_parser = subparsers.add_parser("port-detach", help="removes a port from a network")
            port_action_detach_parser.add_argument("name", help="name or ID of the port")
            port_action_detach_parser.add_argument("-F","--filter", action="store", help="filter query string")
            port_action_detach_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
            port_action_detach_parser.set_defaults(func=element_action_edit, element="ports", action="dettach")

        if item=='net' or item=='host':
            nethost_action_up_parser = subparsers.add_parser(item+"-up", help="puts admin_state_up of "+item_dict[item][:-1]+" to true")
            nethost_action_up_parser.add_argument("name", help="name or ID of the "+item_dict[item][:-1])
            nethost_action_up_parser.add_argument("-F","--filter", action="store", help="filter query string")
            nethost_action_up_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
            nethost_action_up_parser.set_defaults(func=element_action_edit, element=item_dict[item], action="up")
        
            nethost_action_down_parser = subparsers.add_parser(item+"-down", help="puts admin_state_up of "+item_dict[item][:-1]+" to false")
            nethost_action_down_parser.add_argument("name", help="name or ID of the "+item_dict[item][:-1])
            nethost_action_down_parser.add_argument("-F","--filter", action="store", help="filter query string")
            nethost_action_down_parser.add_argument("-f","--force", action="store_true", help="do not prompt for confirmation")
            nethost_action_down_parser.set_defaults(func=element_action_edit, element=item_dict[item], action="down")

    #openflow rules
    openflow_list_action = subparsers.add_parser("openflow-port-list", help="list openflow switch ports name")
    openflow_list_action.set_defaults(func=openflow_action, action="port-list")

    openflow_list_action = subparsers.add_parser("openflow-port-mapping-list", help="list computes port mapping")
    openflow_list_action.set_defaults(func=openflow_action, action="port-mapping")
    
    openflow_list_action = subparsers.add_parser("openflow-clear-all", help="removes all openflow rules")
    openflow_list_action.set_defaults(func=openflow_action, action="clear-all")

    openflow_list_action = subparsers.add_parser("openflow-net-reinstall", help="reinstall the openflow rules for a network")
    openflow_list_action.add_argument("name", nargs='?', help="network name, if missing all networks")
    openflow_list_action.set_defaults(func=openflow_action, action="reinstall")
    
    openflow_list_action = subparsers.add_parser("openflow-net-list", help="list installed openflow rules for a network")
    openflow_list_action.add_argument("name", nargs='?', help="network name, if missing all networks")
    openflow_list_action.set_defaults(func=openflow_action, action="rules-list")

    argcomplete.autocomplete(main_parser)
    
    try:
        args = main_parser.parse_args()
        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 OPENVIM-SERVER (openvimd)"
        result = -2
    except (KeyboardInterrupt):
        print 'Exiting openVIM'
        result = -3
    except (SystemExit, ArgumentParserError):
        result = -4
    
    #print result
    exit(result)