Index: /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/models/network/geneve/__init__.py =================================================================== --- /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/models/network/geneve/__init__.py (revision 0) +++ /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/models/network/geneve/__init__.py (working copy) @@ -0,0 +1,552 @@ +#!/usr/bin/env python +# encoding: utf-8 + +from hive.imports.model import * +from django.utils.translation import ugettext_lazy as _ +from hive.utils import get_ip_by_field +__ = _ + +SPLIT_CHAR = "ÿÿÿÿÿ" + +class CLI_FIELD(): + ENABLE = "geneve enable" + DISABLE = "geneve disable" + LEARN_ON = "geneve learn on" + LEARN_OFF = "geneve learn off" + PORT = "geneve port " + NAME = "name" + VNI = "vni" + +class API_FILED(): + ENABLE = "enable" + LEARNING = "learning" + PORT = "port" + NAME = "name" + VNI = "vni" + VLAN = "vlan" + LOCAL_IP = "local_ip" + REMOTE_IP = "remote_ip" + MAC = "mac" + GTEP_IP = "gtep_ip" + TYPE = "type" + LOCATION = "location" + CONTENT = "content" + +class INPUT_FIELD(): + PK = "pk" + VNI = "vni" + MAC = "mac" + GTEP_IP = "gtep_ip" + TYPE = "type" + NAME = "name" + LOCAL_IP = "local_ip" + REMOTE_IP = "remote_ip" + INTERFACE = "interface" + VLAN = "vlan" + TUNNELS = "tunnels" + TUNNEL = "tunnel" + +class FORWARDING_DIRECTION(): + REMOTE_CODE = 1 + LOCAL_CODE = 2 + REMOTE_TYPE = "remote" + LOCAL_TYPE = "local" + +class BasicSetting(ANModel): + get = FieldGroup(writable=False, verbose_name=_('Running Configuration'), level=BASIC, fields={ + 'enable': BooleanField(verbose_name=_('Enable GENEVE Configuration'), optional=True), + 'learning': BooleanField(verbose_name=_('Enable Learning'), optional=True), + 'port': PortField(verbose_name=_('Port Number'), default=6081, scope='1025..65000', optional=True), + }) + + class Meta: + profile = True + verbose_name = _('Basic Settings') + + class Manager(CLIManager): + def _get_query_set(self): + self.cli.set_enable() + cli_res = self.cli.cmd('show geneve all') + enable = False + learning = False + port = 6081 + enable_map = { + CLI_FIELD.ENABLE: True, + CLI_FIELD.DISABLE: False, + } + learn_map = { + CLI_FIELD.LEARN_ON: True, + CLI_FIELD.LEARN_OFF: False, + } + check_count = 0 + for each in cli_res.split("\n"): + if not each: + continue + if each in enable_map: + enable = enable_map[each] + check_count += 1 + continue + if CLI_FIELD.PORT in each: + port_split = each.split(CLI_FIELD.PORT) + if len(port_split) >= 2 and port_split[1]: + port = int(port_split[1]) + check_count += 1 + continue + if each in learn_map: + learning = learn_map[each] + check_count += 1 + if check_count >= 3: + break + result = { + API_FILED.ENABLE: enable, + API_FILED.LEARNING: learning, + API_FILED.PORT: port, + } + self._model._meta.mark_delay_query(result) + return QuerySet(self._model, [result]) + + def _update(self, instance): + data = instance.get_field_dict() + self.cli.set_config() + mapping = { + API_FILED.ENABLE: { + True: CLI_FIELD.ENABLE, + False: CLI_FIELD.DISABLE, + }, + API_FILED.LEARNING: { + True: CLI_FIELD.LEARN_ON, + False: CLI_FIELD.LEARN_OFF, + }, + API_FILED.PORT: { + 0: CLI_FIELD.PORT + '{port}', + }, + } + cli_list = [] + for key, each in mapping.items(): + if key not in data: + continue + if type(data[key]) is int and len(each): + dicts = {key: data[key]} + cli = each[0].format(**dicts) + cli_list.append(cli) + continue + if data[key] not in each: + continue + cli = each[data[key]] + cli_list.append(cli) + for each_cli in cli_list: + self.cli.cmd(each_cli, + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + +class Interface(ANModel): + default = FieldGroup(editable=False, fields={ + 'vni': Uint32Field(verbose_name=_('VNI'), scope='1..32768'), + 'name': CharField(verbose_name=_('Geneve Interface Name'), primary_key=True, length='1..32'), + 'vlan': CharField(verbose_name=_('VLAN Interface Name'), length='1..32', optional=True), + }) + + class Clear(Action): + verbose_name = _('Clear') + action_name = _('Clear') + config_change = True + + class BindTunnel(Action): + verbose_name = _('Bind Tunnel') + action_name = _('Bind Tunnel') + config_change = True + option_fields = ( + CharField(name='interface', verbose_name='Geneve Interface'), + CharField(name='tunnel', verbose_name='Geneve Tunnel'), + ) + + class UnbindTunnel(Action): + verbose_name = _('Unbind Tunnel') + action_name = _('Unbind Tunnel') + config_change = True + option_fields = ( + CharField(name='interface', verbose_name='Geneve Interface'), + CharField(name='tunnels', verbose_name='Tunnel Name List'), + ) + + class ClearTunnels(Action): + verbose_name = _('Clear Tunnels') + action_name = _('Clear Tunnels') + config_change = True + option_fields = ( + CharField(name='interface', verbose_name='Geneve Interface'), + ) + + class BindVLAN(Action): + verbose_name = _('Bind VLAN') + action_name = _('Bind VLAN') + config_change = True + option_fields = ( + CharField(name='interface', verbose_name='Geneve Interface'), + CharField(name='vlan', verbose_name='VLAN Interface'), + ) + + class UnbindVLAN(Action): + verbose_name = _('Unbind VLAN') + action_name = _('Unbind VLAN') + config_change = True + option_fields = ( + CharField(name='interface', verbose_name='Geneve Interface'), + CharField(name='vlan', verbose_name='VLAN Interface'), + ) + + class Meta: + verbose_name = _('Geneve Interface') + + class Manager(CLIManager): + def _get_query_set(self): + self.cli.set_enable() + result = [] + cli_res = self.cli.cmd('show geneve interface', + EasyParser('geneve interface ', ['?name', '?vni'])) + vlan_mapping = self._get_vlan_mapping() + for each in cli_res: + if CLI_FIELD.NAME not in each or CLI_FIELD.VNI not in each: + continue + vlan = "" + if each[CLI_FIELD.NAME] in vlan_mapping: + vlan = vlan_mapping[each[CLI_FIELD.NAME]] + result.append({ + API_FILED.NAME: each[CLI_FIELD.NAME], + API_FILED.VNI: int(each[CLI_FIELD.VNI]), + API_FILED.VLAN: vlan, + }) + return QuerySet(self._model, result) + + def _get_vlan_mapping(self): + self.cli.set_enable() + cli_res = self.cli.cmd('show geneve all') + mapping = {} + for each in cli_res.split("\n"): + if not each: + continue + if "geneve associate" not in each: + continue + split = each.split(" ") + if len(split) != 4: + continue + mapping[split[2].strip()] = split[3].strip() + return mapping + + def _insert(self, instance): + data = instance.get_field_dict() + self.cli.set_config() + result = self.cli.cmd('geneve interface {name} {vni}'.format(name=data[INPUT_FIELD.NAME], + vni=data[INPUT_FIELD.VNI]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return result + + def _delete(self, pk_list): + self.cli.set_config() + for each in pk_list: + if INPUT_FIELD.NAME not in each: + continue + self.cli.cmd('no geneve interface {name}'.format(name=each[INPUT_FIELD.NAME]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_Clear(self): + self.cli.set_config() + self.cli.cmd("clear geneve interface", + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_BindTunnel(self, options): + self.cli.set_config() + self.cli.cmd('geneve bind {interface} {tunnel}'.format(interface=options[INPUT_FIELD.INTERFACE], + tunnel=options[INPUT_FIELD.TUNNEL]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_UnbindTunnel(self, options): + if not options[INPUT_FIELD.INTERFACE] or not options[INPUT_FIELD.TUNNELS]: + return + self.cli.set_config() + split = options[INPUT_FIELD.TUNNELS].split(SPLIT_CHAR) + try: + for each in split: + data = json.loads(each) + if INPUT_FIELD.NAME not in data: + continue + self.cli.cmd('no geneve bind {interface} {tunnel}'.format(interface=options[INPUT_FIELD.INTERFACE], + tunnel=data[INPUT_FIELD.NAME]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + except ValueError: + return "Invalid json format for tunnels." + return + + def _perform_ClearTunnels(self, options): + if not options[INPUT_FIELD.INTERFACE]: + return + self.cli.set_config() + self.cli.cmd('clear geneve bind {interface}'.format(interface=options[INPUT_FIELD.INTERFACE]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_BindVLAN(self, options): + self.cli.set_config() + self.cli.cmd('geneve associate {interface} {vlan}'.format(interface=options[INPUT_FIELD.INTERFACE], + vlan=options[INPUT_FIELD.VLAN]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_UnbindVLAN(self, options): + self.cli.set_config() + self.cli.cmd('no geneve associate {interface} {vlan}'.format(interface=options[INPUT_FIELD.INTERFACE], + vlan=options[INPUT_FIELD.VLAN]), + BlankParser(nonblank_exception=CLICmdError, supplement=True, + ignore_msg=["Warning: please also clear geneve local forwarding table after this CLI.\n"])) + return + +class Tunnel(ANModel): + default = FieldGroup(editable=False, fields={ + 'name': CharField(verbose_name=_('Tunnel Name'), primary_key=True, length='1..32'), + 'local_ip': IPAddressField(verbose_name=_("Local GTEP's IP")), + 'remote_ip': IPAddressField(verbose_name=_("Remote GTEP's IP")), + }) + + class Clear(Action): + verbose_name = _('Clear') + action_name = _('Clear') + config_change = True + + class Meta: + verbose_name = _('Geneve Tunnel') + + class Manager(CLIManager): + def _get_query_set(self): + result = self._get_tunnel_list([]) + return QuerySet(self._model, result) + + def _filter(self, filter_dict): + self.cli.set_enable() + result = [] + if INPUT_FIELD.INTERFACE not in filter_dict or not filter_dict[INPUT_FIELD.INTERFACE]: + return QuerySet(self._model, result) + cli_res = self.cli.cmd('show geneve bind {interface}'.format(interface=filter_dict[INPUT_FIELD.INTERFACE])) + tunnels = [] + for each in cli_res.split("\n"): + if not each: + continue + split = each.split(" ") + if len(split) != 4: + continue + if split[2] != filter_dict[INPUT_FIELD.INTERFACE]: + continue + tunnels.append(split[3]) + if not tunnels: + return QuerySet(self._model, result) + result = self._get_tunnel_list(tunnels) + return QuerySet(self._model, result) + + def _get_tunnel_list(self, tunnels): + self.cli.set_enable() + result = [] + cli_res = self.cli.cmd('show geneve tunnel') + if "No such geneve tunnel configured." in cli_res: + return result + for each in cli_res.split("\n"): + if not each: + continue + split = each.split(" ") + if len(split) != 5: + continue + if tunnels and split[2].strip() not in tunnels: + continue + result.append({ + API_FILED.NAME: split[2].strip(), + API_FILED.LOCAL_IP: split[3].strip(), + API_FILED.REMOTE_IP: split[4].strip(), + }) + return result + + def _insert(self, instance): + data = instance.get_field_dict() + self.cli.set_config() + result = self.cli.cmd('geneve tunnel {name} {local} {remote}'.format(name=data[INPUT_FIELD.NAME], + local=get_ip_by_field(data, INPUT_FIELD.LOCAL_IP), + remote=get_ip_by_field(data, INPUT_FIELD.REMOTE_IP)), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return result + + def _delete(self, pk_list): + self.cli.set_config() + for each in pk_list: + self.cli.cmd('no geneve tunnel {name}'.format(name=each[INPUT_FIELD.NAME]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_Clear(self): + self.cli.set_config() + self.cli.cmd("clear geneve tunnel", + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + +class ForwardingEntry(ANModel): + default = FieldGroup(editable=False, fields={ + 'vni': Uint32Field(verbose_name=_('VNI'), primary_key=True, scope='1..32768'), + 'mac': MACAddressField(verbose_name=_('MAC Address'), primary_key=True), + 'gtep_ip': IPAddressField(verbose_name=_("GTEP's IP"), optional=True), + 'vlan': CharField(verbose_name=_('VLAN Interface Name'), length='1..32', optional=True), + 'type': CharField(verbose_name=_('Type'), optional=True), + 'location': Uint32Field(verbose_name=_('Location'), scope='1..2', optional=True), + }) + + class Delete(Action): + verbose_name = _('Delete Entry') + action_name = _('Delete Entry') + config_change = True + option_fields = ( + CharField(name='pk', verbose_name='Primary Key List'), + ) + + class ClearDynamic(Action): + verbose_name = _('Clear Dynamic') + action_name = _('Clear Dynamic') + config_change = True + option_fields = ( + Uint32Field(name='vni', verbose_name='VNI', scope='1..32768'), + ) + + class ClearStatic(Action): + verbose_name = _('Clear Static') + action_name = _('Clear Static') + config_change = True + option_fields = ( + Uint32Field(name='vni', verbose_name='VNI', scope='1..32768'), + ) + + class Meta: + verbose_name = _('Forwarding Entry') + + class Manager(CLIManager): + def _get_query_set(self): + return QuerySet(self._model, []) + + def _filter(self, filter_dict): + self.cli.set_enable() + result = [] + if INPUT_FIELD.VNI not in filter_dict or not filter_dict[INPUT_FIELD.VNI]: + return QuerySet(self._model, result) + mac = "" + if INPUT_FIELD.MAC in filter_dict and filter_dict[INPUT_FIELD.MAC]: + mac = " " + filter_dict[INPUT_FIELD.MAC] + cli_res = self.cli.cmd('show geneve forwarding {vni}{mac}'.format(vni=filter_dict[INPUT_FIELD.VNI], + mac=mac)) + is_local = False + is_remote = False + for each in cli_res.split("\n"): + if "MAC" in each and "GTEP-IP" in each and "TYPE" in each: + is_remote = True + continue + elif "MAC" in each and "VLAN" in each and "TYPE" in each: + is_local = True + continue + if "========================================" in each: + continue + split = each.split() + if len(split) != 3: + continue + if is_local: + result.append({ + API_FILED.VNI: filter_dict[INPUT_FIELD.VNI], + API_FILED.MAC: split[0], + API_FILED.GTEP_IP: "", + API_FILED.VLAN: split[1], + API_FILED.TYPE: split[2], + API_FILED.LOCATION: FORWARDING_DIRECTION.LOCAL_CODE + }) + elif is_remote: + result.append({ + API_FILED.VNI: filter_dict[INPUT_FIELD.VNI], + API_FILED.MAC: split[0], + API_FILED.GTEP_IP: split[1], + API_FILED.VLAN: "", + API_FILED.TYPE: split[2], + API_FILED.LOCATION: FORWARDING_DIRECTION.REMOTE_CODE + }) + return QuerySet(self._model, result) + + def _insert(self, instance): + data = instance.get_field_dict() + self.cli.set_config() + gtep_ip = "" + direction = FORWARDING_DIRECTION.LOCAL_TYPE + if INPUT_FIELD.GTEP_IP in data and data[INPUT_FIELD.GTEP_IP]: + gtep_ip = " " + get_ip_by_field(data, INPUT_FIELD.GTEP_IP) + direction = FORWARDING_DIRECTION.REMOTE_TYPE + result = self.cli.cmd('geneve forwarding {dir} {vni} {mac}{ip}'.format(dir=direction, + vni=data[INPUT_FIELD.VNI], + mac=data[INPUT_FIELD.MAC], + ip=gtep_ip), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return result + + def _perform_Delete(self, options): + self.cli.set_config() + map = { + FORWARDING_DIRECTION.REMOTE_CODE: FORWARDING_DIRECTION.REMOTE_TYPE, + FORWARDING_DIRECTION.LOCAL_CODE: FORWARDING_DIRECTION.LOCAL_TYPE, + } + pk_str_list = options[INPUT_FIELD.PK].split(SPLIT_CHAR) + pk_list = [json.loads(pk_str) for pk_str in pk_str_list] + for each in pk_list: + if INPUT_FIELD.TYPE not in each or \ + INPUT_FIELD.VNI not in each or \ + INPUT_FIELD.MAC not in each: + continue + if each[INPUT_FIELD.TYPE] not in map: + continue + if not each[INPUT_FIELD.VNI] or not each[INPUT_FIELD.MAC]: + continue + direction = map[each[INPUT_FIELD.TYPE]] + self.cli.cmd('no geneve forwarding {dir} {vni} {mac}'.format(dir=direction, + vni=each[INPUT_FIELD.VNI], + mac=each[INPUT_FIELD.MAC]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_ClearDynamic(self, options): + self.cli.set_config() + self.cli.cmd('clear geneve forwarding dynamic {vni}'.format(vni=options[INPUT_FIELD.VNI]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + + def _perform_ClearStatic(self, options): + self.cli.set_config() + self.cli.cmd('clear geneve forwarding static {vni}'.format(vni=options[INPUT_FIELD.VNI]), + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return + +class Configuration(ANModel): + get = FieldGroup(editable=False, verbose_name=_('Configuration'), + fields={ + 'content': CLITextField(verbose_name=_('Configuration')), + }) + + class Clear(Action): + verbose_name = _('Clear') + action_name = _('Clear') + config_change = True + + class Meta: + profile = True + verbose_name = _('Configuration') + show_im_export_button = False + + class Manager(CLIManager): + def _get_query_set(self): + self.cli.set_enable(force=True) + cli_res = self.cli.cmd('show geneve all') + return QuerySet(self._model, [{API_FILED.CONTENT:cli_res}]) + + def _perform_Clear(self): + self.cli.set_config() + self.cli.cmd("clear geneve all", + BlankParser(nonblank_exception=CLICmdError, supplement=True)) + return Index: /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/router.py =================================================================== --- /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/router.py (revision 39287) +++ /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/router.py (working copy) @@ -789,4 +789,15 @@ template = env.get_template("/monitoring/prometheus/index/log.html") response = HttpResponse(template.render()) return response - raise Http404('Page not found') \ No newline at end of file + raise Http404('Page not found') + +def geneve_log_download(request): + sess = get_current_session() + sess.cli.set_enable() + logs = sess.cli.cmd('show geneve all') + cur_time = time.strftime("%Y%m%d%H%M%S", time.localtime()) + file_name = "%s_%s.%s" % ("GENEVE_log", cur_time, 'txt') + response = HttpResponse(logs) + response['Content-Type'] = 'text/plain; charset=utf-8' + response['Content-Disposition'] = 'attachment; filename=%s' % file_name + return response Index: /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/urls.py =================================================================== --- /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/urls.py (revision 39287) +++ /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/apv/urls.py (working copy) @@ -59,4 +59,5 @@ url(r'^%s/%s/get_topology$' % (PRODUCT_KEYWORD, C_PATH_GSLB), get_topology), url(r'^%s/%s/get_top_chart_data$' % (PRODUCT_KEYWORD, C_PATH_GSLB), get_top_chart_data), url(r'^%s/%s/get_hits_chart_data$' % (PRODUCT_KEYWORD, C_PATH_GSLB), get_hits_chart_data), + url(r'^%s/network/geneve/download' % PRODUCT_KEYWORD, geneve_log_download), ) Index: /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/hive/model/ajax.py =================================================================== --- /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/hive/model/ajax.py (revision 39287) +++ /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/hive/model/ajax.py (working copy) @@ -31,6 +31,7 @@ from djproject.an_settings import GRAPH_DB_FILE_LIST from hive.utils import escapehtml import sqlite3, re +import traceback TIMEFORMAT='%Y-%m-%d %X' @@ -1148,6 +1149,28 @@ ret['error'] = unicode(_('Fails to save statistics data.')) return json.dumps(ret) + def get_info(self, **kwargs): + if 'initial_filter' not in kwargs: + raise Http404('no initial_filter provided') + try: + pk_list = json.loads(kwargs['initial_filter']) + instance = self.manager.get(pk_list) + data = instance.get_field_dict() + output = {} + for key, val in data.items(): + if isinstance(val, dict): + if "ipv4" in val and val["ipv4"]: + output[key] = val["ipv4"] + if "ipv6" in val and val["ipv6"]: + output[key] = val["ipv6"] + continue + output[key] = val + return json.dumps(output) + except Exception: + traceback.print_exc() + err_msg = traceback.format_exc() + return json.dumps([True, [['warning',unicode(_("Error occurred: {msg}".format(msg=err_msg) ))]]]) + class ObjectAjaxHandler(object): def __init__(self, request, session, app, model, action, pk): self.request = request Index: /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/hive/utils.py =================================================================== --- /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/hive/utils.py (revision 39287) +++ /branches/rel_apv_10_7/usr/click/webui/htdocs/new/src/hive/utils.py (working copy) @@ -592,7 +592,15 @@ except: return False return True - + +def get_ip_by_field(data, field): + ip_str = "" + if "ipv4" in data[field]: + ip_str = data[field]["ipv4"] + elif "ipv6" in data[field]: + ip_str = data[field]["ipv6"] + return ip_str + def get_sysctl_int(name): try: fh = open("/lib/libc.so.7", "r")