},
        }
    },
}


def controller_completion_add_localhost(completions, prefix):
    if completions == None:
        completions = {}
    if not 'localhost ' in completions and 'localhost'.startswith(prefix):
        completions['localhost '] = 'Select currently logged in controller'


command.add_completion(
    'controller-add-localhost', controller_completion_add_localhost,
    {'kwargs': {
        'completions': '$completions',
        'prefix': '$text',
    }})

CONTROLLER_NODE_SHOW_ID_COMMAND_DESCRIPTION = {
    'name':
    'show',
    'obj-type':
    'controller-node',
    'mode':
    'login',
    'short-help':
    'Show controller-node associated details by name',
    'no-supported':
    False,
    'action':
def init_completions(bs):
    global bigsh
    bigsh = bs

    command.add_completion('complete-object-field', complete_object_field,
                           {'kwargs': {'path'         : '$path',
                                       'parent_field' : '$parent-field',
                                       'parent_id'    : '$current-mode-obj-id',
                                       'field'        : '$field',
                                       'prefix'       : '$text',
                                       'data'         : '$data',
                                       'scoped'       : '$scoped',
                                       'other'        : '$other',
                                       'mode'         : '$mode',
                                       'no_command'   : True, # add current
                                       'completions'  : '$completions'}})

    command.add_completion('complete-config-field', complete_object_field,
                           {'kwargs': {'path'         : '$path',
                                       'parent_field' : '$parent-field',
                                       'parent_id'    : '$current-mode-obj-id',
                                       'field'        : '$field',
                                       'prefix'       : '$text',
                                       'data'         : '$data',
                                       'scoped'       : '$scoped',
                                       'other'        : '$other',
                                       'mode'         : '$mode',
                                       'no_command'   : '$is-no-command',
                                       'completions'  : '$completions'}})

    command.add_completion('complete-from-another', complete_from_another,
                           {'kwargs': {'other_path'   : '$other-path',
                                       'path'         : '$path',
                                       'parent_field' : '$parent-field',
                                       'parent_id'    : '$current-mode-obj-id',
                                       'field'        : '$field',
                                       'prefix'       : '$text',
                                       'data'         : '$data',
                                       'scoped'       : '$scoped',
                                       'completions'  : '$completions',
                                       'no_command'   : '$is-no-command',
                                       'explicit'     : '$explicit',
                                       'mode_switch'  : '$mode-switch-clue',
                                       }})

    command.add_completion('complete-alias-choice', complete_alias_choice,
                           {'kwargs': {'path'        : '$path',
                                       'field'       : '$field',
                                       'other'       : '$other',
                                       'other_path'  : '$other-path',
                                       'prefix'      : '$text',
                                       'data'        : '$data',
                                       'scoped'      : '$scoped',
                                       'completions' : '$completions',
                                       'no_command'  : '$is-no-command', }})

    command.add_completion('complete-config', complete_config,
                           {'kwargs': {'prefix'      : '$text',
                                       'data'        : '$data',
                                       'completions' : '$completions'}})

    command.add_completion('complete-config-file', complete_config_file,
                           {'kwargs': {'prefix'      : '$text',
                                       'data'        : '$data',
                                       'completions' : '$completions'}})

    command.add_completion('complete-config-copy', complete_config,
                           {'kwargs': {'prefix'      : '$text',
                                       'data'        : '$data',
                                       'completions' : '$completions',
                                       'copy'        : True }})

    command.add_completion('complete-interface-list', complete_interface_list,
                           {'kwargs': {'prefix'      : '$text',
                                       'data'        : '$data',
                                       'completions' : '$completions'}})

    command.add_completion('complete-staticflow-actions', complete_staticflow_actions,
                           {'kwargs': {'prefix'        : '$text',
                                       'data'        : '$data',
                                       'completions' : '$completions'}})

    command.add_completion('complete-integer-comma-ranges', complete_integer_comma_ranges,
                           {'kwargs': {'path'        : '$path',
                                       'field'       : '$field',
                                       'scoped'      : '$scoped',
                                       'field_range' : '$range',
                                       'prefix'      : '$text',
                                       'data'        : '$data',
                                       'no_command'  : '$is-no-command',
                                       'completions' : '$completions'}})
                        
    command.add_completion('description-versions', complete_description_versions,
                           {'kwargs': {'prefix'      : '$text',
                                       'completions' : '$completions'}})

    command.add_completion('complete-log-names', complete_log_names,
                           {'kwargs': {'prefix'     : '$text',
                                       'data'       : '$data',
                                       'completions': '$completions'}})
# Licensed under the Eclipse Public License, Version 1.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.eclipse.org/legal/epl-v10.html
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing
# permissions and limitations under the License.
#

import command
import fmtcnv
"""
CONTROLLER_NODE_FORMAT = {
    'controller-node' : {
        'field-orderings' : {
            'default'       : [
                             'Idx',
                             'alias',
                             'me',
                             'ha-role',
                             'change-date-time',
                             'change-description',
                             'status',
                             'uptime',
                             'errors'
                             #'domain-lookups-enabled',
                             #'logging-enabled',
Ejemplo n.º 4
0
            'localTunnelIPAddr' : {
                                    'verbose-name' : 'Local tunnel IP',
                                  },
            'tunnelPorts' :       {
                                     'verbose-name' : 'Remote tunnel IP',
                                  },
        },
    },
}
"""

def group_id_completion(prefix, data, completions):
    dpid = data.get('dpid')
    #print dpid
    query_url = "http://127.0.0.1:8000/rest/v1/realtimestats/group/%s/" %(dpid)
    result = command.sdnsh.store.rest_simple_request(query_url)
    entries = json.loads(result)
    entries = entries[dpid]
    #print "result", entries
    for entry in entries:
        #print entry['groupId']
        if str(entry['groupId']).startswith(prefix):
            completions[str(entry['groupId'])+' '] = entry['groupId']
    return

command.add_completion('group-id-completion', group_id_completion,
                       {'kwargs': { 'prefix'       : '$text',
                                    'data'         : '$data',
                                    'completions'  : '$completions',
                                    }})
    if 'dst-tenant' in data:
        data['tenant']=data['dst-tenant']

def complete_virtualrouter_postprocess(data,completions):
    obj_id = command.sdnsh.get_current_mode_obj()
    parts=obj_id.split('|')
    tenant=parts[0]
    if tenant !='system': #non-system virtual router can only connected to system virtual router
        completions.clear()
        completions['system ']='Tenant Selection'
    else: # system virtual router can't connect to itself
        if 'system ' in completions:
            del completions['system ']

command.add_completion('complete-virtualrouter-postprocess', complete_virtualrouter_postprocess,
                           {'kwargs': {'data': '$data',
                                       'completions'  : '$completions',}})
command.add_completion('complete-virtualrouter-preprocess', complete_virtualrouter_preprocess,
                           {'kwargs': {'data': '$data',
                                       }})

def virtualrouter_confirm_external_delete(data):
    """
    From the named virtualrouter, look up the entry, if it exists in the
    database, validate the 'origin' is either null, or 'cli',
    otherwise provide a warning about this particular virtualrouter
    (along with the originator name)
    """
    external_origin = virtualrouter_origin_external(data)
    if external_origin:
        confirm = command.action_registry['confirm'][0] # XXX accessor?
Ejemplo n.º 6
0
            'format' : 'show_policy',
        },
    )
}

def tunnel_id_completion(prefix, completions):
    query_url = "http://127.0.0.1:8000/rest/v1/showtunnel"
    result = command.sdnsh.store.rest_simple_request(query_url)
    entries = json.loads(result)
    for entry in entries:
        if entry['tunnelId'].startswith(prefix):
            completions[entry['tunnelId']+' '] = entry['tunnelId']
    return

command.add_completion('tunnel-id-completion', tunnel_id_completion,
                       {'kwargs': { 'prefix'       : '$text',
                                    'completions'  : '$completions',
                                    }})

def tunnelset_id_completion(prefix, completions):
    query_url = "http://127.0.0.1:8000/rest/v1/showtunnelset"
    result = command.sdnsh.store.rest_simple_request(query_url)
    entries = json.loads(result)
    for entry in entries:
        if entry['tunnelsetId'].startswith(prefix):
            completions[entry['tunnelsetId']+' '] = entry['tunnelsetId']
    return

command.add_completion('tunnelset-id-completion', tunnelset_id_completion,
                       {'kwargs': { 'prefix'       : '$text',
                                    'completions'  : '$completions',
                                    }})
Ejemplo n.º 7
0
def init_completions(bs, modi):
    global sdnsh, mi
    sdnsh = bs
    mi = modi

    command.add_completion(
        "complete-object-field",
        complete_object_field,
        {
            "kwargs": {
                "obj_type": "$obj-type",
                "parent_field": "$parent-field",
                "parent_id": "$current-mode-obj-id",
                "field": "$field",
                "prefix": "$text",
                "data": "$data",
                "scoped": "$scoped",
                "other": "$other",
                "mode": "$mode",
                "completions": "$completions",
            }
        },
    )

    command.add_completion(
        "complete-tag-mapping",
        complete_tag_mapping,
        {
            "kwargs": {
                "obj_type": "$obj-type",
                "parent_field": "$parent-field",
                "parent_id": "$current-mode-obj-id",
                "field": "$field",
                "prefix": "$text",
                "data": "$data",
                "scoped": "$scoped",
                "other": "$other",
                "mode": "$mode",
                "completions": "$completions",
            }
        },
    )

    command.add_completion(
        "complete-from-another",
        complete_from_another,
        {
            "kwargs": {
                "other": "$other",
                "obj_type": "$obj-type",
                "parent_field": "$parent-field",
                "parent_id": "$current-mode-obj-id",
                "field": "$field",
                "prefix": "$text",
                "data": "$data",
                "scoped": "$scoped",
                "completions": "$completions",
                "no_command": "$is-no-command",
                "explicit": "$explicit",
            }
        },
    )

    command.add_completion(
        "complete-alias-choice",
        complete_alias_choice,
        {
            "kwargs": {
                "obj_type": "$obj-type",
                "field": "$field",
                "other": "$other",
                "prefix": "$text",
                "data": "$data",
                "scoped": "$scoped",
                "completions": "$completions",
                "no_command": "$is-no-command",
            }
        },
    )

    command.add_completion(
        "complete-config",
        complete_config,
        {"kwargs": {"prefix": "$text", "data": "$data", "completions": "$completions"}},
    )

    command.add_completion(
        "complete-config-copy",
        complete_config,
        {"kwargs": {"prefix": "$text", "data": "$data", "completions": "$completions", "copy": True}},
    )

    command.add_completion(
        "complete-interface-list",
        complete_interface_list,
        {"kwargs": {"prefix": "$text", "data": "$data", "completions": "$completions"}},
    )

    command.add_completion(
        "complete-staticflow-actions",
        complete_staticflow_actions,
        {"kwargs": {"prefix": "$text", "data": "$data", "completions": "$completions"}},
    )

    command.add_completion(
        "description-versions",
        complete_description_versions,
        {"kwargs": {"prefix": "$text", "completions": "$completions"}},
    )

    command.add_completion(
        "complete-log-names",
        complete_log_names,
        {"kwargs": {"prefix": "$text", "data": "$data", "completions": "$completions"}},
    )
                             'verbose-name' : 'Firewall Rule'
                           },
            }
       },
}


def controller_completion_add_localhost(completions, prefix):
    if completions == None:
        completions = {}
    if not 'localhost ' in completions and 'localhost'.startswith(prefix) :
        completions['localhost '] = 'Select currently logged in controller'


command.add_completion('controller-add-localhost', controller_completion_add_localhost,
                      {'kwargs': { 'completions' : '$completions',
                                   'prefix'      : '$text',
                      }})


CONTROLLER_NODE_SHOW_ID_COMMAND_DESCRIPTION = {
    'name'         : 'show',
    'obj-type'     : 'controller-node',
    'mode'         : 'login',
    'short-help'   : 'Show controller-node associated details by name',
    'no-supported' : False,
    'action'       : controller_node_show_actions,
    'doc'          : 'controller|show-details',
    'args'         : (
        'controller-node',
        {
            'choices' : (
def init_completions(bs, modi):
    global sdnsh, mi
    sdnsh = bs
    mi = modi

    command.add_completion(
        'complete-object-field', complete_object_field, {
            'kwargs': {
                'obj_type': '$obj-type',
                'parent_field': '$parent-field',
                'parent_id': '$current-mode-obj-id',
                'field': '$field',
                'prefix': '$text',
                'data': '$data',
                'scoped': '$scoped',
                'other': '$other',
                'mode': '$mode',
                'completions': '$completions'
            }
        })

    command.add_completion(
        'complete-tag-mapping', complete_tag_mapping, {
            'kwargs': {
                'obj_type': '$obj-type',
                'parent_field': '$parent-field',
                'parent_id': '$current-mode-obj-id',
                'field': '$field',
                'prefix': '$text',
                'data': '$data',
                'scoped': '$scoped',
                'other': '$other',
                'mode': '$mode',
                'completions': '$completions'
            }
        })

    command.add_completion(
        'complete-from-another', complete_from_another, {
            'kwargs': {
                'other': '$other',
                'obj_type': '$obj-type',
                'parent_field': '$parent-field',
                'parent_id': '$current-mode-obj-id',
                'field': '$field',
                'prefix': '$text',
                'data': '$data',
                'scoped': '$scoped',
                'completions': '$completions',
                'no_command': '$is-no-command',
                'explicit': '$explicit',
            }
        })

    command.add_completion(
        'complete-alias-choice', complete_alias_choice, {
            'kwargs': {
                'obj_type': '$obj-type',
                'field': '$field',
                'other': '$other',
                'prefix': '$text',
                'data': '$data',
                'scoped': '$scoped',
                'completions': '$completions',
                'no_command': '$is-no-command',
            }
        })

    command.add_completion(
        'complete-config', complete_config, {
            'kwargs': {
                'prefix': '$text',
                'data': '$data',
                'completions': '$completions'
            }
        })

    command.add_completion(
        'complete-config-copy', complete_config, {
            'kwargs': {
                'prefix': '$text',
                'data': '$data',
                'completions': '$completions',
                'copy': True
            }
        })

    command.add_completion(
        'complete-interface-list', complete_interface_list, {
            'kwargs': {
                'prefix': '$text',
                'data': '$data',
                'completions': '$completions'
            }
        })

    command.add_completion(
        'complete-staticflow-actions', complete_staticflow_actions, {
            'kwargs': {
                'prefix': '$text',
                'data': '$data',
                'completions': '$completions'
            }
        })

    command.add_completion(
        'description-versions', complete_description_versions,
        {'kwargs': {
            'prefix': '$text',
            'completions': '$completions'
        }})

    command.add_completion(
        'complete-log-names', complete_log_names, {
            'kwargs': {
                'prefix': '$text',
                'data': '$data',
                'completions': '$completions'
            }
        })
Ejemplo n.º 10
0
        if (obj_type!='virtualrouter-gwpool'):
            data['virtual-router-gwpool']=data['tenant'] +'|'+data['vrname'] +'|' + data['vrgwname']

command.add_action('tenant-show-preprocess', tenant_show_preprocess,
                    {'kwargs': {'obj_type': '$obj-type',
                                'data'    : '$data',
                                'scoped'  : '$scoped',}})
command.add_action('tenant-warn-external-config', tenant_warn_external_config,
                    {'kwargs': {'data'      : '$data',}})

def complete_tenant_preprocess(data):
    if 'name' in data:
        data['tenant'] =data['name']

command.add_completion('complete-tenant-preprocess', complete_tenant_preprocess,
                           {'kwargs': {'data': '$data',
                                       }})
#
# ----------------------------------------------------------------------
# tenant submode commands
#
TENANT_COMMAND_DESCRIPTION = {
    'name'         : 'tenant',
    'help'         : 'Enter tenant definition submode',
    'mode'         : 'config*',
    'command-type' : 'config-submode',
    'obj-type'     : 'tenant',
    'parent-field' : None,
    'current-mode-obj-id' : None,
    'submode-name' : 'config-tenant',
    'feature'      : 'vns',