Contributing lib/ansible/modules/network/cloudengine/ce_netstream_global.py module to manage HUAWEI data center CloudEngine (#21817)

* add ce_netstream_global module

add ce_netstream_global module

* update ce_netstream_global

update ce_netstream_global

* fix CI issues

* fix pep8 error

lib/ansible/modules/network/cloudengine/ce_netstream_global.py

@@ -0,0 +1,911 @@
+#!/usr/bin/python
+#
+# This file is part of Ansible
+#
+# Ansible is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ansible is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+#
+ANSIBLE_METADATA = {'status': ['preview'],
+                    'supported_by': 'community',
+                    'metadata_version': '1.0'}
+
+DOCUMENTATION = """
+---
+module: ce_netstream_global
+version_added: "2.4"
+short_description: Manages global parameters of NetStream on HUAWEI CloudEngine switches.
+description:
+    - Manages global parameters of NetStream on HUAWEI CloudEngine switches.
+author: YangYang (@CloudEngine-Ansible)
+options:
+    type:
+        description:
+            - Specifies the type of netstream global.
+        required: false
+        choices: ['ip', 'vxlan']
+        default: 'ip'
+    state:
+        description:
+            - Specify desired state of the resource.
+        required: false
+        choices: ['present', 'absent']
+        default: present
+    interface:
+        description:
+            - Netstream global interface.
+        required: true
+        default: null
+    sampler_interval:
+        description:
+            -  Specifies the netstream sampler interval, length is 1 - 65535.
+        required: false
+        default: null
+    sampler_direction:
+        description:
+            -  Specifies the netstream sampler direction.
+        required: false
+        choices: ['inbound', 'outbound']
+        default: null
+    statistics_direction:
+        description:
+            -  Specifies the netstream statistic direction.
+        required: false
+        choices: ['inbound', 'outbound']
+        default: null
+    statistics_record:
+        description:
+            -  Specifies the flexible netstream statistic record, length is 1 - 32.
+        required: false
+        default: null
+    index_switch:
+        description:
+            -  Specifies the netstream index-switch.
+        required: false
+        choices: ['16', '32']
+        default: '16'
+"""
+
+EXAMPLES = '''
+- name: netstream global module test
+  hosts: cloudengine
+  connection: local
+  gather_facts: no
+  vars:
+    cli:
+      host: "{{ inventory_hostname }}"
+      port: "{{ ansible_ssh_port }}"
+      username: "{{ username }}"
+      password: "{{ password }}"
+      transport: cli
+
+  tasks:
+
+  - name: Configure a netstream sampler at interface 10ge1/0/2, direction is outbound,interval is 30.
+    ce_netstream_global:
+      interface: 10ge1/0/2
+      type: ip
+      sampler_interval: 30
+      sampler_direction: outbound
+      state: present
+      provider: "{{ cli }}"
+  - name: Configure a netstream flexible statistic at interface 10ge1/0/2, record is test1, type is ip.
+    ce_netstream_global:
+      type: ip
+      interface: 10ge1/0/2
+      statistics_record: test1
+      provider: "{{ cli }}"
+  - name: Set the vxlan index-switch to 32.
+    ce_netstream_global:
+      type: vxlan
+      interface: all
+      index_switch: 32
+      provider: "{{ cli }}"
+'''
+
+RETURN = '''
+proposed:
+    description: k/v pairs of parameters passed into module
+    returned: verbose mode
+    type: dict
+    sample: {"index_switch": "16",
+        "interface": "10ge1/0/2",
+        "state": "present",
+        "statistics_record": "test",
+        "type": "vxlan"}
+existing:
+    description: k/v pairs of existing configuration
+    returned: verbose mode
+    type: dict
+    sample: {"flexible_statistic": [
+            {
+                "interface": "10ge1/0/2",
+                "statistics_record": [],
+                "type": "ip"
+            },
+            {
+                "interface": "10ge1/0/2",
+                "statistics_record": [],
+                "type": "vxlan"
+            }
+        ],
+        "index-switch": [
+            {
+                "index-switch": "16",
+                "type": "ip"
+            },
+            {
+                "index-switch": "16",
+                "type": "vxlan"
+            }
+        ],
+        "ip_record": [
+            "test",
+            "test1"
+        ],
+        "sampler": [
+            {
+                "interface": "all",
+                "sampler_direction": "null",
+                "sampler_interval": "null"
+            }
+        ],
+        "statistic": [
+            {
+                "interface": "10ge1/0/2",
+                "statistics_direction": [],
+                "type": "null"
+            }
+        ],
+        "vxlan_record": [
+            "test"
+        ]}
+end_state:
+    description: k/v pairs of configuration after module execution
+    returned: verbose mode
+    type: dict
+    sample: {"flexible_statistic": [
+            {
+                "interface": "10ge1/0/2",
+                "statistics_record": [],
+                "type": "ip"
+            },
+            {
+                "interface": "10ge1/0/2",
+                "statistics_record": [
+                    "test"
+                ],
+                "type": "vxlan"
+            }
+        ],
+        "index-switch": [
+            {
+                "index-switch": "16",
+                "type": "ip"
+            },
+            {
+                "index-switch": "16",
+                "type": "vxlan"
+            }
+        ],
+        "sampler": [
+            {
+                "interface": "all",
+                "sampler_direction": "null",
+                "sampler_interval": "null"
+            }
+        ],
+        "statistic": [
+            {
+                "interface": "10ge1/0/2",
+                "statistics_direction": [],
+                "type": "null"
+            }
+        ]}
+updates:
+    description: commands sent to the device
+    returned: always
+    type: list
+    sample: ["interface 10ge1/0/2",
+        "netstream record test vxlan inner-ip"]
+changed:
+    description: check to see if a change was made on the device
+    returned: always
+    type: boolean
+    sample: true
+'''
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.ce import get_config, load_config
+from ansible.module_utils.ce import ce_argument_spec
+
+
+def get_interface_type(interface):
+    """Gets the type of interface, such as 10GE, ETH-TRUNK..."""
+
+    if interface is None:
+        return None
+
+    iftype = None
+
+    if interface.upper().startswith('GE'):
+        iftype = 'ge'
+    elif interface.upper().startswith('10GE'):
+        iftype = '10ge'
+    elif interface.upper().startswith('25GE'):
+        iftype = '25ge'
+    elif interface.upper().startswith('4X10GE'):
+        iftype = '4x10ge'
+    elif interface.upper().startswith('40GE'):
+        iftype = '40ge'
+    elif interface.upper().startswith('100GE'):
+        iftype = '100ge'
+    elif interface.upper().startswith('ETH-TRUNK'):
+        iftype = 'eth-trunk'
+    elif interface.upper().startswith('ALL'):
+        iftype = 'all'
+    else:
+        return None
+
+    return iftype.lower()
+
+
+class NetStreamGlobal(object):
+    """
+    Manages netstream global parameters.
+    """
+
+    def __init__(self, argument_spec):
+        self.spec = argument_spec
+        self.module = None
+        self.init_module()
+
+        # module input info
+        self.type = self.module.params['type']
+        self.interface = self.module.params['interface']
+        self.sampler_interval = self.module.params['sampler_interval']
+        self.sampler_direction = self.module.params['sampler_direction']
+        self.statistics_direction = self.module.params['statistics_direction']
+        self.statistics_record = self.module.params['statistics_record']
+        self.index_switch = self.module.params['index_switch']
+        self.state = self.module.params['state']
+
+        # host info
+        self.host = self.module.params['host']
+        self.username = self.module.params['username']
+        self.port = self.module.params['port']
+
+        # state
+        self.changed = False
+        self.updates_cmd = list()
+        self.commands = list()
+        self.results = dict()
+        self.proposed = dict()
+        self.existing = dict()
+        self.end_state = dict()
+
+        # local parameters
+        self.existing["sampler"] = list()
+        self.existing["statistic"] = list()
+        self.existing["flexible_statistic"] = list()
+        self.existing["index-switch"] = list()
+        self.existing["ip_record"] = list()
+        self.existing["vxlan_record"] = list()
+        self.end_state["sampler"] = list()
+        self.end_state["statistic"] = list()
+        self.end_state["flexible_statistic"] = list()
+        self.end_state["index-switch"] = list()
+        self.sampler_changed = False
+        self.statistic_changed = False
+        self.flexible_changed = False
+        self.index_switch_changed = False
+
+    def init_module(self):
+        """init module"""
+
+        self.module = AnsibleModule(
+            argument_spec=self.spec, supports_check_mode=True)
+
+    def cli_load_config(self, commands):
+        """load config by cli"""
+
+        if not self.module.check_mode:
+            load_config(self.module, commands)
+
+    def cli_add_command(self, command, undo=False):
+        """add command to self.update_cmd and self.commands"""
+
+        if undo and command.lower() not in ["quit", "return"]:
+            cmd = "undo " + command
+        else:
+            cmd = command
+
+        self.commands.append(cmd)
+        if command.lower() not in ["quit", "return"]:
+            self.updates_cmd.append(cmd)
+
+    def get_exist_sampler_interval(self):
+        """get exist netstream sampler interval"""
+
+        sampler_tmp = dict()
+        sampler_tmp1 = dict()
+        flags = list()
+        exp = " | ignore-case  include ^netstream sampler random-packets"
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            sampler_tmp["sampler_interval"] = "null"
+            sampler_tmp["sampler_direction"] = "null"
+        else:
+            config_list = config.split(' ')
+            config_num = len(config_list)
+            sampler_tmp["sampler_direction"] = config_list[config_num - 1]
+            sampler_tmp["sampler_interval"] = config_list[config_num - 2]
+        sampler_tmp["interface"] = "all"
+        self.existing["sampler"].append(sampler_tmp)
+        if self.interface != "all":
+            flags = list()
+            exp = " | ignore-case  section include ^interface %s$" \
+                  " | include netstream sampler random-packets" % self.interface
+            flags.append(exp)
+            config = get_config(self.module, flags)
+            if not config:
+                sampler_tmp1["sampler_interval"] = "null"
+                sampler_tmp1["sampler_direction"] = "null"
+            else:
+                config = config.lstrip()
+                config_list = config.split('\n')
+                for config_mem in config_list:
+                    sampler_tmp1 = dict()
+                    config_mem_list = config_mem.split(' ')
+                    config_num = len(config_mem_list)
+                    sampler_tmp1["sampler_direction"] = config_mem_list[
+                        config_num - 1]
+                    sampler_tmp1["sampler_interval"] = config_mem_list[
+                        config_num - 2]
+                    sampler_tmp1["interface"] = self.interface
+                    self.existing["sampler"].append(sampler_tmp1)
+
+    def get_exist_statistic_record(self):
+        """get exist netstream statistic record parameter"""
+
+        if self.statistics_record and self.statistics_direction:
+            self.module.fail_json(
+                msg='Error: The statistic direction and record can not exist at the same time.')
+        statistic_tmp = dict()
+        statistic_tmp1 = dict()
+        statistic_tmp["statistics_record"] = list()
+        statistic_tmp["interface"] = self.interface
+        statistic_tmp1["statistics_record"] = list()
+        statistic_tmp1["interface"] = self.interface
+        flags = list()
+        exp = " | ignore-case  section include ^interface %s$" \
+              " | include netstream record"\
+              % (self.interface)
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            statistic_tmp["type"] = "ip"
+            self.existing["flexible_statistic"].append(statistic_tmp)
+            statistic_tmp1["type"] = "vxlan"
+            self.existing["flexible_statistic"].append(statistic_tmp1)
+        else:
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem = config_mem.lstrip()
+                statistic_tmp["statistics_record"] = list()
+                config_mem_list = config_mem.split(' ')
+                if str(config_mem_list[3]) == "ip":
+                    statistic_tmp["statistics_record"].append(
+                        str(config_mem_list[2]))
+            statistic_tmp["type"] = "ip"
+            self.existing["flexible_statistic"].append(statistic_tmp)
+            for config_mem in config_list:
+                statistic_tmp1["statistics_record"] = list()
+                config_mem = config_mem.lstrip()
+                config_mem_list = config_mem.split(' ')
+                if str(config_mem_list[3]) == "vxlan":
+                    statistic_tmp1["statistics_record"].append(
+                        str(config_mem_list[2]))
+            statistic_tmp1["type"] = "vxlan"
+            self.existing["flexible_statistic"].append(statistic_tmp1)
+
+    def get_exist_interface_statistic(self):
+        """get exist netstream interface statistic parameter"""
+
+        statistic_tmp1 = dict()
+        statistic_tmp1["statistics_direction"] = list()
+        flags = list()
+        exp = " | ignore-case  section include ^interface %s$" \
+              " | include netstream inbound|outbound"\
+              % self.interface
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            statistic_tmp1["type"] = "null"
+        else:
+            statistic_tmp1["type"] = "ip"
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem = config_mem.lstrip()
+                config_mem_list = config_mem.split(' ')
+                statistic_tmp1["statistics_direction"].append(
+                    str(config_mem_list[1]))
+        statistic_tmp1["interface"] = self.interface
+        self.existing["statistic"].append(statistic_tmp1)
+
+    def get_exist_index_switch(self):
+        """get exist netstream index-switch"""
+
+        index_switch_tmp = dict()
+        index_switch_tmp1 = dict()
+        index_switch_tmp["index-switch"] = "16"
+        index_switch_tmp["type"] = "ip"
+        index_switch_tmp1["index-switch"] = "16"
+        index_switch_tmp1["type"] = "vxlan"
+        flags = list()
+        exp = " | ignore-case  include index-switch"
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            self.existing["index-switch"].append(index_switch_tmp)
+            self.existing["index-switch"].append(index_switch_tmp1)
+        else:
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem_list = config_mem.split(' ')
+                if str(config_mem_list[2]) == "ip":
+                    index_switch_tmp["index-switch"] = "32"
+                    index_switch_tmp["type"] = "ip"
+                if str(config_mem_list[2]) == "vxlan":
+                    index_switch_tmp1["index-switch"] = "32"
+                    index_switch_tmp1["type"] = "vxlan"
+            self.existing["index-switch"].append(index_switch_tmp)
+            self.existing["index-switch"].append(index_switch_tmp1)
+
+    def get_exist_record(self):
+        """get exist netstream record"""
+
+        flags = list()
+        exp = " | ignore-case include netstream record"
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if config:
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem_list = config_mem.split(' ')
+                if config_mem_list[3] == "ip":
+                    self.existing["ip_record"].append(config_mem_list[2])
+                if config_mem_list[3] == "vxlan":
+                    self.existing["vxlan_record"].append(config_mem_list[2])
+
+    def get_end_sampler_interval(self):
+        """get end netstream sampler interval"""
+
+        sampler_tmp = dict()
+        sampler_tmp1 = dict()
+        flags = list()
+        exp = " | ignore-case  include ^netstream sampler random-packets"
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            sampler_tmp["sampler_interval"] = "null"
+            sampler_tmp["sampler_direction"] = "null"
+        else:
+            config_list = config.split(' ')
+            config_num = len(config_list)
+            sampler_tmp["sampler_direction"] = config_list[config_num - 1]
+            sampler_tmp["sampler_interval"] = config_list[config_num - 2]
+        sampler_tmp["interface"] = "all"
+        self.end_state["sampler"].append(sampler_tmp)
+        if self.interface != "all":
+            flags = list()
+            exp = " | ignore-case  section include ^interface %s$" \
+                  " | include netstream sampler random-packets" % self.interface
+            flags.append(exp)
+            config = get_config(self.module, flags)
+            if not config:
+                sampler_tmp1["sampler_interval"] = "null"
+                sampler_tmp1["sampler_direction"] = "null"
+            else:
+                config = config.lstrip()
+                config_list = config.split('\n')
+                for config_mem in config_list:
+                    sampler_tmp1 = dict()
+                    config_mem_list = config_mem.split(' ')
+                    config_num = len(config_mem_list)
+                    sampler_tmp1["sampler_direction"] = config_mem_list[
+                        config_num - 1]
+                    sampler_tmp1["sampler_interval"] = config_mem_list[
+                        config_num - 2]
+                    sampler_tmp1["interface"] = self.interface
+                    self.end_state["sampler"].append(sampler_tmp1)
+
+    def get_end_statistic_record(self):
+        """get end netstream statistic record parameter"""
+
+        if self.statistics_record and self.statistics_direction:
+            self.module.fail_json(
+                msg='Error: The statistic direction and record can not exist at the same time.')
+        statistic_tmp = dict()
+        statistic_tmp1 = dict()
+        statistic_tmp["statistics_record"] = list()
+        statistic_tmp["interface"] = self.interface
+        statistic_tmp1["statistics_record"] = list()
+        statistic_tmp1["interface"] = self.interface
+        flags = list()
+        exp = " | ignore-case  section include ^interface %s$" \
+              " | include netstream record"\
+              % (self.interface)
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            statistic_tmp["type"] = "ip"
+            self.end_state["flexible_statistic"].append(statistic_tmp)
+            statistic_tmp1["type"] = "vxlan"
+            self.end_state["flexible_statistic"].append(statistic_tmp1)
+        else:
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem = config_mem.lstrip()
+                statistic_tmp["statistics_record"] = list()
+                config_mem_list = config_mem.split(' ')
+                if str(config_mem_list[3]) == "ip":
+                    statistic_tmp["statistics_record"].append(
+                        str(config_mem_list[2]))
+            statistic_tmp["type"] = "ip"
+            self.end_state["flexible_statistic"].append(statistic_tmp)
+            for config_mem in config_list:
+                statistic_tmp1["statistics_record"] = list()
+                config_mem = config_mem.lstrip()
+                config_mem_list = config_mem.split(' ')
+                if str(config_mem_list[3]) == "vxlan":
+                    statistic_tmp1["statistics_record"].append(
+                        str(config_mem_list[2]))
+            statistic_tmp1["type"] = "vxlan"
+            self.end_state["flexible_statistic"].append(statistic_tmp1)
+
+    def get_end_interface_statistic(self):
+        """get end netstream interface statistic parameters"""
+
+        statistic_tmp1 = dict()
+        statistic_tmp1["statistics_direction"] = list()
+        flags = list()
+        exp = " | ignore-case  section include ^interface %s$" \
+              " | include netstream inbound|outbound"\
+              % self.interface
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            statistic_tmp1["type"] = "null"
+        else:
+            statistic_tmp1["type"] = "ip"
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem = config_mem.lstrip()
+                config_mem_list = config_mem.split(' ')
+                statistic_tmp1["statistics_direction"].append(
+                    str(config_mem_list[1]))
+        statistic_tmp1["interface"] = self.interface
+        self.end_state["statistic"].append(statistic_tmp1)
+
+    def get_end_index_switch(self):
+        """get end netstream index switch"""
+
+        index_switch_tmp = dict()
+        index_switch_tmp1 = dict()
+        index_switch_tmp["index-switch"] = "16"
+        index_switch_tmp["type"] = "ip"
+        index_switch_tmp1["index-switch"] = "16"
+        index_switch_tmp1["type"] = "vxlan"
+        flags = list()
+        exp = " | ignore-case  include index-switch"
+        flags.append(exp)
+        config = get_config(self.module, flags)
+        if not config:
+            self.end_state["index-switch"].append(index_switch_tmp)
+            self.end_state["index-switch"].append(index_switch_tmp1)
+        else:
+            config = config.lstrip()
+            config_list = config.split('\n')
+            for config_mem in config_list:
+                config_mem_list = config_mem.split(' ')
+                if str(config_mem_list[2]) == "ip":
+                    index_switch_tmp["index-switch"] = "32"
+                    index_switch_tmp["type"] = "ip"
+                if str(config_mem_list[2]) == "vxlan":
+                    index_switch_tmp1["index-switch"] = "32"
+                    index_switch_tmp1["type"] = "vxlan"
+            self.end_state["index-switch"].append(index_switch_tmp)
+            self.end_state["index-switch"].append(index_switch_tmp1)
+
+    def check_params(self):
+        """check all input params"""
+
+        # netstream parameters check
+        if not get_interface_type(self.interface):
+            self.module.fail_json(
+                msg='Error: Interface name of %s is error.' % self.interface)
+        if self.sampler_interval:
+            if not str(self.sampler_interval).isdigit():
+                self.module.fail_json(
+                    msg='Error: Active interval should be numerical.')
+            if int(self.sampler_interval) < 1 or int(self.sampler_interval) > 65535:
+                self.module.fail_json(
+                    msg="Error: Sampler interval should between 1 - 65535.")
+        if self.statistics_record:
+            if len(self.statistics_record) < 1 or len(self.statistics_record) > 32:
+                self.module.fail_json(
+                    msg="Error: Statistic record length should between 1 - 32.")
+        if self.interface == "all":
+            if self.statistics_record or self.statistics_direction:
+                self.module.fail_json(
+                    msg="Error: Statistic function should be used at interface.")
+        if self.statistics_direction:
+            if self.type == "vxlan":
+                self.module.fail_json(
+                    msg="Error: Vxlan do not support inbound or outbound statistic.")
+        if (self.sampler_interval and not self.sampler_direction) \
+                or (self.sampler_direction and not self.sampler_interval):
+            self.module.fail_json(
+                msg="Error: Sampler interval and direction must be set at the same time.")
+
+        if self.statistics_record and not self.type:
+            self.module.fail_json(
+                msg="Error: Statistic type and record must be set at the same time.")
+
+        self.get_exist_record()
+        if self.statistics_record:
+            if self.type == "ip":
+                if self.statistics_record not in self.existing["ip_record"]:
+                    self.module.fail_json(
+                        msg="Error: The statistic record is not exist.")
+            if self.type == "vxlan":
+                if self.statistics_record not in self.existing["vxlan_record"]:
+                    self.module.fail_json(
+                        msg="Error: The statistic record is not exist.")
+
+    def get_proposed(self):
+        """get proposed info"""
+
+        if self.type:
+            self.proposed["type"] = self.type
+        if self.interface:
+            self.proposed["interface"] = self.interface
+        if self.sampler_interval:
+            self.proposed["sampler_interval"] = self.sampler_interval
+        if self.sampler_direction:
+            self.proposed["sampler_direction"] = self.sampler_direction
+        if self.statistics_direction:
+            self.proposed["statistics_direction"] = self.statistics_direction
+        if self.statistics_record:
+            self.proposed["statistics_record"] = self.statistics_record
+        if self.index_switch:
+            self.proposed["index_switch"] = self.index_switch
+        if self.state:
+            self.proposed["state"] = self.state
+
+    def get_existing(self):
+        """get existing info"""
+        sampler_tmp = dict()
+        statistic_tmp = dict()
+        statistic_tmp1 = dict()
+        index_tmp = dict()
+        temp = False
+
+        self.get_exist_sampler_interval()
+        self.get_exist_interface_statistic()
+        self.get_exist_statistic_record()
+        self.get_exist_index_switch()
+
+        if self.state == "present":
+            for sampler_tmp in self.existing["sampler"]:
+                if self.interface == str(sampler_tmp["interface"]):
+                    temp = True
+                    if (self.sampler_interval and str(sampler_tmp["sampler_interval"]) != self.sampler_interval) \
+                            or (self.sampler_direction and
+                                str(sampler_tmp["sampler_direction"]) != self.sampler_direction):
+                        self.sampler_changed = True
+            if not temp:
+                if self.sampler_direction or self.sampler_interval:
+                    self.sampler_changed = True
+            for statistic_tmp in self.existing["statistic"]:
+                if str(statistic_tmp["interface"]) == self.interface and self.interface != "all":
+                    if self.type == "vxlan":
+                        if statistic_tmp["statistics_direction"] \
+                                and 'outbound' in statistic_tmp["statistics_direction"]:
+                            self.module.fail_json(
+                                msg='Error: The NetStream record vxlan '
+                                    'cannot be configured because the port has been configured NetStream outbound ip.')
+                    if statistic_tmp["statistics_direction"] and self.statistics_direction:
+                        if self.statistics_direction not in statistic_tmp["statistics_direction"]:
+                            self.statistic_changed = True
+                    else:
+                        if self.statistics_direction:
+                            self.statistic_changed = True
+            for statistic_tmp1 in self.existing["flexible_statistic"]:
+                if self.interface != "all" \
+                        and self.type == str(statistic_tmp1["type"]) \
+                        and self.interface == str(statistic_tmp1["interface"]):
+                    if statistic_tmp1["statistics_record"] and self.statistics_record:
+                        if self.statistics_record not in statistic_tmp1["statistics_record"]:
+                            self.flexible_changed = True
+                    else:
+                        if self.statistics_record:
+                            self.flexible_changed = True
+            for index_tmp in self.existing["index-switch"]:
+                if self.type == str(index_tmp["type"]):
+                    if self.index_switch != str(index_tmp["index-switch"]):
+                        self.index_switch_changed = True
+        else:
+            for sampler_tmp in self.existing["sampler"]:
+                if self.interface == str(sampler_tmp["interface"]):
+                    if (self.sampler_interval and str(sampler_tmp["sampler_interval"]) == self.sampler_interval) \
+                            and (self.sampler_direction and str(sampler_tmp["sampler_direction"]) == self.sampler_direction):
+                        self.sampler_changed = True
+            for statistic_tmp in self.existing["statistic"]:
+                if str(statistic_tmp["interface"]) == self.interface and self.interface != "all":
+                    if len(statistic_tmp["statistics_direction"]) and self.statistics_direction:
+                        if self.statistics_direction in statistic_tmp["statistics_direction"]:
+                            self.statistic_changed = True
+            for statistic_tmp1 in self.existing["flexible_statistic"]:
+                if self.interface != "all" \
+                        and self.type == str(statistic_tmp1["type"]) \
+                        and self.interface == str(statistic_tmp1["interface"]):
+                    if len(statistic_tmp1["statistics_record"]) and self.statistics_record:
+                        if self.statistics_record in statistic_tmp1["statistics_record"]:
+                            self.flexible_changed = True
+            for index_tmp in self.existing["index-switch"]:
+                if self.type == str(index_tmp["type"]):
+                    if self.index_switch == str(index_tmp["index-switch"]):
+                        if self.index_switch != "16":
+                            self.index_switch_changed = True
+
+    def operate_ns_gloabl(self):
+        """configure netstream global parameters"""
+
+        cmd = ""
+        if not self.sampler_changed and not self.statistic_changed \
+                and not self.flexible_changed and not self.index_switch_changed:
+            self.changed = False
+            return
+
+        if self.sampler_changed is True:
+            if self.type == "vxlan":
+                self.module.fail_json(
+                    msg="Error: Netstream do not support vxlan sampler.")
+            if self.interface != "all":
+                cmd = "interface %s" % self.interface
+                self.cli_add_command(cmd)
+            cmd = "netstream sampler random-packets %s %s" % (
+                self.sampler_interval, self.sampler_direction)
+            if self.state == "present":
+                self.cli_add_command(cmd)
+            else:
+                self.cli_add_command(cmd, undo=True)
+            if self.interface != "all":
+                cmd = "quit"
+                self.cli_add_command(cmd)
+        if self.statistic_changed is True:
+            if self.interface != "all":
+                cmd = "interface %s" % self.interface
+                self.cli_add_command(cmd)
+            cmd = "netstream %s ip" % self.statistics_direction
+            if self.state == "present":
+                self.cli_add_command(cmd)
+            else:
+                self.cli_add_command(cmd, undo=True)
+            if self.interface != "all":
+                cmd = "quit"
+                self.cli_add_command(cmd)
+        if self.flexible_changed is True:
+            if self.interface != "all":
+                cmd = "interface %s" % self.interface
+                self.cli_add_command(cmd)
+            if self.state == "present":
+                for statistic_tmp in self.existing["flexible_statistic"]:
+                    tmp_list = statistic_tmp["statistics_record"]
+                    if self.type == statistic_tmp["type"]:
+                        if self.type == "ip":
+                            if len(tmp_list):
+                                cmd = "netstream record %s ip" % tmp_list[0]
+                                self.cli_add_command(cmd, undo=True)
+                            cmd = "netstream record %s ip" % self.statistics_record
+                            self.cli_add_command(cmd)
+                        if self.type == "vxlan":
+                            if len(tmp_list):
+                                cmd = "netstream record %s vxlan inner-ip" % tmp_list[
+                                    0]
+                                self.cli_add_command(cmd, undo=True)
+                            cmd = "netstream record %s vxlan inner-ip" % self.statistics_record
+                            self.cli_add_command(cmd)
+            else:
+                if self.type == "ip":
+                    cmd = "netstream record %s ip" % self.statistics_record
+                    self.cli_add_command(cmd, undo=True)
+                if self.type == "vxlan":
+                    cmd = "netstream record %s vxlan inner-ip" % self.statistics_record
+                    self.cli_add_command(cmd, undo=True)
+            if self.interface != "all":
+                cmd = "quit"
+                self.cli_add_command(cmd)
+        if self.index_switch_changed is True:
+            if self.interface != "all":
+                self.module.fail_json(
+                    msg="Error: Index-switch function should be used globally.")
+            if self.type == "ip":
+                cmd = "netstream export ip index-switch %s" % self.index_switch
+            else:
+                cmd = "netstream export vxlan inner-ip index-switch %s" % self.index_switch
+            if self.state == "present":
+                self.cli_add_command(cmd)
+            else:
+                self.cli_add_command(cmd, undo=True)
+
+        if self.commands:
+            self.cli_load_config(self.commands)
+            self.changed = True
+
+    def get_end_state(self):
+        """get end state info"""
+
+        self.get_end_sampler_interval()
+        self.get_end_interface_statistic()
+        self.get_end_statistic_record()
+        self.get_end_index_switch()
+
+    def work(self):
+        """worker"""
+
+        self.check_params()
+        self.get_existing()
+        self.get_proposed()
+        self.operate_ns_gloabl()
+        self.get_end_state()
+        self.results['changed'] = self.changed
+        self.results['proposed'] = self.proposed
+        self.results['existing'] = self.existing
+        self.results['end_state'] = self.end_state
+        if self.changed:
+            self.results['updates'] = self.updates_cmd
+        else:
+            self.results['updates'] = list()
+
+        self.module.exit_json(**self.results)
+
+
+def main():
+    """Module main"""
+
+    argument_spec = dict(
+        type=dict(required=False, choices=['ip', 'vxlan'], default='ip'),
+        interface=dict(required=True, type='str'),
+        sampler_interval=dict(required=False, type='str'),
+        sampler_direction=dict(required=False, choices=['inbound', 'outbound']),
+        statistics_direction=dict(required=False, choices=['inbound', 'outbound']),
+        statistics_record=dict(required=False, type='str'),
+        index_switch=dict(required=False, choices=['16', '32'], default='16'),
+        state=dict(required=False, choices=['present', 'absent'], default='present'),
+    )
+    argument_spec.update(ce_argument_spec)
+    module = NetStreamGlobal(argument_spec)
+    module.work()
+
+
+if __name__ == '__main__':
+    main()