cli/desc/version200/address_space_run_config.py - spring-open-cli - Gitiles

 #
 # Copyright (c) 2012,2013 Big Switch Networks, Inc.
 #
 # 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.
 #

 #  address_space_run_config.py
 #
 # show running address-space [as]
 #

 import run_config
 import command
 import fmtcnv
 import utif
 import sys
 from midw import *

 def address_space_running_config_include_field(context, config,
         address_space, obj_type, field, value, indent, prefix = ""):
     """
     Identify fields of obj_types who's values differ from the default
     values, since these need to be included into the running-config
     """
     if context.mi.not_default_value(obj_type, field, value):
         if context.mi.is_field_string(obj_type, field):
             config.append(' ' * (indent + indent) + prefix + field +
                           " %s\n" % utif.quote_string(value))
         else:
             config.append(' ' * (indent + indent) + prefix + field +
                           ' %s\n' % value)

 #
 # address_space_running_config_details
 #
 # Show an address-space configuration in detail
 #
 def address_space_running_config_details (context, config, address_space):
     """
     Display the details for the fields of a address_space which may have
     non-default values.
     """

     #
     # 'active' is True by default. Prepend 'no' into the generated config
     # if this item is not active.
     #
     if address_space['active'] != \
         context.mi.field_default_value('address-space', 'active'):
         config.append('  no active\n')

     #
     # Show the rest of the fields
     #
     address_space_fields = ['description', 'origin', 'priority',
                             'vlan-tag-on-egress']

     for field in sorted(address_space_fields):
         address_space_running_config_include_field(context, config,
             address_space, 'address-space', field,
             address_space.get(field,''), 1)

 #
 # address_space_running_config_id_rule
 #
 # Generate indentifier-rule under address-space configuration
 #
 def address_space_running_config_id_rule (context, config, address_space,
                                           address_space_id_rule_entries):

     #
     # Iterate through each identifier-rule and show its contents
     #
     for rule in address_space_id_rule_entries:

         #
         # Show the rule header line
         #
         config.append('  identifier-rule %s\n' % rule['rule'])

         #
         # Iterate through each field configurable and generate the config
         # if present.
         #
         for field in ['description', 'active', 'priority']:
             address_space_running_config_include_field(context, config,
                 address_space, 'address-space-identifier-rule', field,
                 rule.get(field, ''), 2)

         for field in ['vlans', 'tag']:
             address_space_running_config_include_field(context, config,
                 address_space, 'address-space-identifier-rule', field,
                 rule.get(field, ''), 2, "match ")

         #
         # Manage switch and ports differently, placing both on the
         # same line when ports exist, and replacing the switch alias
         # when its available.
         if 'switch' in rule:
             dpid_or_alias = alias_lookup_with_foreign_key('switch-alias',
                                                           rule['switch'])
             if dpid_or_alias == None:
                 dpid_or_alias = rule['switch'] # dpid
             if 'ports' in rule:
                 config.append('    match switch %s %s\n' % \
                               (dpid_or_alias, rule['ports']))
             else:
                 config.append('    match switch %s\n' % dpid_or_alias)

         #
         # This configuration section complete, print the trailer.
         #


 #
 # running_config_specific_address_space
 #
 # Show running configuration of one particular address-space
 #
 def running_config_specific_address_space (context, config, address_space_name):

     #
     # Have a temporary holder to store generated configuration.
     #
     tmp_config = [ ]

     #
     # Retrieve the configuration from the data store. Catch all possible
     # exceptions and report back as appropriate.
     #
     try:
         address_space = context.get_object_from_store(
                             'address-space', address_space_name)
     except:

         #
         # This particular address-space is not available in the
         # data base. Report error back.
         #
         return ('Error: no address-space name %s, Error %s' %  \
                (address_space_name, sys.exc_info()[0]))

     #
     # Show the configured sub items under this address-space.
     #
     address_space_running_config_details(context, tmp_config, address_space)

     #
     # Retrieve all the identifier rules configured. There may not be any
     # rule present. Handle it gracefully.
     #
     address_space_rules = None
     try:
         address_space_rules = context.get_table_from_store(
                                   'address-space-identifier-rule',
                                   'address-space',
                                   address_space_name, "exact")
     except Exception:
         pass

     #
     # Show each rule configured in detail
     #
     if address_space_rules:
         address_space_running_config_id_rule(context, tmp_config, address_space,
                                              address_space_rules)

     #
     # Don't shown empty configuration for default address-space.
     #
     if len(tmp_config) > 0 or address_space['name'] != 'default':
         config.append("address-space %s\n" % address_space_name)
         config += tmp_config

 #
 # running_config_address_space
 #
 # Show running configuration for 'all' address-space configured
 #
 def running_config_address_space (context, config, words):
     """
     Add the Address Space configuration detils
     """

     #
     # Check if this is request for a specific address-space
     #
     if len(words) > 0:
         return running_config_specific_address_space(context, config, words[0])

     #
     # Retrieve all address-space configurations
     #
     address_space_list = None
     try:
         address_space_list = \
             context.get_table_from_store('address-space')
     except Exception:
         pass

     #
     # Retrieve all address-spaces' identifier rules
     #
     address_space_rules = None
     try:
         address_space_rules = \
             context.get_table_from_store('address-space-identifier-rule')
     except Exception:
         pass

     #
     # Walk each address-space found and print its contents
     #
     if address_space_list:
         for address_space in address_space_list:
             tmp_config = [ ]

             #
             # Now print its contents in details
             #
             address_space_running_config_details(context, tmp_config,
                                                  address_space)

             #
             # If there is any identifier-rule configured, show each of them.
             #
             if address_space_rules:
                 address_space_running_config_id_rule(context, tmp_config,
                     address_space,
                     [rule for rule in address_space_rules \
                     if rule['address-space'] == address_space['name']])


             #
             # Don't shown empty configuration for default address-space.
             #
             if len(tmp_config) > 0 or address_space['name'] != 'default':
                 config.append("!\naddress-space %s\n" % address_space['name'])
                 config += tmp_config

 #
 # address_space_running_config_tuple
 #
 # address-space configuration tuple that we intend to process wrt
 # generating their running configuration
 #
 address_space_running_config_tuple = (
     (
         #
         # show running-configuration address-space
         #
         {
             'optional'   : False,
             'field'      : 'running-config',
             'type'       : 'enum',
             'values'     : 'address-space',
             'short-help' : 'Configuration for address spaces',
             'doc'        : 'running-config|show-address-space',
         },

         #
         # show running-configuration address-space <address-space>
         #
         {
             'field'        : 'word',
             'type'         : 'identifier',
             'completion'   : 'complete-from-another',
             'other'        : 'address-space|name',
             'parent-field' : None,
             'action'       : 'legacy-cli',
             'optional'     : True,
         }
     ),
 )

 #
 # Register with run_config module, our callback to process running configs for
 # address-space configuration items
 #
 run_config.register_running_config('address-space', 4000, None,
                                    running_config_address_space,
                                    address_space_running_config_tuple)
	#
	# Copyright (c) 2012,2013 Big Switch Networks, Inc.
	#
	# 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.
	#

	# address_space_run_config.py
	#
	# show running address-space [as]
	#

	import run_config
	import command
	import fmtcnv
	import utif
	import sys
	from midw import *

	def address_space_running_config_include_field(context, config,
	address_space, obj_type, field, value, indent, prefix = ""):
	"""
	Identify fields of obj_types who's values differ from the default
	values, since these need to be included into the running-config
	"""
	if context.mi.not_default_value(obj_type, field, value):
	if context.mi.is_field_string(obj_type, field):
	config.append(' ' * (indent + indent) + prefix + field +
	" %s\n" % utif.quote_string(value))
	else:
	config.append(' ' * (indent + indent) + prefix + field +
	' %s\n' % value)

	#
	# address_space_running_config_details
	#
	# Show an address-space configuration in detail
	#
	def address_space_running_config_details (context, config, address_space):
	"""
	Display the details for the fields of a address_space which may have
	non-default values.
	"""

	#
	# 'active' is True by default. Prepend 'no' into the generated config
	# if this item is not active.
	#
	if address_space['active'] != \
	context.mi.field_default_value('address-space', 'active'):
	config.append(' no active\n')

	#
	# Show the rest of the fields
	#
	address_space_fields = ['description', 'origin', 'priority',
	'vlan-tag-on-egress']

	for field in sorted(address_space_fields):
	address_space_running_config_include_field(context, config,
	address_space, 'address-space', field,
	address_space.get(field,''), 1)

	#
	# address_space_running_config_id_rule
	#
	# Generate indentifier-rule under address-space configuration
	#
	def address_space_running_config_id_rule (context, config, address_space,
	address_space_id_rule_entries):

	#
	# Iterate through each identifier-rule and show its contents
	#
	for rule in address_space_id_rule_entries:

	#
	# Show the rule header line
	#
	config.append(' identifier-rule %s\n' % rule['rule'])

	#
	# Iterate through each field configurable and generate the config
	# if present.
	#
	for field in ['description', 'active', 'priority']:
	address_space_running_config_include_field(context, config,
	address_space, 'address-space-identifier-rule', field,
	rule.get(field, ''), 2)

	for field in ['vlans', 'tag']:
	address_space_running_config_include_field(context, config,
	address_space, 'address-space-identifier-rule', field,
	rule.get(field, ''), 2, "match ")

	#
	# Manage switch and ports differently, placing both on the
	# same line when ports exist, and replacing the switch alias
	# when its available.
	if 'switch' in rule:
	dpid_or_alias = alias_lookup_with_foreign_key('switch-alias',
	rule['switch'])
	if dpid_or_alias == None:
	dpid_or_alias = rule['switch'] # dpid
	if 'ports' in rule:
	config.append(' match switch %s %s\n' % \
	(dpid_or_alias, rule['ports']))
	else:
	config.append(' match switch %s\n' % dpid_or_alias)

	#
	# This configuration section complete, print the trailer.
	#


	#
	# running_config_specific_address_space
	#
	# Show running configuration of one particular address-space
	#
	def running_config_specific_address_space (context, config, address_space_name):

	#
	# Have a temporary holder to store generated configuration.
	#
	tmp_config = [ ]

	#
	# Retrieve the configuration from the data store. Catch all possible
	# exceptions and report back as appropriate.
	#
	try:
	address_space = context.get_object_from_store(
	'address-space', address_space_name)
	except:

	#
	# This particular address-space is not available in the
	# data base. Report error back.
	#
	return ('Error: no address-space name %s, Error %s' % \
	(address_space_name, sys.exc_info()[0]))

	#
	# Show the configured sub items under this address-space.
	#
	address_space_running_config_details(context, tmp_config, address_space)

	#
	# Retrieve all the identifier rules configured. There may not be any
	# rule present. Handle it gracefully.
	#
	address_space_rules = None
	try:
	address_space_rules = context.get_table_from_store(
	'address-space-identifier-rule',
	'address-space',
	address_space_name, "exact")
	except Exception:
	pass

	#
	# Show each rule configured in detail
	#
	if address_space_rules:
	address_space_running_config_id_rule(context, tmp_config, address_space,
	address_space_rules)

	#
	# Don't shown empty configuration for default address-space.
	#
	if len(tmp_config) > 0 or address_space['name'] != 'default':
	config.append("address-space %s\n" % address_space_name)
	config += tmp_config

	#
	# running_config_address_space
	#
	# Show running configuration for 'all' address-space configured
	#
	def running_config_address_space (context, config, words):
	"""
	Add the Address Space configuration detils
	"""

	#
	# Check if this is request for a specific address-space
	#
	if len(words) > 0:
	return running_config_specific_address_space(context, config, words[0])

	#
	# Retrieve all address-space configurations
	#
	address_space_list = None
	try:
	address_space_list = \
	context.get_table_from_store('address-space')
	except Exception:
	pass

	#
	# Retrieve all address-spaces' identifier rules
	#
	address_space_rules = None
	try:
	address_space_rules = \
	context.get_table_from_store('address-space-identifier-rule')
	except Exception:
	pass

	#
	# Walk each address-space found and print its contents
	#
	if address_space_list:
	for address_space in address_space_list:
	tmp_config = [ ]

	#
	# Now print its contents in details
	#
	address_space_running_config_details(context, tmp_config,
	address_space)

	#
	# If there is any identifier-rule configured, show each of them.
	#
	if address_space_rules:
	address_space_running_config_id_rule(context, tmp_config,
	address_space,
	[rule for rule in address_space_rules \
	if rule['address-space'] == address_space['name']])


	#
	# Don't shown empty configuration for default address-space.
	#
	if len(tmp_config) > 0 or address_space['name'] != 'default':
	config.append("!\naddress-space %s\n" % address_space['name'])
	config += tmp_config

	#
	# address_space_running_config_tuple
	#
	# address-space configuration tuple that we intend to process wrt
	# generating their running configuration
	#
	address_space_running_config_tuple = (
	(
	#
	# show running-configuration address-space
	#
	{
	'optional' : False,
	'field' : 'running-config',
	'type' : 'enum',
	'values' : 'address-space',
	'short-help' : 'Configuration for address spaces',
	'doc' : 'running-config\|show-address-space',
	},

	#
	# show running-configuration address-space <address-space>
	#
	{
	'field' : 'word',
	'type' : 'identifier',
	'completion' : 'complete-from-another',
	'other' : 'address-space\|name',
	'parent-field' : None,
	'action' : 'legacy-cli',
	'optional' : True,
	}
	),
	)

	#
	# Register with run_config module, our callback to process running configs for
	# address-space configuration items
	#
	run_config.register_running_config('address-space', 4000, None,
	running_config_address_space,
	address_space_running_config_tuple)