Exemple #1
0
    grammer_12_1 = Group(serverfarm + host + name)
    grammer_12_2 = Group(Keyword('probe') + name)
    grammer_12_3 = Group(Keyword('inband-health') + Keyword('check') + name)
    grammer_12_4_1 = Keyword('rserver') + ~Word('host') + name + ZeroOrMore(
        num)
    grammer_12_4_2 = Keyword('inservice') + Optional(Keyword('standby'))
    grammer_12_4_3 = Group(Keyword('probe') + restOfLine)
    grammer_12_4_4 = Group(Keyword('backup-rserver') + restOfLine)

    grammer_12_4 = Group(grammer_12_4_1 + ZeroOrMore(grammer_12_4_3) +
                         ZeroOrMore(grammer_12_4_4) +
                         ZeroOrMore(grammer_12_4_2))
    grammer_12_5 = Group(
        Keyword('predictor') + Keyword('leastconns') + Keyword('slowstart') +
        num)
    # grammer_12_6 = Group(Keyword('description') + printables)
    # grammer_12_7 = Group(Keyword('predictor') + printables)
    grammer_12_6 = Group(Keyword('description') + restOfLine)
    grammer_12_7 = Group(Keyword('predictor') + restOfLine)
    grammer_12_8 = Group(Keyword('retcode') + restOfLine)
    grammer_12_9 = Keyword('fail-on-all')

    grammer_12 = Group(grammer_12_1 +
                       ZeroOrMore(grammer_12_2 | grammer_12_2 | grammer_12_3
                                  | grammer_12_4 | grammer_12_5 | grammer_12_6
                                  | grammer_12_7 | grammer_12_8
                                  | grammer_12_9))

    for match, start, end in grammer_12.scanString(s):
        print match
Exemple #2
0
def parser(file_name):
    """ Parsing goes here """
    LOG.info('Parser Started')

    with open(file_name, 'r') as input_config:
        input_data = input_config.read()
        input_config.seek(0, 2)
        file_size = input_config.tell()

    # grammer def:1 source-address-list Anywhere owner System
    key = Keyword("source-address-list")
    name = Word(printables)
    system = Keyword("owner")
    system_name = Word(alphanums)
    comment_key = Keyword("comments")
    comment = quotedString | Word(printables)
    grammer1 = Group(key + name + system + system_name +
                     Optional(comment_key + comment))

    # grammer def:2 ip address  10.10.10.10 255.255.255.255
    key1 = "ip address"
    ipaddress = Combine(Word(nums) + ('.' + Word(nums)) * 3)
    ipaddress1 = Empty().addParseAction(
        replaceWith('Mask')) + Combine(Word(nums) + ('.' + Word(nums)) * 3)
    grammer2 = Group(key1 + Optional(ipaddress) + Optional(ipaddress1) +
                     Optional('::/0'))

    # grammer def:3 domain-list <name> owner System
    key = Keyword("domain-list")
    name = Word(printables)
    own = Keyword("owner")
    owner_name = Word(alphanums)
    comments = Keyword('comment')
    comment = quotedString | Word(printables)
    grammer3 = Group(key + name + own + owner_name +
                     Optional(comments + comment))

    # grammer def:4
    domain_key = Keyword("domain")
    domain_name = Word(printables)
    grammer4 = Group(domain_key + ~Literal('-') + domain_name)

    # grammer def:4 answer vip 10.10.10.10 name <name> location
    # "<location>" manual-reactivation disable activate
    answer_key = Keyword("answer vip")
    ipaddress = Combine(Word(nums) + ('.' + Word(nums)) * 3)
    name_key = Keyword("name")
    name = Word(alphanums)
    location_key = Keyword("location")
    location = quotedString
    manual_reactivation_key = Keyword("manual-reactivation")
    manual_reactivation = Keyword("disable") | Keyword("enable")
    activate_key = Empty().addParseAction(
        replaceWith('Mode')) + Keyword("activate")

    grammer5 = Group(answer_key + ipaddress + name_key + name + location_key +
                     location + Optional(manual_reactivation_key) +
                     Optional(manual_reactivation) + Optional(activate_key))

    # grammer6 : keepalive type tcp port <port> ip-address <ip> <<retries>>
    #                        <<successful-probes>> <<termination>>
    #            keepalive type http-head port 80 <<path>> <<retries>>
    #                          <<successful-probes>> <<shared>> <<termination>>
    #            keepalive type icmp ip-address <ip>  <<retries>>
    #                       <<successful-probes>>
    key = Keyword('keepalive')
    tcp_key = Keyword("type tcp")
    http_key = Keyword("type http-head")
    icmp_key = Keyword("type icmp")
    port_key = Keyword("port")
    num = Word(nums)
    ip_add_key = Keyword("ip-address")
    ip_add = Combine(Word(nums) + ('.' + Word(nums)) * 3)
    retry = Optional(Keyword('retries') + num)
    probe = Optional(Keyword('successful-probes') + num)
    shared = Optional(Keyword('shared') + ip_add)
    path = Optional(Keyword('path') + ip_add)
    termination = Optional(
        Keyword('termination') + (Word('graceful') | Word('reset')))

    grammer6_1 = Group(key + tcp_key + port_key + num + ip_add_key + ip_add +
                       Optional(retry) + Optional(probe) +
                       Optional(termination))
    grammer6_2 = Group(key + http_key + path + port_key + num + retry + probe +
                       shared + termination)
    grammer6_3 = Group(key + icmp_key + Optional(ip_add_key + ip_add) + retry +
                       probe)

    grammer6 = grammer6_1 | grammer6_2 | grammer6_3

    # grammer 7: answer-group <name> owner System type vip comment "comment"
    key = Keyword("answer-group")
    key_name = Word(printables)
    owner_key = Keyword("owner")
    owner_name = Word(alphanums)
    type_key = Keyword("type")
    type_name = Word(alphas)
    comment_key = Keyword("comments")
    comments = quotedString() | Word(printables)

    grammer7 = Group(key + key_name + owner_key + owner_name + type_key +
                     type_name + Optional(comment_key + comments))

    # grammer 8: answer-add 10.10.10.10 name MDC-PROD-SMTP-ACE \
    # weight 1 order 1 load-threshold 254 suspend
    key = Keyword('answer-add')
    key_ip = Combine(Word(nums) + ('.' + Word(nums)) * 3)
    name_key = Keyword('name')
    name_val = Word(printables)
    weight_key = Keyword('weight')
    weight_val = Word(nums)
    order_key = Keyword('order')
    order_val = Word(nums)
    thres_key = Keyword('load-threshold')
    thres_val = Word(nums)
    suspend_key = Empty().addParseAction(replaceWith('Mode')) + Word(alphas)

    grammer8 = Group(key + key_ip + name_key + name_val + weight_key +
                     weight_val + order_key + order_val + thres_key +
                     thres_val + suspend_key)

    # grammer9:dns rule <rule name> owner System source-address-list
    # Anywhere domain-list <dl_name> activate
    # query a
    # <sticky | sticky method> <domain | domain-list> timeout 15
    key = Keyword("dns rule")
    key_val = Word(printables)
    owner_key = Keyword("owner")
    owner_name = Word(alphas)
    saddlist_key = Keyword("source-address-list")
    saddlist_val = Word(alphanums)
    domain_key = Keyword("domain-list")
    domain_val = Word(printables)
    activate_key = Empty().addParseAction(
        replaceWith('Mode')) + Keyword("activate")
    query_key = Keyword("query")
    query_val = Word("a") | Word(printables)
    s_key = Keyword('sticky method') | Keyword('sticky')
    d_key = Keyword('domain') | Keyword('domain-list')
    t_key = Keyword('timeout')
    t_val = Word(nums)

    grammer9 = Group(key + key_val + owner_key + owner_name + saddlist_key +
                     saddlist_val + domain_key + domain_val + activate_key +
                     Optional(query_key + query_val) +
                     Optional(s_key + d_key + t_key + t_val))

    # grammer10 :
    # clause 1 vip-group <name> method ordered ttl 20 \
    # count 1 <sticky|region-sticky> enabled manual-reactivation disable activate
    key = Keyword("clause")
    key_val = Word(nums)
    vip_key = Keyword("vip-group")
    vip_val = Word(printables)
    method_key = Keyword("method")
    method_val = Word(printables)
    ttl_key = Keyword("ttl")
    ttl_val = Word(nums)
    count_key = Keyword("count")
    count_val = Word(nums)
    sticky_key = Keyword("sticky") | Keyword("region-sticky")
    sticky_val = Word("enable")
    mr_key = Keyword("manual-reactivation")
    mr_val = Word("disable")
    state_key = Empty().addParseAction(replaceWith('Mode')) + Word("activate")

    grammer10 = Group(key + key_val + vip_key + vip_val + method_key +
                      method_val + ttl_key + ttl_val + count_key + count_val +
                      Optional(sticky_key + sticky_val) + mr_key + mr_val +
                      state_key)

    testing = Group(grammer1 + ZeroOrMore(grammer2)) | Group(
        grammer3 +
        ZeroOrMore(grammer4)) | Group(grammer5 + ZeroOrMore(grammer6)) | Group(
            grammer7 + ZeroOrMore(grammer8)) | Group(grammer9 +
                                                     ZeroOrMore(grammer10))

    LOG.info('Grammar Generated')

    child_ref = {
        'source-address-list': 'ip address',
        'domain-list': 'domain',
        'answer vip': 'keepalive',
        'answer-group': 'answer-add',
        'dns rule': 'clause'
    }

    excel_dict = dict()

    out_dict = {
        'source-address-list': [],
        'domain-list': [],
        'answer vip': [],
        'answer-group': [],
        'dns rule': []
    }

    ref = ''

    print("Parsing the File ...")

    total_parse_count = 0
    c = 0

    for match, start, end in testing.scanString(input_data):

        # incrementing total object count for reporting
        total_parse_count += 1

        matched = match.asList()
        type = matched[0][0][0]
        name = matched[0][0][1]
        excel_dict[type + '-' + name] = {
            'type': type,
            'name': name,
            'status': '',
            'na': '',
            'skipped': ''
        }
        msg = 'Parsing Entity [ ' + matched[0][0][0] + '->' +\
              matched[0][0][1] + ']'
        printProgressBar(end, file_size, msg, prefix='Progress', suffix='')

        # dictonary creation
        start = True
        for line in matched[0]:
            out = 'Parsing [ ' + line[0] + '->' + line[1] + ']'
            LOG.debug(out)
            # print matched[0]
            if start:
                ref = line[0]
                parent = parse(line)
                start = False
            else:
                child = parse(line)
                if child_ref[ref] not in parent:
                    parent[str(child_ref[ref])] = [child]
                else:
                    parent[str(child_ref[ref])].append(child)
        out_dict[ref].append(parent)

    LOG.info('Config File Parsed')
    set_excel_dict(excel_dict)

    return out_dict, excel_dict
Exemple #3
0
    def parse_ace(self):

        with open(self.file_name, 'r') as input_config:
            input_data = input_config.read()
            input_config.seek(0, 2)
            file_size = input_config.tell()

        # Pyparsing grammer starts here :excitement :-O

        command = Group(
            Keyword('logging') | Keyword('access-list') | Keyword('probe'))

        # Grammer Global
        name = Word(printables)
        ipaddress = Combine(Word(nums) + ('.' + Word(nums)) * 3)
        num = Word(nums)

        # Grammer 1:
        # logging enable
        # logging timestamp
        # logging trap 9
        # logging buffered 9
        # logging host 127.0.0.1 udp/619
        log = Keyword('logging')
        single_key = Keyword('enable') | Keyword('timestamp')
        double_key = (Keyword('trap') | Keyword('buffered')) + num
        triple_key = Keyword('host') + ipaddress + name
        grammer_1 = Group(log + (single_key | double_key | triple_key))

        # Grammer 2:
        # eg : access-list FROM_INSIDE line 11 extended permit ip <ip> 255.255.255.0 any
        access = Keyword('access-list')
        in_out = Keyword('FROM_INSIDE') | Keyword('FROM_OUTSIDE')
        line = Keyword('line')
        extend = Keyword('extended')
        permit = Keyword('permit')
        ip_key = Keyword('ip')
        any_key = Keyword('any')
        ip_any = ipaddress | any_key

        grammer_2 = Group(access + in_out + line + num + extend + permit +
                          ip_key + ip_any + ip_any + ip_any)

        # Grammer 3:
        # eg: probe http prb_HTTP-1234
        #        port 1234
        #        receive 5
        #        interval 10
        #        expect status 200 200
        #        expect regex "(200|302)"
        #        ssl version all
        #        request method get url /test/test:ping
        #        passdetect interval 10
        #        open 3

        probe = Keyword('probe')
        type_key = Keyword('http') | Keyword('icmp') | Keyword(
            'https') | Keyword('tcp')
        grammer_3_1 = Group(probe + type_key + name)

        grammer_3_2 = Group(Keyword('port') + Word(nums))
        grammer_3_3 = Group(Keyword('receive') + Word(nums))
        grammer_3_4 = Group(Keyword('interval') + Word(nums))
        grammer_3_5 = Group(
            (Keyword('expect') + Keyword('status') + Word(nums) + Word(nums))
            | (Keyword('expect') + Keyword('regex') + Word(printables)))
        grammer_3_6 = Group(Keyword('passdetect') + Keyword('interval') + num)
        grammer_3_7 = Group(Keyword('open') + num)
        grammer_3_8 = Group(
            Keyword('ssl') + Keyword('version') + Keyword('all'))

        request_key = Keyword('request')
        method_key = Keyword('method')
        get = Keyword('get')
        url_key = Keyword('url')
        url = Word(printables)
        grammer_3_6 = Group(request_key + method_key + get + url_key + url)

        grammer_3 = Group(grammer_3_1 +
                          ZeroOrMore(grammer_3_2 | grammer_3_3 | grammer_3_4
                                     | grammer_3_5 | grammer_3_6 | grammer_3_7
                                     | grammer_3_8))

        # grammer 4:
        # rserver host rs_Test123
        #   description TEST_DESC
        #   ip address 127.0.0.1
        #   webhost-redirection https://www.google.com/test/1234/ 301
        #   probe prb_HTTP-1234
        #   inservice

        rserver_key = Keyword('rserver')
        host = Keyword('host')
        rserver_name = Word(printables)

        grammer_4_1 = Group(rserver_key + host + rserver_name)
        grammer_4_2 = Group(Keyword('description') + restOfLine)
        grammer_4_3 = Group(Keyword('ip address') + ipaddress)
        grammer_4_4 = Group(Keyword('probe') + Word(printables))
        grammer_4_5 = Group(Keyword('inservice'))
        grammer_4_6 = Group(
            Keyword('webhost-redirection') + Word(printables) + num)

        grammer_4 = Group(grammer_4_1 +
                          ZeroOrMore(grammer_4_2 | grammer_4_3 | grammer_4_4
                                     | grammer_4_5 | grammer_4_6))

        # grammer 5
        # parameter-map type <connection|http|ssl> ALLOW_TEST
        #   tcp-options selective-ack allow
        #   tcp-options timestamp allow
        #   tcp-options window-scale allow
        #   persistence-rebalance strict
        #   set timeout inactivity 9999
        #   session-cache timeout 300
        #   queue-delay timeout 1
        #   set header-maxparse-length 65535
        #   set content-maxparse-length 65535
        #   cipher RSA_EXPORT1024_WITH_RC4_56_SHA

        param_key = Keyword('parameter-map')
        type_key = Word('type')
        connection = Word('connection') | Word('http') | Word('ssl')
        param_name = Word(printables)
        tcp_key = Word('tcp-options')
        tcp_type = Keyword('timestamp') | Keyword('window-scale') | Keyword(
            'selective-ack')
        allow = Word('allow')
        sess_queue = Keyword('session-cache') | Keyword('queue-delay')
        timeout = Keyword('timeout')
        set = Keyword('set')
        length = Keyword('header-maxparse-length') | Keyword(
            'content-maxparse-length')

        grammer_5_1 = Group(param_key + type_key + connection + param_name)
        grammer_5_2 = Group(tcp_key + tcp_type + allow)
        grammer_5_3 = Group(
            Keyword('persistence-rebalance') + Keyword('strict'))
        grammer_5_4 = Group(
            Keyword('set') + Keyword('timeout') + Keyword('inactivity') +
            Word(nums))
        grammer_5_5 = Group(set + length + num)
        grammer_5_6 = Group(sess_queue + timeout + num)
        grammer_5_7 = Group(Keyword('cipher') + name)
        grammer_5_8 = Keyword('case-insensitive')
        grammer_5_9 = Group(Keyword('parsing') + name)
        grammer_5_10 = Group(Keyword('exceed-mss') + name)

        grammer_5 = Group(grammer_5_1 +
                          ZeroOrMore(grammer_5_2 | grammer_5_3 | grammer_5_4
                                     | grammer_5_6 | grammer_5_7 | grammer_5_8
                                     | grammer_5_9 | grammer_5_10))

        # Grammer 6:
        # sticky ip-netmask 255.255.255.255 address source test-adfdas-$5D
        # sticky http-cookie TEST TEST_COOKIE
        #   serverfarm sf_TEST
        #   timeout 1000
        #   replicate sticky
        #   cookie insert browser-expire
        #   8 static cookie-value "ONETXEIS" rserver ESC20_TXEIS_APP_1 443
        sticky = Keyword('sticky')
        ipnetmask = Keyword('ip-netmask')
        http_cookie = Keyword('http-cookie')
        address = Keyword('address')
        source = Keyword('source')
        sticky_name = Word(printables)
        cookie = Keyword('cookie')
        insert = Keyword('insert')
        browser_expire = Keyword('browser-expire')
        static = Keyword('static')
        cookie_val = Keyword('cookie-value')

        grammer_6_1 = Group(sticky + ipnetmask + ipaddress + address + source +
                            sticky_name) | Group(sticky + http_cookie + name +
                                                 name)
        grammer_6_2 = Group(Keyword('serverfarm') + Word(printables))
        grammer_6_3 = Group(Keyword('timeout') + Word(nums))
        grammer_6_4 = Group(Keyword('replicate') + sticky)
        grammer_6_5 = Group(cookie + insert + browser_expire)
        grammer_6_6 = Group(num + static + cookie_val + name + rserver_key +
                            name + num)

        grammer_6 = Group(grammer_6_1 +
                          ZeroOrMore(grammer_6_2 | grammer_6_3 | grammer_6_4
                                     | grammer_6_5 | grammer_6_6))

        # grammer7:
        # class-map type management match-any TEST-PROTOCOLS
        # class-map match-any TEST_TEST_123
        # class-map match-any TEST_TEST_123
        # class-map match-all TEST_TEST_123
        #     2 match protocol icmp source-address 127.0.0.1 255.0.0.0
        #     3 match protocol snmp source-address 127.0.0.1 255.255.255.0
        #     2 match destination-address 127.0.0.1 255.255.255.0
        #     3 match source-address 127.0.0.1 255.255.255.0
        #     2 match virtual-address 127.0.0.1 tcp eq 1234
        #     2 match virtual-address 127.0.0.1 tcp any
        #     2 match http url .*

        classmap = Keyword('class-map')
        classmap_type = Keyword('type')
        mgmt = Keyword('management') | (Keyword('http') +
                                        Keyword('loadbalance'))
        type_key_att = classmap_type + mgmt
        match_key = Keyword('match-any') | Keyword('match-all')

        grammer7_1 = Group(classmap + match_key + name)

        match_key = Keyword('match')
        proto_key = Keyword('protocol')
        grammer_url = Group(num + match_key + Keyword('http') +
                            Keyword('url') + name)
        proto_type = Keyword('tcp') | Keyword('icmp') | Keyword(
            'snmp') | Keyword('http') | Keyword('https') | Keyword('udp')
        proto = proto_key + proto_type
        source_dest = Keyword('source-address') | Keyword(
            'destination-address')
        virtual_add = Keyword('virtual-address')
        eq_key = Keyword('eq')
        eq_val = Keyword('https') | Keyword('www') | Keyword('http') | num
        any_key = Keyword('any')
        add_att = Optional(proto) + source_dest + ipaddress + ipaddress
        virt_att = virtual_add + ipaddress + \
            proto_type + ((eq_key + eq_val) | any_key)

        grammer7_2 = Group(num + match_key +
                           (add_att | virt_att)) | grammer_url

        grammer_7 = Group(grammer7_1 + ZeroOrMore(grammer7_2))

        # grammer8:
        # policy-map type loadbalance first-match LB_TEST_MAP_1235
        #     class class-default
        #         serverfarm TEST_FARM_2
        #         sticky-serverfarm TEST_FARM_2
        #         connection advanced-options TEST_CONN123
        #         loadbalance vip inservice
        #         loadbalance vip icmp-reply
        #         loadbalance policy LB_TEST_123
        #         inspect ftp
        #         ssl-proxy server ssl_name
        #         nat dynamic 5 vlan 2100
        #         appl-parameter http advanced-options ADV-HTTP
        #         connection advanced-options NETSETTINGS
        #         action test_rewrite

        policy_key = Keyword('policy-map')
        lb_key = Keyword('loadbalance')
        match = Keyword('first-match') | Keyword('multi-match')

        grammer_8_1 = Group(policy_key + Optional(type_key + lb_key) + match +
                            name)

        grammer_8_2_1 = Group(Keyword('class') + name)

        grammer_8_2_2 = Group(((Keyword('serverfarm') | Keyword('action')
                                | Keyword('sticky-serverfarm')) + name)
                              | Keyword('drop')
                              | Keyword('insert-http') + restOfLine)
        grammer_8_2_3 = Group(
            Keyword('connection') + Keyword('advanced-option') + name)

        lb_vip = Keyword('vip') + (
            Keyword('inservice') | Keyword('icmp-reply') + ZeroOrMore(
                Keyword('active') + ZeroOrMore(Keyword('primary-inservice')))
            | Keyword('inservice'))
        lb_policy = Keyword('policy') + name
        grammer_8_2_4 = Group(Keyword('loadbalance') + (lb_vip | lb_policy))
        grammer_8_2_5 = Group(Keyword('inspect') + Keyword('ftp'))
        grammer_8_2_6 = Group(Keyword('ssl-proxy') + Keyword('server') + name)
        grammer_8_2_7 = Group(
            Keyword('nat') + Keyword('dynamic') + num + Keyword('vlan') + num)
        grammer_8_2_8 = Group(
            Keyword('appl-parameter') + Keyword('http') +
            Keyword('advanced-options') + name)
        grammer_8_2_9 = Group(
            Keyword('connection') + Keyword('advanced-options') + name)
        grammer_8_2_10 = Group(Keyword('action') + name)

        grammer_8_3 = Group(Keyword('description') + restOfLine)

        grammer_8_2 = Group(
            grammer_8_2_1 +
            ZeroOrMore(grammer_8_2_2 | grammer_8_2_3 | grammer_8_2_4
                       | grammer_8_2_5 | grammer_8_2_6 | grammer_8_2_7
                       | grammer_8_2_8 | grammer_8_2_9 | grammer_8_2_10))

        grammer_8 = Group(grammer_8_1 + ZeroOrMore(grammer_8_3) +
                          ZeroOrMore(grammer_8_2))

        # grammer9:
        # interface vlan 1011
        #     ip address 127.0.0.1 255.255.255.0
        #     alias 127.0.0.1 255.255.255.0
        #     peer ip address 127.0.0.1 255.255.255.0
        #     access-group input FROM_TEST
        #     service-policy input TEST_ACCESS
        #     service-policy input vs_TEST
        #     service-policy input TEST_POLICY_8080
        #     no shutdown
        #     nat-pool 1 127.0.0.1 127.0.0.1 netmask 255.255.255.255 pat

        grammer_9_1 = Group(Keyword('interface') + Keyword('vlan') + num)
        grammer_9_2 = Group(ip_key + address + ipaddress + ipaddress)
        grammer_9_3 = Group(Keyword('alias') + ipaddress + ipaddress)
        grammer_9_4 = Group(
            Keyword('peer') + ip_key + address + ipaddress + ipaddress)
        grammer_9_5 = Group(Keyword('access-group') + Keyword('input') + name)
        grammer_9_6 = Group(
            Keyword('service-policy') + Keyword('input') + name)
        grammer_9_7 = Group(Keyword('no') + Keyword('shutdown'))
        grammer_9_8 = Group(
            Keyword('nat-pool') + num + ipaddress + ipaddress +
            Keyword('netmask') + ipaddress + Keyword('pat'))

        grammer_9 = Group(grammer_9_1 +
                          ZeroOrMore(grammer_9_2 | grammer_9_3 | grammer_9_4
                                     | grammer_9_5 | grammer_9_6 | grammer_9_7
                                     | grammer_9_8))

        # grammer 10:
        # ip route 0.0.0.0 0.0.0.0 127.0.0.1
        grammer_10 = Group(ip_key + Keyword('route') + ipaddress + ipaddress)

        # grammer 11:
        # snmp-server host 127.0.0.1 traps version 2c ********
        # snmp-server enable traps slb k7server
        snmp = Keyword('snmp-server')
        host = Keyword('host')
        traps = Keyword('traps')
        slb = Keyword('slb')
        version = Keyword('version')
        enable = Keyword('enable')
        host_att = host + ipaddress + traps + version + name + name
        ord_att = enable + traps + slb + name

        grammer_11 = Group(snmp + (host_att | ord_att))

        # grammer 12
        # serverfarm host TEST_TEST_79
        #     probe probe_TEST_123
        #     inband-health check count
        #     predictor leastconns slowstart 30
        #     rserver RS_TEST123
        #         inservice
        serverfarm = Keyword('serverfarm')
        host = Keyword('host')
        grammer_12_1 = Group(serverfarm + host + name)
        grammer_12_2 = Group(Keyword('probe') + name)
        grammer_12_3 = Group(
            Keyword('inband-health') + Keyword('check') + name)
        grammer_12_4_1 = Keyword(
            'rserver') + ~Word('host') + name + ZeroOrMore(num)
        grammer_12_4_2 = Keyword('inservice')
        grammer_12_4 = Group(grammer_12_4_1 + ZeroOrMore(grammer_12_4_2))
        grammer_12_5 = Group(
            Keyword('predictor') + Keyword('leastconns') +
            Keyword('slowstart') + num)
        grammer_12_6 = Group(Keyword('description') + printables)
        grammer_12_7 = Group(Keyword('predictor') + printables)
        grammer_12_6 = Group(Keyword('description') + restOfLine)
        grammer_12_7 = Group(Keyword('predictor') + restOfLine)

        grammer_12 = Group(grammer_12_1 +
                           ZeroOrMore(grammer_12_2 | grammer_12_2
                                      | grammer_12_3 | grammer_12_4
                                      | grammer_12_5 | grammer_12_6
                                      | grammer_12_7))

        # grammer ssl
        # ssl-proxy service SSL_CLIENT
        #     key KEY12.PEM
        #     cert CERT12.PEM
        #     ssl advanced-options PM1
        grammer_ssl = Group(Keyword('ssl-proxy') + Keyword('service') + name)
        grammer_ssl_key = Group(Keyword('key') + name)
        grammer_ssl_cert = Group(Keyword('cert') + name)
        grammer_ssl_opt = Group(
            Keyword('ssl') + Keyword('advanced-options') + name)

        grammer_ssl_comp = Group(grammer_ssl +
                                 ZeroOrMore(grammer_ssl_key | grammer_ssl_cert
                                            | grammer_ssl_opt))

        # crypto chaingroup test_group
        #   cert Test_cert.crt
        grammer_crypto_1 = Group(
            Keyword('crypto') + Keyword('chaingroup') + name)
        grammer_crypto_2 = Group(Keyword('cert') + name)
        grammer_crypto = Group(grammer_crypto_1 + ZeroOrMore(grammer_crypto_2))

        # aaa authentication login default group TAC_PLUS local
        # aaa accounting default group TAC_PLUS
        grammer_aaa_1 = Keyword('aaa')
        grammer_aaa_2 = Keyword('authentication login') | Keyword('accounting')
        grammer_aaa_3 = Keyword('default')
        grammer_aaa_4 = Keyword('group')
        grammer_aaa_5 = Keyword('local')

        grammer_aaa = Group(grammer_aaa_1 + grammer_aaa_2 + grammer_aaa_3 +
                            grammer_aaa_4 + (name | grammer_aaa_5))

        # action-list type modify http test-ssl-rewrite
        #   ssl url rewrite location ".*"
        #   header rewrite request Host header-value "(.*)" replace "%1\/"
        grammer_al_1 = Keyword('action-list')
        grammer_al_2 = Keyword('type')
        grammer_al_3 = Keyword('modify')
        grammer_al_4 = Keyword('http')
        grammer_al_5 = Keyword('ssl')
        grammer_al_6 = Keyword('url')
        grammer_al_7 = Keyword('rewrite')
        grammer_al_8 = Keyword('location')
        grammer_al_9 = Keyword('header')
        grammer_al_10 = Keyword('request')
        grammer_al_11 = Keyword('Host')
        grammer_al_12 = Keyword('header-value')
        grammer_al_13 = Keyword('replace')
        grammer_al_1_1 = Group(grammer_al_5 + grammer_al_6 + grammer_al_7 +
                               grammer_al_8 + name)
        grammer_al_1_2 = Group(grammer_al_9 + grammer_al_7 + grammer_al_10 +
                               grammer_al_11 + grammer_al_12 + name +
                               grammer_al_13 + name)
        grammer_al = Group(
            Group(grammer_al_1 + grammer_al_2 + grammer_al_3 + grammer_al_4 +
                  name) + ZeroOrMore(grammer_al_1_1 | grammer_al_1_2))

        # Overall Grammer
        grammer = Group(grammer_1 | grammer_2 | grammer_3 | grammer_4
                        | grammer_5 | grammer_6 | grammer_7 | grammer_8
                        | grammer_9 | grammer_10 | grammer_11 | grammer_12
                        | grammer_ssl_comp | grammer_aaa | grammer_crypto
                        | grammer_al)

        print "Grammer created .."
        LOG.info("Grammer created ..")

        out_dict = []
        total_parse_count = 0
        final_excel = []

        LOG.info("Parsing Starts ..")
        final_dict = dict()
        for match, start, end in grammer.scanString(input_data):
            key = ''
            extra_dict = {}

            # printing progress bar
            msg = ''
            printProgressBar(end, file_size, msg, prefix='Progress', suffix='')

            if match:
                matched = match.asList()
                command = input_data[start:end]
                out_dict.append(matched)
                if type(matched[0][0][0]) is list:
                    key = matched[0][0][0][0]
                    name_to_log = matched[0][0][0][1]
                else:
                    key = matched[0][0][0]
                    name_to_log = matched[0][0][1]

            LOG.info('Parsing happening for :{} ->  {}'.format(
                key, name_to_log))
            # LOG.debug('Parsing value {}'.format(matched))

            excel_dict = {
                'name': '',
                'type': '',
                'command': '',
                'converted': 'n',
                'status': 'Not Supported',
                'skipped': [],
                'indirect': [],
                'NA': [],
                'Avi Object': ''
            }

            name_to_log = None
            type_to_log = [
                'logging', 'access-list', 'rserver', 'serverfarm',
                'parameter-map', 'class-map', 'policy-map', 'sticky', 'probe',
                'action-list'
            ]

            if key == 'logging':
                matched = matched[0][0]
                name_to_log = matched[1]
                total_index = len(matched)
                if total_index == 2:
                    extra_dict = {'log_type': matched[1]}

                elif total_index == 3:
                    extra_dict = {'log_type': matched[1], 'value': matched[2]}

                elif total_index == 4:
                    extra_dict = {
                        'log_type': matched[1],
                        'value': matched[2],
                        'packet': matched[3]
                    }
                LOG.info('parsing: Logging for value : {}'.format(name_to_log))
                # LOG.debug('Logging value {}'.format(extra_dict))

            if key == 'access-list':
                matched = matched[0][0]
                name_to_log = "{} line {}".format(matched[0][1], matched[0][4])
                extra_dict = {
                    'type': matched[1],
                    matched[2]: matched[3],
                    'extend': matched[4],
                    'permit': matched[5],
                    'ip1': matched[7],
                    'ip2': matched[8],
                    'ip3': matched[9]
                }
                LOG.info('parsing: Access-list {}'.format(name_to_log))
                # LOG.debug('Access-list value {}'.format(extra_dict))

            if key == 'rserver':
                matched = matched[0][0]
                name_to_log = matched[0][2]
                extra_dict = {matched[0][1]: matched[0][2], 'desc': []}
                for match in matched[1:]:
                    temp_dict = dict()
                    if len(match) == 1:
                        temp_dict = {'type': match[0]}
                    elif len(match) == 3:
                        temp_dict = {
                            'type': 'redirect',
                            'code': match[2],
                            'location': match[1]
                        }
                    else:
                        temp_dict = {match[0]: match[1]}
                    extra_dict['desc'].append(temp_dict)

                LOG.info('parsing: rserver for value : {}'.format(name_to_log))
                # LOG.debug('rserver value {}'.format(extra_dict))

            if key == 'serverfarm':
                matched = matched[0][0]
                name_to_log = matched[0][2]
                extra_dict = {matched[0][1]: matched[0][2], 'desc': []}
                for match in matched[1:]:
                    temp_dict = dict()
                    if len(match) < 3:
                        temp_dict = {match[0]: match[1]}
                    else:
                        temp_dict = {match[0]: match[1], 'type': match[2]}
                    extra_dict['desc'].append(temp_dict)

                LOG.info(
                    'parsing: server farm for value : {}'.format(name_to_log))
                # LOG.debug('serverfarm value {}'.format(extra_dict))

            if key == 'parameter-map':
                matched = matched[0][0]
                name_to_log = matched[0][3]
                extra_dict = {
                    matched[0][1]: matched[0][2],
                    'conn_name': matched[0][3],
                    'desc': []
                }
                for match in matched[1:]:
                    temp_dict = dict()
                    if len(match) == 2:
                        temp_dict = {match[0]: match[1]}
                    else:
                        temp_dict = {match[0]: match[1], 'allow': match[2]}
                    extra_dict['desc'].append(temp_dict)

                LOG.info('parsing: parameter-map for value : {}'.format(
                    name_to_log))

            if key == 'class-map':
                matched = matched[0][0]
                name_to_log = matched[0][2]
                extra_dict = {
                    matched[0][0]: matched[0][2],
                    'type': matched[0][1],
                    'desc': []
                }
                for match in matched[1:]:
                    temp_dict = dict()
                    if len(match) == 7:
                        temp_dict = {
                            match[1]: match[0],
                            match[2]: match[3],
                            match[4]: match[6]
                        }
                    elif len(match) == 5:
                        temp_dict = {
                            match[1]: match[0],
                            match[2]: match[3],
                            "mask": match[4]
                        }
                    elif len(match) == 6:
                        temp_dict = {
                            match[1]: match[0],
                            match[2]: match[3],
                            match[4]: match[5]
                        }
                    extra_dict['desc'].append(temp_dict)
                LOG.info(
                    'parsing: class-map for value : {}'.format(name_to_log))
                # LOG.debug('class-map value {}'.format(extra_dict))

            if key == 'policy-map':
                matched = matched[0][0]
                if len(matched[0]) == 5:
                    extra_dict = {
                        matched[0][1]: matched[0][2],
                        'match': matched[0][3],
                        'name': matched[0][4],
                        'desc': []
                    }
                    name_to_log = matched[0][4]
                else:
                    extra_dict = {
                        matched[0][0]: matched[0][2],
                        'match': matched[0][1],
                        'desc': []
                    }
                    name_to_log = matched[0][2]

                for match in matched[1:]:
                    temp_dict = dict()
                    temp_dict = {match[0][0]: match[0][1], 'class_desc': []}
                    for match1 in match[1:]:
                        temp_dict_1 = dict()
                        if len(match1) == 2:
                            temp_dict_1 = {match1[0]: match1[1]}
                        elif len(match1) == 3:
                            temp_dict_1 = {
                                match1[0]: match1[1],
                                'type': match1[2]
                            }
                        temp_dict['class_desc'].append(temp_dict_1)
                    extra_dict['desc'].append(temp_dict)
                LOG.info(
                    'parsing: policy-map for value : {}'.format(name_to_log))

            if key == 'sticky':
                matched = matched[0][0]
                if len(matched[0]) == 6:
                    name_to_log = matched[0][5]
                    extra_dict = {
                        matched[0][1]: matched[0][2],
                        'name': matched[0][5],
                        'desc': []
                    }
                if len(matched[0]) == 4:
                    name_to_log = matched[0][3]
                    extra_dict = {
                        matched[0][1]: matched[0][1],
                        'name': name_to_log,
                        'desc': []
                    }
                for match in matched[1:]:
                    temp_dict = dict()
                    if len(match) == 2:
                        temp_dict = {match[0]: match[1]}
                    extra_dict['desc'].append(temp_dict)
                LOG.info('parsing: sticky for value : {}'.format(name_to_log))
                # LOG.debug('sticky value {}'.format(extra_dict))

            if key == 'ssl-proxy':
                matched = matched[0][0]
                name_to_log = matched[0][2]
                extra_dict = {
                    'type': matched[0][1],
                    'name': name_to_log,
                    'desc': []
                }
                for match in matched[1:]:
                    if len(match) == 2:
                        temp_dict = {match[0]: match[1]}
                    if len(match) == 3:
                        temp_dict = {match[0]: match[1], 'name': match[2]}
                    extra_dict['desc'].append(temp_dict)
        # action-list type modify http test-ssl-rewrite
        #   ssl url rewrite location ".*"
        #   header rewrite request Host header-value "(.*)" replace "%1\/"
            if key == 'action-list':
                matched = matched[0][0]
                name_to_log = matched[0][4]
                extra_dict = {
                    matched[0][0]: name_to_log,
                    matched[0][1]: matched[0][2],
                    matched[0][3]: matched[0][4],
                    'desc': []
                }
                for match in matched[1:]:
                    if len(match) == 5:
                        temp_dict = {
                            match[0]: match[1],
                            match[2]: match[3],
                            "to": match[4]
                        }
                    if len(match) == 8:
                        temp_dict = {
                            match[0]: match[1],
                            match[2]: match[3],
                            match[4]: match[5],
                            match[6]: match[7],
                        }
                    extra_dict['desc'].append(temp_dict)
                LOG.info(
                    'parsing: action-list for value : {}'.format(name_to_log))

            if key == 'probe':
                matched = matched[0][0]
                name_to_log = matched[0][2]
                extra_dict = {
                    'type': matched[0][1],
                    'name': matched[0][2],
                }
                for match in matched[1:]:
                    temp_dict = dict()
                    if len(match) == 2:
                        temp_dict = {match[0]: match[1]}
                    if len(match) == 4:
                        temp_dict = {'status': match[2], 'status1': match[3]}
                    if len(match) == 3:
                        if 'regex' in match:
                            temp_dict = {'regex': 'yes'}
                    if len(match) == 5:
                        temp_dict = {match[1]: match[2], match[3]: match[4]}
                    extra_dict.update(temp_dict)
                LOG.info('parsing: probe for value : {}'.format(name_to_log))

            # updating excel sheet
            if key in type_to_log and name_to_log:
                excel_dict['name'] = name_to_log
                excel_dict['type'] = key
                final_excel.append(excel_dict)

            if key not in final_dict.keys():
                final_dict.update({key: [extra_dict]})
            else:
                final_dict[key].append(extra_dict)

        set_excel_dict(final_excel)
        printProgressBar(file_size,
                         file_size,
                         msg,
                         prefix='Progress',
                         suffix='')
        return final_dict