Instruction:
Make a summary of the following Python 3 code
def bind_port(self, context):
        vnic_type = context.current.get(bc.portbindings.VNIC_TYPE,
                                        bc.portbindings.VNIC_NORMAL)

        LOG.debug('Attempting to bind port %(port)s with vnic_type '
                  '%(vnic_type)s on network %(network)s ',
                  {'port': context.current['id'],
                   'vnic_type': vnic_type,
                   'network': context.network.current['id']})

        profile = context.current.get(bc.portbindings.PROFILE, {})

        if not self.driver.check_vnic_type_and_vendor_info(vnic_type,
                                                           profile):
            return

        for segment in context.network.network_segments:
            if self.check_segment(segment):
                vlan_id = segment[api.SEGMENTATION_ID]

                if not vlan_id:
                    LOG.warning('Cannot bind port: vlan_id is None.')
                    return

                LOG.debug("Port binding to Vlan_id: %s", str(vlan_id))

                # Check if this is a Cisco VM-FEX port or Intel SR_IOV port
                if self.driver.is_vmfex_port(profile):
                    profile_name = self.make_profile_name(vlan_id)
                    self.vif_details[
                        const.VIF_DETAILS_PROFILEID] = profile_name
                else:
                    self.vif_details[
                        bc.portbindings.VIF_DETAILS_VLAN] = str(vlan_id)

                context.set_binding(segment[api.ID],
                                    self.vif_type,
                                    self.vif_details,
                                    bc.constants.PORT_STATUS_ACTIVE)
                return

        LOG.error('UCS Mech Driver: Failed binding port ID %(id)s '
                  'on any segment of network %(network)s',
                  {'id': context.current['id'],
                   'network': context.network.current['id']})

Response: Binds a port to the current network segment.


Instruction:
Create a Python 3 function to
update the rule_info list.

Response:
def update_rule_entry(self, rule_info):
        """Update the rule_info list."""

        if rule_info.get('status') == 'up':
            self.add_rule_entry(rule_info)
        if rule_info.get('status') == 'down':
            self.remove_rule_entry(rule_info)


Instruction:
Given the following Python 3 function, write the documentation
def add_rule_entry(self, rule_info):

        new_rule = IpMacPort(rule_info.get('ip'), rule_info.get('mac'),
                             rule_info.get('port'))
        LOG.debug('Added rule info %s to the list', rule_info)
        self.rule_info.append(new_rule)

Response: Add a rule entry to the rule_info list.


Instruction:
How would you explain what the following Python 3 function does
def remove_rule_entry(self, rule_info):

        temp_list = list(self.rule_info)
        for rule in temp_list:
            if (rule.ip == rule_info.get('ip') and
                rule.mac == rule_info.get('mac') and
                    rule.port == rule_info.get('port')):
                LOG.debug('Removed rule info %s from the list', rule_info)
                self.rule_info.remove(rule)

Response: Remove rule entry from rule_info list.


Instruction:
Implement a Python 3 function for
finding a rule associated with a given mac.

Response:
def _find_chain_name(self, mac):
        """Find a rule associated with a given mac."""

        ipt_cmd = ['iptables', '-t', 'filter', '-S']
        cmdo = dsl.execute(ipt_cmd, root_helper=self._root_helper,
                           log_output=False)
        for o in cmdo.split('\n'):
            if mac in o.lower():
                chain = o.split()[1]
                LOG.info('Find %(chain)s for %(mac)s.',
                         {'chain': chain, 'mac': mac})
                return chain


Instruction:
Explain what the following Python 3 code does
def _find_rule_no(self, mac):

        ipt_cmd = ['iptables', '-L', '--line-numbers']
        cmdo = dsl.execute(ipt_cmd, self._root_helper, log_output=False)
        for o in cmdo.split('\n'):
            if mac in o.lower():
                rule_no = o.split()[0]
                LOG.info('Found rule %(rule)s for %(mac)s.',
                         {'rule': rule_no, 'mac': mac})
                return rule_no

Response: Find rule number associated with a given mac.


Instruction:
Can you tell what is the following Python 3 function doing
def update_ip_rule(self, ip, mac):

        rule_no = self._find_rule_no(mac)
        chain = self._find_chain_name(mac)
        if not rule_no or not chain:
            LOG.error('Failed to update ip rule for %(ip)s %(mac)s',
                      {'ip': ip, 'mac': mac})
            return

        update_cmd = ['iptables', '-R', '%s' % chain, '%s' % rule_no,
                      '-s', '%s/32' % ip, '-m', 'mac', '--mac-source',
                      '%s' % mac, '-j', 'RETURN']
        LOG.debug('Execute command: %s', update_cmd)
        dsl.execute(update_cmd, self._root_helper, log_output=False)

Response: Update a rule associated with given ip and mac.


Instruction:
Can you tell what is the following Python 3 function doing
def enqueue_event(self, event):

        LOG.debug('Enqueue iptable event %s.', event)
        if event.get('status') == 'up':
            for rule in self.rule_info:
                if (rule.mac == event.get('mac').lower() and
                        rule.port == event.get('port')):
                    # Entry already exist in the list.
                    if rule.ip != event.get('ip'):
                        LOG.debug('enqueue_event: Only updating IP from %s'
                                  ' to %s.' % (rule.ip, event.get('ip')))
                        # Only update the IP address if it is different.
                        rule.ip = event.get('ip')
                        return

        self._iptq.put(event)

Response: Enqueue the given event.


Instruction:
Write a Python 3 function for
updating the iptables based on information in the rule_info.

Response:
def update_iptables(self):
        """Update iptables based on information in the rule_info."""

        # Read the iptables
        iptables_cmds = ['iptables-save', '-c']
        all_rules = dsl.execute(iptables_cmds, root_helper=self._root_helper,
                                log_output=False)

        # For each rule in rule_info update the rule if necessary.
        new_rules = []
        is_modified = False
        for line in all_rules.split('\n'):
            new_line = line
            line_content = line.split()
            # The spoofing rule which includes mac and ip should have
            # -s cidr/32  option for ip address. Otherwise no rule
            # will be modified.
            if '-s' in line_content:
                tmp_rule_info = list(self.rule_info)
                for rule in tmp_rule_info:
                    if (rule.mac in line.lower() and
                        rule.chain.lower() in line.lower() and
                            not self._is_ip_in_rule(rule.ip, line_content)):
                        ip_loc = line_content.index('-s') + 1
                        line_content[ip_loc] = rule.ip + '/32'
                        new_line = ' '.join(line_content)
                        LOG.debug('Modified %(old_rule)s. '
                                  'New rule is %(new_rule)s.' % (
                                      {'old_rule': line,
                                       'new_rule': new_line}))
                        is_modified = True
            new_rules.append(new_line)

        if is_modified and new_rules:
            # Updated all the rules. Now commit the new rules.
            iptables_cmds = ['iptables-restore', '-c']
            dsl.execute(iptables_cmds, process_input='\n'.join(new_rules),
                        root_helper=self._root_helper, log_output=False)


Instruction:
How would you code a function in Python 3 to
process the event queue and update the rule table.

Response:
def process_rule_info(self):
        """Task responsible for processing event queue."""

        while True:
            try:
                event = self._iptq.get(block=False)
                LOG.debug('Dequeue event: %s.', event)
                self.update_rule_entry(event)
            except queue.Empty:
                self.update_iptables()
                time.sleep(1)
            except Exception:
                LOG.exception('ERROR: failed to process queue')


Instruction:
Here you have a function in Python 3, explain what it does
def setup(self, **kwargs):
        params = kwargs.get('params')
        LOG.info("asa_setup: tenant %(tenant)s %(in_vlan)d %(out_vlan)d"
                 " %(in_ip)s %(in_mask)s %(out_ip)s %(out_mask)s",
                 {'tenant': params.get('tenant_name'),
                  'in_vlan': params.get('in_vlan'),
                  'out_vlan': params.get('out_vlan'),
                  'in_ip': params.get('in_ip'),
                  'in_mask': params.get('in_mask'),
                  'out_ip': params.get('out_ip'),
                  'out_mask': params.get('out_mask')})
        inside_vlan = str(params.get('in_vlan'))
        outside_vlan = str(params.get('out_vlan'))
        context = params.get('tenant_name')
        cmds = ["conf t", "changeto system"]
        inside_int = params.get('intf_in') + '.' + inside_vlan
        cmds.append("int " + inside_int)
        cmds.append("vlan " + inside_vlan)
        outside_int = params.get('intf_out') + '.' + outside_vlan
        cmds.append("int " + outside_int)
        cmds.append("vlan " + outside_vlan)
        cmds.append("context " + context)
        cmds.append("allocate-interface " + inside_int)
        cmds.append("allocate-interface " + outside_int)
        cmds.append("config-url disk0:/" + context + ".cfg")
        cmds.append("write memory")
        cmds.append("changeto context " + context)
        cmds.append("int " + inside_int)
        cmds.append("nameif Inside")
        cmds.append("security-level 100")
        cmds.append(
            "ip address " + params.get('in_ip') + " " + params.get('in_mask'))
        cmds.append("int " + outside_int)
        cmds.append("nameif Outside")
        cmds.append("security-level 0")
        cmds.append("ip address " + params.get('out_ip') + " " +
                    params.get('out_mask'))

        cmds.append("router ospf 1")
        cmds.append("network " + params.get('in_ip') + " " +
                    params.get('in_mask') + " area 0")
        cmds.append("network " + params.get('out_ip') + " " +
                    params.get('out_mask') + " area 0")
        cmds.append("area 0")
        cmds.append("route Outside 0.0.0.0 0.0.0.0 " + params.get('out_gw') +
                    " 1")
        cmds.append("route Outside 0.0.0.0 0.0.0.0 " +
                    params.get('out_sec_gw') + " 1")
        cmds.append("end")
        cmds.append("write memory")

        if context not in self.tenant_rule:
            self.tenant_rule[context] = dict()
            self.tenant_rule[context]['rule_lst'] = []

        data = {"commands": cmds}
        return self.rest_send_cli(data)

Response: setup ASA context for an edge tenant pair.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def cleanup(self, **kwargs):
        params = kwargs.get('params')
        LOG.info("asa_cleanup: tenant %(tenant)s %(in_vlan)d %(out_vlan)d"
                 " %(in_ip)s %(in_mask)s %(out_ip)s %(out_mask)s",
                 {'tenant': params.get('tenant_name'),
                  'in_vlan': params.get('in_vlan'),
                  'out_vlan': params.get('out_vlan'),
                  'in_ip': params.get('in_ip'),
                  'in_mask': params.get('in_mask'),
                  'out_ip': params.get('out_ip'),
                  'out_mask': params.get('out_mask')})
        inside_vlan = str(params.get('in_vlan'))
        outside_vlan = str(params.get('out_vlan'))
        context = params.get('tenant_name')
        cmds = ["conf t", "changeto system"]
        cmds.append("no context " + context + " noconfirm")
        inside_int = params.get('intf_in') + '.' + inside_vlan
        outside_int = params.get('intf_out') + '.' + outside_vlan
        cmds.append("no interface " + inside_int)
        cmds.append("no interface " + outside_int)
        cmds.append("write memory")
        cmds.append("del /noconfirm disk0:/" + context + ".cfg")

        if context in self.tenant_rule:
            for rule in self.tenant_rule[context].get('rule_lst'):
                del self.rule_tbl[rule]
            del self.tenant_rule[context]
        data = {"commands": cmds}
        return self.rest_send_cli(data)

Response: cleanup ASA context for an edge tenant pair.


Instruction:
How would you implement a function in Python 3 that
builds the acl for IP address.

Response:
def build_acl_ip(self, network_obj):
        "Build the acl for IP address. "

        if str(network_obj) == '0.0.0.0/0':
            acl = "any "
        else:
            acl = "%(ip)s %(mask)s " % {'ip': network_obj.network,
                                        'mask': network_obj.netmask}
        return acl


Instruction:
Can you write a function in Python 3 where it
builds the acl for L4 Ports.

Response:
def build_acl_port(self, port, enabled=True):
        "Build the acl for L4 Ports. "
        if port is not None:
            if ':' in port:
                range = port.replace(':', ' ')
                acl = "range %(range)s " % {'range': range}
            else:
                acl = "eq %(port)s " % {'port': port}
                if not enabled:
                    acl += "inactive"
            return acl


Instruction:
Implement a Python 3 function for
applying a firewall policy to the current ASA context.

Response:
def apply_policy(self, policy):
        """Apply a firewall policy. """
        tenant_name = policy['tenant_name']
        fw_id = policy['fw_id']
        fw_name = policy['fw_name']
        LOG.info("asa_apply_policy: tenant=%(tenant)s fw_id=%(fw_id)s "
                 "fw_name=%(fw_name)s",
                 {'tenant': tenant_name, 'fw_id': fw_id, 'fw_name': fw_name})
        cmds = ["conf t", "changeto context " + tenant_name]

        for rule_id, rule in policy['rules'].items():
            acl = self.build_acl(tenant_name, rule)

            LOG.info("rule[%(rule_id)s]: name=%(name)s enabled=%(enabled)s"
                     " protocol=%(protocol)s dport=%(dport)s "
                     "sport=%(sport)s dip=%(dport)s "
                     "sip=%(sip)s action=%(dip)s",
                     {'rule_id': rule_id, 'name': rule.get('name'),
                      'enabled': rule.get('enabled'),
                      'protocol': rule.get('protocol'),
                      'dport': rule.get('dst_port'),
                      'sport': rule.get('src_port'),
                      'dip': rule.get('destination_ip_address'),
                      'sip': rule.get('source_ip_address'),
                      'action': rule.get('action')})

            # remove the old ace for this rule
            if rule_id in self.rule_tbl:
                cmds.append('no ' + self.rule_tbl[rule_id])

            self.rule_tbl[rule_id] = acl
            if tenant_name in self.tenant_rule:
                if rule_id not in self.tenant_rule[tenant_name]['rule_lst']:
                    self.tenant_rule[tenant_name]['rule_lst'].append(rule_id)
            cmds.append(acl)
        cmds.append("access-group " + tenant_name + " global")
        cmds.append("write memory")

        LOG.info("cmds sent is %s", cmds)
        data = {"commands": cmds}
        return self.rest_send_cli(data)


Instruction:
How would you explain what the following Python 3 function does
def _flow_check_handler(self):
        LOG.info("In _flow_check_handler")
        try:
            with self.ovs_vdp_lock:
                self._flow_check_handler_internal()
        except Exception as e:
            LOG.error("Exception in _flow_check_handler_internal %s",
                      str(e))

Response: Top level routine to check OVS flow consistency.


Instruction:
Write a Python 3 function that can
generate a veth string.

Response:
def gen_veth_str(self, const_str, intf_str):
        """Generate a veth string.

        Concatenates the constant string with remaining available length
        of interface string from trailing position.
        """
        avl_len = constants.MAX_VETH_NAME - len(const_str)
        if avl_len <= 0:
            LOG.error("veth string name too short")
            raise dfae.DfaAgentFailed(reason="Veth Unavailable")
        start_pos = len(intf_str) - avl_len
        veth_str = const_str + intf_str[start_pos:]
        return veth_str


Instruction:
Create a Python 3 function to
find the internal veth or patch ports.

Response:
def find_interconnect_ports(self):
        """Find the internal veth or patch ports. """

        phy_port_list = self.ext_br_obj.get_port_name_list()
        int_port_list = self.integ_br_obj.get_port_name_list()
        for port in phy_port_list:
            # Use get Interface  xxx type
            is_patch = ovs_lib.is_patch(self.root_helper, port)
            if is_patch:
                # Get the peer for this patch
                peer_port = ovs_lib.get_peer(self.root_helper, port)
                if peer_port in int_port_list:
                    return port, peer_port
        # A solution is needed for veth pairs also, fixme(padkrish)
        # ip_wrapper.get_devices() returns all the devices
        # Pick the ones whose type is veth (?) and get the other pair
        # Combination of "ethtool -S xxx" command and "ip tool" command.
        return None, None


Instruction:
Can you tell what is the following Python 3 function doing
def send_vdp_port_event_internal(self, port_uuid, mac, net_uuid,
                                     segmentation_id, status, oui):
        """Send vNIC UP/Down event to VDP.

        :param port_uuid: a ovslib.VifPort object.
        :mac: MAC address of the VNIC
        :param net_uuid: the net_uuid this port is to be associated with.
        :param segmentation_id: the VID for 'vlan' or tunnel ID for 'tunnel'
        :param status: Type of port event. 'up' or 'down'
        :oui: OUI Parameters
        """
        lldpad_port = self.lldpad_info
        if not lldpad_port:
            fail_reason = "There is no LLDPad port available."
            LOG.error("%s", fail_reason)
            return {'result': False, 'fail_reason': fail_reason}

        if status == 'up':
            if self.vdp_mode == constants.VDP_SEGMENT_MODE:
                port_name = self.ext_br_obj.get_ofport_name(port_uuid)
                if port_name is None:
                    fail_reason = "Unknown portname for uuid %s" % (port_uuid)
                    LOG.error("%s", fail_reason)
                    return {'result': False, 'fail_reason': fail_reason}
                LOG.info("Status up: portname for uuid %(uuid)s is %(port)s",
                         {'uuid': port_uuid, 'port': port_name})
                ret = self.port_up_segment_mode(lldpad_port, port_name,
                                                port_uuid, mac, net_uuid,
                                                segmentation_id, oui)
        else:
            if self.vdp_mode == constants.VDP_SEGMENT_MODE:
                LOG.info("Status down for portname uuid %s", port_uuid)
                ret = self.port_down_segment_mode(lldpad_port, port_uuid,
                                                  mac, net_uuid,
                                                  segmentation_id, oui)
        return ret

Response: Send a VDP UP or DOWN event to the VDP.


Instruction:
How would you explain what the following Python 3 function does
def send_vdp_port_event(self, port_uuid, mac, net_uuid,
                            segmentation_id, status, oui):
        """Send vNIC UP/Down event to VDP.

        :param port: a ovslib.VifPort object.
        :param net_uuid: the net_uuid this port is to be associated with.
        :param segmentation_id: the VID for 'vlan' or tunnel ID for 'tunnel'
        :param status: Type of port event. 'up' or 'down'
        """
        try:
            with self.ovs_vdp_lock:
                ret = self.send_vdp_port_event_internal(port_uuid, mac,
                                                        net_uuid,
                                                        segmentation_id,
                                                        status, oui)
                return ret
        except Exception as e:
            LOG.error("Exception in send_vdp_port_event %s" % str(e))
            return {'result': False, 'fail_reason': str(e)}

Response: Send a vNIC UP or Down event to VDP.


Instruction:
Can you generate the documentation for the following Python 3 function
def get_lvid_vdp_vlan(self, net_uuid, port_uuid):

        lvm = self.local_vlan_map.get(net_uuid)
        if not lvm:
            LOG.error("lvm not yet created, get_lvid_vdp_lan "
                      "return error")
            return cconstants.INVALID_VLAN, cconstants.INVALID_VLAN
        vdp_vlan = lvm.get_portid_vlan(port_uuid)
        lvid = lvm.lvid
        LOG.info("Return from lvid_vdp_vlan lvid %(lvid)s vdp_vlan %(vdp)s",
                 {'lvid': lvid, 'vdp': vdp_vlan})
        return lvid, vdp_vlan

Response: Retrieve the Local Vlan ID and VDP VLAN.


Instruction:
Can you generate the documentation for the following Python 3 function
def vdp_vlan_change_internal(self, vsw_cb_data, vdp_vlan, fail_reason):
        LOG.debug("In VDP VLAN change VLAN %s", vdp_vlan)
        if not vsw_cb_data:
            LOG.error("NULL vsw_cb_data Info received")
            return
        net_uuid = vsw_cb_data.get('net_uuid')
        port_uuid = vsw_cb_data.get('port_uuid')
        lvm = self.local_vlan_map.get(net_uuid)
        if not lvm:
            LOG.error("Network %s is not in the local vlan map", net_uuid)
            return
        lldpad_port = self.lldpad_info
        if not lldpad_port:
            LOG.error("There is no LLDPad port available.")
            return
        exist_vdp_vlan = lvm.late_binding_vlan
        lvid = lvm.vlan
        LOG.debug("lvid %(lvid)s exist %(vlan)s",
                  {'lvid': lvid, 'vlan': exist_vdp_vlan})
        lvm.decr_reset_vlan(port_uuid, vdp_vlan)
        lvm.set_fail_reason(port_uuid, fail_reason)
        self.vdp_vlan_cb(port_uuid, lvid, vdp_vlan, fail_reason)
        if vdp_vlan == exist_vdp_vlan:
            LOG.debug("No change in provider VLAN %s", vdp_vlan)
            return
        # Logic is if the VLAN changed to 0, clear the flows only if none of
        # the VM's in the network has a valid VLAN.
        if not ovs_lib.is_valid_vlan_tag(vdp_vlan):
            if ovs_lib.is_valid_vlan_tag(exist_vdp_vlan) and not (
               lvm.any_valid_vlan()):
                # Clear the old flows
                LOG.debug("Clearing flows, no valid vlans")
                self.program_vm_ovs_flows(lvid, exist_vdp_vlan, 0)
                lvm.late_binding_vlan = 0
            lvm.vdp_nego_req = False
        else:
            # If any VM gets a VLAN change, we immediately modify the flow.
            # This is done to not wait for all VM's VLAN getting updated from
            # switch. Logic is if any VM gts a new VLAN, the other VM's of the
            # same network will be updated eventually.
            if vdp_vlan != exist_vdp_vlan and (
               ovs_lib.is_valid_vlan_tag(vdp_vlan)):
                # Add the new flows and remove the old flows
                LOG.warning("Non Zero VDP Vlan change %s %s" %
                            (vdp_vlan, exist_vdp_vlan))
                self.program_vm_ovs_flows(lvid, exist_vdp_vlan, vdp_vlan)
                lvm.late_binding_vlan = vdp_vlan
                lvm.vdp_nego_req = False
            else:
                LOG.error("Invalid or same VLAN Exist %(exist)s "
                          "New %(new)s VLANs",
                          {'exist': exist_vdp_vlan, 'new': vdp_vlan})

Response: Internal function to update the local vlan map.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def provision_vdp_overlay_networks(self, port_uuid, mac, net_uuid,
                                       segmentation_id, lvid, oui):
        """Provisions a overlay type network configured using VDP.

        :param port_uuid: the uuid of the VM port.
        :param mac: the MAC address of the VM.
        :param net_uuid: the uuid of the network associated with this vlan.
        :param segmentation_id: the VID for 'vlan' or tunnel ID for 'tunnel'
        :lvid: Local VLAN ID
        :oui: OUI Parameters
        """
        lldpad_port = self.lldpad_info
        if lldpad_port:
            ovs_cb_data = {'obj': self, 'port_uuid': port_uuid, 'mac': mac,
                           'net_uuid': net_uuid}
            vdp_vlan, fail_reason = lldpad_port.send_vdp_vnic_up(
                port_uuid=port_uuid, vsiid=port_uuid, gid=segmentation_id,
                mac=mac, new_network=True, oui=oui,
                vsw_cb_fn=self.vdp_vlan_change, vsw_cb_data=ovs_cb_data)
        else:
            fail_reason = "There is no LLDPad port available."
            LOG.error("%s", fail_reason)
            return {'result': False, 'vdp_vlan': cconstants.INVALID_VLAN,
                    'fail_reason': fail_reason}
        # check validity
        if not ovs_lib.is_valid_vlan_tag(vdp_vlan):
            LOG.error("Cannot provision VDP Overlay network for"
                      " net-id=%(net_uuid)s - Invalid ",
                      {'net_uuid': net_uuid})
            return {'result': True, 'vdp_vlan': cconstants.INVALID_VLAN,
                    'fail_reason': fail_reason}

        LOG.info('provision_vdp_overlay_networks: add_flow for '
                 'Local Vlan %(local_vlan)s VDP VLAN %(vdp_vlan)s',
                 {'local_vlan': lvid, 'vdp_vlan': vdp_vlan})
        self.program_vm_ovs_flows(lvid, 0, vdp_vlan)
        return {'result': True, 'vdp_vlan': vdp_vlan, 'fail_reason': None}

Response: Provisions a overlay type network for a given local vlan.


Instruction:
How would you explain what the following Python 3 function does
def pop_local_cache(self, port_uuid, mac, net_uuid, lvid, vdp_vlan,
                        segmentation_id):
        """Populate the local cache after restart. """

        LOG.info("Populating the OVS VDP cache with port %(port_uuid)s, "
                 "mac %(mac)s net %(net_uuid)s lvid %(lvid)s vdpvlan "
                 "%(vdp_vlan)s seg %(seg)s",
                 {'port_uuid': port_uuid, 'mac': mac, 'net_uuid': net_uuid,
                  'lvid': lvid, 'vdp_vlan': vdp_vlan, 'seg': segmentation_id})
        lvm = self.local_vlan_map.get(net_uuid)
        if not lvm:
            lvm = LocalVlan(lvid, segmentation_id)
            self.local_vlan_map[net_uuid] = lvm
        lvm.lvid = lvid
        lvm.set_port_uuid(port_uuid, vdp_vlan, None)
        if vdp_vlan != cconstants.INVALID_VLAN:
            lvm.late_binding_vlan = vdp_vlan
            lvm.vdp_nego_req = False

Response: Populate the local cache after restart.


Instruction:
How would you implement a function in Python 3 that
stores the dummy router attributes.

Response:
def store_dummy_router_net(self, net_id, subnet_id, rtr_id):
        """Storing the router attributes. """
        self.dummy_net_id = net_id
        self.dummy_subnet_id = subnet_id
        self.dummy_router_id = rtr_id


Instruction:
Can you generate the documentation for the following Python 3 function
def store_dcnm_net_dict(self, net_dict, direc):
        if direc == 'in':
            self.in_dcnm_net_dict = net_dict
        else:
            self.out_dcnm_net_dict = net_dict

Response: Stores the DCNM net dict.


Instruction:
Make a summary of the following Python 3 code
def _parse_subnet(self, subnet_dict):
        if not subnet_dict:
            return
        alloc_pool = subnet_dict.get('allocation_pools')
        cidr = subnet_dict.get('cidr')
        subnet = cidr.split('/')[0]
        start = alloc_pool[0].get('start')
        end = alloc_pool[0].get('end')
        gateway = subnet_dict.get('gateway_ip')
        sec_gateway = subnet_dict.get('secondary_gw')
        return {'subnet': subnet, 'start': start, 'end': end,
                'gateway': gateway, 'sec_gateway': sec_gateway}

Response: Parse a subnet dictionary into a dict of start end gateway and sec_gateway.


Instruction:
Make a summary of the following Python 3 code
def store_dcnm_subnet_dict(self, subnet_dict, direc):
        if direc == 'in':
            self.in_dcnm_subnet_dict = subnet_dict
            self.in_subnet_dict = self._parse_subnet(subnet_dict)
        else:
            self.out_dcnm_subnet_dict = subnet_dict
            self.out_subnet_dict = self._parse_subnet(subnet_dict)

Response: Store the subnet attributes and dict.


Instruction:
Write a Python 3 script to
delete the FW dict and its attributes.

Response:
def destroy_local_fw_db(self):
        """Delete the FW dict and its attributes. """
        del self.fw_dict
        del self.in_dcnm_net_dict
        del self.in_dcnm_subnet_dict
        del self.out_dcnm_net_dict
        del self.out_dcnm_subnet_dict


Instruction:
Here you have a function in Python 3, explain what it does
def update_fw_local_cache(self, net, direc, start):
        fw_dict = self.get_fw_dict()
        if direc == 'in':
            fw_dict.update({'in_network_id': net, 'in_service_ip': start})
        else:
            fw_dict.update({'out_network_id': net, 'out_service_ip': start})
        self.update_fw_dict(fw_dict)

Response: Update the local cache with Net ID and service IP.


Instruction:
How would you explain what the following Python 3 function does
def update_fw_local_result_str(self, os_result=None, dcnm_result=None,
                                   dev_result=None):
        """Update the FW result in the dict. """
        fw_dict = self.get_fw_dict()
        if os_result is not None:
            fw_dict['os_status'] = os_result
        if dcnm_result is not None:
            fw_dict['dcnm_status'] = dcnm_result
        if dev_result is not None:
            fw_dict['dev_status'] = dev_result
        self.update_fw_dict(fw_dict)

Response: Update the FW result in the dict.


Instruction:
Write a Python 3 function for
retrieving and update the FW result in the dict.

Response:
def update_fw_local_result(self, os_result=None, dcnm_result=None,
                               dev_result=None):
        """Retrieve and update the FW result in the dict. """
        self.update_fw_local_result_str(os_result=os_result,
                                        dcnm_result=dcnm_result,
                                        dev_result=dev_result)


Instruction:
Here you have a function in Python 3, explain what it does
def update_fw_local_router(self, net_id, subnet_id, router_id, os_result):
        fw_dict = self.get_fw_dict()
        fw_dict.update({'router_id': router_id, 'router_net_id': net_id,
                        'router_subnet_id': subnet_id})
        self.store_dummy_router_net(net_id, subnet_id, router_id)
        self.update_fw_local_result(os_result=os_result)

Response: Update the FW with router attributes.


Instruction:
Make a summary of the following Python 3 code
def commit_fw_db(self):
        fw_dict = self.get_fw_dict()
        self.update_fw_db(fw_dict.get('fw_id'), fw_dict)

Response: Calls routine to update the FW DB.


Instruction:
Create a Python 3 function to
call routine to update the FW create or delete result in DB.

Response:
def commit_fw_db_result(self):
        """Calls routine to update the FW create/delete result in DB. """
        fw_dict = self.get_fw_dict()
        self.update_fw_db_result(fw_dict.get('fw_id'), fw_dict)


Instruction:
Given the following Python 3 function, write the documentation
def get_store_local_final_result(self):
        fw_dict = self.get_fw_dict()
        fw_data, fw_data_dict = self.get_fw(fw_dict.get('fw_id'))
        res = fw_data.result
        self.store_local_final_result(res)

Response:
Store the final result for FW create or delete from DB and store it
        locally.


Instruction:
Create a Python 3 function to
store the state of the FW create or delete operation.

Response:
def store_state(self, state, popl_db=True):
        """Store the state of FW create/del operation. """
        self.state = state
        if popl_db:
            fw_dict = self.get_fw_dict()
            self.append_state_final_result(fw_dict.get('fw_id'),
                                           self.get_local_final_result(),
                                           state)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def fixup_state(self, from_str, state):
        result = self.get_local_final_result()
        if from_str == fw_const.FW_CR_OP:
            if result == fw_const.RESULT_FW_DELETE_INIT:
                return state + 1
        if from_str == fw_const.FW_DEL_OP:
            if result == fw_const.RESULT_FW_CREATE_INIT:
                return state - 1
        return state

Response: Fixup the state after retart.


Instruction:
Explain what the following Python 3 code does
def store_db_obj(cls, in_obj, out_obj):
        cls.ip_db_obj['in'] = in_obj
        cls.ip_db_obj['out'] = out_obj

Response: Store the IP DB object.


Instruction:
How would you code a function in Python 3 to
retrieve the in service subnet attributes.

Response:
def get_in_ip_addr(cls, tenant_id):
        """Retrieves the 'in' service subnet attributes. """
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        return tenant_obj.get_in_ip_addr()


Instruction:
Here you have a function in Python 3, explain what it does
def get_out_ip_addr(cls, tenant_id):
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        return tenant_obj.get_out_ip_addr()

Response: Retrieves the out service subnet attributes.


Instruction:
Make a summary of the following Python 3 code
def get_in_srvc_node_ip_addr(cls, tenant_id):
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        in_subnet_dict = tenant_obj.get_in_ip_addr()
        next_hop = str(netaddr.IPAddress(in_subnet_dict.get('subnet')) + 2)
        return next_hop

Response: Retrieves the IN service node IP address.


Instruction:
Can you tell what is the following Python 3 function doing
def get_out_srvc_node_ip_addr(cls, tenant_id):
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        out_subnet_dict = tenant_obj.get_out_ip_addr()
        next_hop = str(netaddr.IPAddress(out_subnet_dict.get('subnet')) + 2)
        return next_hop

Response: Retrieves the OUT service node IP address.


Instruction:
Here you have a function in Python 3, explain what it does
def get_dummy_router_net(cls, tenant_id):
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        return tenant_obj.get_dummy_router_net()

Response: Retrieves the dummy router network info.


Instruction:
Implement a function in Python 3 to
retrieve the IN Seg VLAN and mob domain.

Response:
def get_in_seg_vlan(cls, tenant_id):
        """Retrieves the IN Seg, VLAN, mob domain. """
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return None, None
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        return tenant_obj.get_in_seg_vlan()


Instruction:
Create a Python 3 function to
retrieve the OUT Seg VLAN and mob domain.

Response:
def get_out_seg_vlan(cls, tenant_id):
        """Retrieves the OUT Seg, VLAN, mob domain. """
        if tenant_id not in cls.serv_obj_dict:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return None, None
        tenant_obj = cls.serv_obj_dict.get(tenant_id)
        return tenant_obj.get_out_seg_vlan()


Instruction:
Can you tell what is the following Python 3 function doing
def get_in_subnet_id(cls, tenant_id):
        if 'in' not in cls.ip_db_obj:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return None
        db_obj = cls.ip_db_obj.get('in')
        in_subnet_dict = cls.get_in_ip_addr(tenant_id)
        sub = db_obj.get_subnet(in_subnet_dict.get('subnet'))
        return sub.subnet_id

Response: Retrieve the subnet ID of IN network.


Instruction:
Implement a Python 3 function for
retrieving the subnet ID of OUT network.

Response:
def get_out_subnet_id(cls, tenant_id):
        """Retrieve the subnet ID of OUT network. """
        if 'out' not in cls.ip_db_obj:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return None
        db_obj = cls.ip_db_obj.get('out')
        out_subnet_dict = cls.get_out_ip_addr(tenant_id)
        sub = db_obj.get_subnet(out_subnet_dict.get('subnet'))
        return sub.subnet_id


Instruction:
Can you implement a function in Python 3 that
retrieves the network ID of IN network.

Response:
def get_in_net_id(cls, tenant_id):
        """Retrieve the network ID of IN network. """
        if 'in' not in cls.ip_db_obj:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return None
        db_obj = cls.ip_db_obj.get('in')
        in_subnet_dict = cls.get_in_ip_addr(tenant_id)
        sub = db_obj.get_subnet(in_subnet_dict.get('subnet'))
        return sub.network_id


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_out_net_id(cls, tenant_id):
        if 'out' not in cls.ip_db_obj:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return None
        db_obj = cls.ip_db_obj.get('out')
        out_subnet_dict = cls.get_out_ip_addr(tenant_id)
        sub = db_obj.get_subnet(out_subnet_dict.get('subnet'))
        return sub.network_id

Response: Retrieve the network ID of OUT network.


Instruction:
Write a Python 3 script to
check if SOURCE is FIREWALL.

Response:
def is_network_source_fw(cls, nwk, nwk_name):
        """Check if SOURCE is FIREWALL, if yes return TRUE.

        If source is None or entry not in NWK DB, check from Name.
        Name should have constant AND length should match.
        """
        if nwk is not None:
            if nwk.source == fw_const.FW_CONST:
                return True
            return False
        if nwk_name in fw_const.DUMMY_SERVICE_NWK and (
           len(nwk_name) == len(fw_const.DUMMY_SERVICE_NWK) +
           fw_const.SERVICE_NAME_EXTRA_LEN):
            return True
        if nwk_name in fw_const.IN_SERVICE_NWK and (
           len(nwk_name) == len(fw_const.IN_SERVICE_NWK) +
           fw_const.SERVICE_NAME_EXTRA_LEN):
            return True
        if nwk_name in fw_const.OUT_SERVICE_NWK and (
           len(nwk_name) == len(fw_const.OUT_SERVICE_NWK) +
           fw_const.SERVICE_NAME_EXTRA_LEN):
            return True
        return False


Instruction:
Make a summary of the following Python 3 code
def is_subnet_source_fw(cls, tenant_id, subnet):
        cfg = config.CiscoDFAConfig().cfg
        subnet = subnet.split('/')[0]
        in_sub_dict = cls.get_in_ip_addr(tenant_id)
        if not in_sub_dict:
            return False
        if in_sub_dict.get('subnet') == subnet:
            return True
        out_sub_dict = cls.get_out_ip_addr(tenant_id)
        if not out_sub_dict:
            return False
        if out_sub_dict.get('subnet') == subnet:
            return True
        dummy_sub = cfg.firewall.fw_service_dummy_ip_subnet
        dummy_sub = dummy_sub.split('/')[0]
        return subnet == dummy_sub

Response: Check if the subnet is created as a result of any FW operation.


Instruction:
Write a Python 3 script for
initializing the Finite State Machine.

Response:
def initialize_fsm(self):
        """Initializing the Finite State Machine.

        This is a mapping of state to a dict of appropriate create and delete
        functions.
        """
        self.fabric_fsm = {
            fw_const.INIT_STATE:
                [self.init_state, self.init_state],
            fw_const.OS_IN_NETWORK_STATE:
                [self.create_os_in_nwk, self.delete_os_in_nwk],
            fw_const.OS_OUT_NETWORK_STATE:
                [self.create_os_out_nwk, self.delete_os_out_nwk],
            fw_const.OS_DUMMY_RTR_STATE:
                [self.create_os_dummy_rtr, self.delete_os_dummy_rtr],
            fw_const.DCNM_IN_NETWORK_STATE:
                [self.create_dcnm_in_nwk, self.delete_dcnm_in_nwk],
            fw_const.DCNM_IN_PART_UPDATE_STATE:
                [self.update_dcnm_in_part, self.clear_dcnm_in_part],
            fw_const.DCNM_OUT_PART_STATE:
                [self.create_dcnm_out_part, self.delete_dcnm_out_part],
            fw_const.DCNM_OUT_NETWORK_STATE:
                [self.create_dcnm_out_nwk, self.delete_dcnm_out_nwk],
            fw_const.DCNM_OUT_PART_UPDATE_STATE:
                [self.update_dcnm_out_part, self.clear_dcnm_out_part],
            fw_const.FABRIC_PREPARE_DONE_STATE:
                [self.prepare_fabric_done, self.prepare_fabric_done]}


Instruction:
Create a Python 3 function to
create and stores the service object associated with a tenant.

Response:
def create_serv_obj(self, tenant_id):
        """Creates and stores the service object associated with a tenant. """
        self.service_attr[tenant_id] = ServiceIpSegTenantMap()
        self.store_tenant_obj(tenant_id, self.service_attr[tenant_id])


Instruction:
How would you explain what the following Python 3 function does
def delete_serv_obj(self, tenant_id):
        self.del_obj(tenant_id, self.service_attr[tenant_id])
        del self.service_attr[tenant_id]

Response: Creates and stores the service object associated with a tenant.


Instruction:
Make a summary of the following Python 3 code
def store_net_db(self, tenant_id, net, net_dict, result):
        network_dict = {'name': net_dict.get('name'),
                        'config_profile': net_dict.get('config_profile'),
                        'segmentation_id': net_dict.get('segmentation_id'),
                        'tenant_id': tenant_id,
                        'fwd_mode': net_dict.get('fwd_mode'),
                        'vlan': net_dict.get('vlan_id')}
        self.add_network_db(net, network_dict, fw_const.FW_CONST, result)

Response: Store service network in DB.


Instruction:
Can you implement a function in Python 3 that
calls the service object routine to update the FW entry to DB.

Response:
def store_fw_db(self, tenant_id, net, subnet_dict, direc):
        """Calls the service object routine to commit the FW entry to DB. """
        serv_obj = self.get_service_obj(tenant_id)
        sub = subnet_dict.get('allocation_pools')[0].get('start')
        serv_obj.update_fw_local_cache(net, direc, sub)
        serv_obj.commit_fw_db()


Instruction:
Can you generate a brief explanation for the following Python 3 code
def update_fw_db_result(self, tenant_id, os_status=None, dcnm_status=None,
                            dev_status=None):
        """Update the FW DB Result and commit it in DB.

        Calls the service object routine to commit the result of a FW
        operation in to DB
        """
        serv_obj = self.get_service_obj(tenant_id)
        serv_obj.update_fw_local_result(os_status, dcnm_status, dev_status)
        serv_obj.commit_fw_db_result()

Response: Update the FW DB Result and commit it in DB.


Instruction:
Can you write a function in Python 3 where it
stores the result of FW router operation in DB.

Response:
def store_fw_db_router(self, tenant_id, net_id, subnet_id, router_id,
                           os_status):
        """Store the result of FW router operation in DB.

        Calls the service object routine to commit the result of router
        operation in to DB, after updating the local cache.
        """
        serv_obj = self.get_service_obj(tenant_id)
        serv_obj.update_fw_local_router(net_id, subnet_id, router_id,
                                        os_status)
        serv_obj.commit_fw_db()
        serv_obj.commit_fw_db_result()


Instruction:
Implement a Python 3 function for
storing the entries in Network and Firewall DB and update the result of operation into FW DB.

Response:
def store_net_fw_db(self, tenant_id, net, net_dict, subnet_dict,
                        direc, result, os_status=None, dcnm_status=None,
                        dev_status=None):
        """Save the entries in Network and Firewall DB.

        Stores the entries into Network DB and Firewall DB as well as update
        the result of operation into FWDB. Generally called by OS operations
        that wants to modify both the Net DB and FW DB.
        """
        self.store_net_db(tenant_id, net, net_dict, result)
        self.store_fw_db(tenant_id, net, subnet_dict, direc)
        self.update_fw_db_result(tenant_id, os_status=os_status,
                                 dcnm_status=dcnm_status,
                                 dev_status=dev_status)


Instruction:
Make a summary of the following Python 3 code
def check_allocate_ip(self, obj, direc):
        subnet_lst = self.os_helper.get_all_subnets_cidr(no_mask=True)
        ip_next = obj.allocate_subnet(subnet_lst)
        if ip_next is None:
            LOG.error("Unable to allocate a subnet for direction %s",
                      direc)
        return ip_next

Response: This function allocates a subnet from the pool. It checks to see if the subnet is already allocated by Openstack. If it is not it tries to find a free subnet from the pool.


Instruction:
Create a Python 3 function for
retrieving the next available subnet. Given a tenant it returns the next available subnet.

Response:
def get_next_ip(self, tenant_id, direc):
        """Retrieve the next available subnet.

        Given a tenant, it returns the service subnet values assigned
        to it based on direction.
        """
        # TODO(padkrish) Put in a common functionality for services.
        if direc == 'in':
            subnet_dict = self.get_in_ip_addr(tenant_id)
        else:
            subnet_dict = self.get_out_ip_addr(tenant_id)
        if subnet_dict:
            return subnet_dict
        if direc == 'in':
            # ip_next = self.service_in_ip.allocate_subnet()
            ip_next = self.check_allocate_ip(self.service_in_ip, "in")
        else:
            # ip_next = self.service_out_ip.allocate_subnet()
            ip_next = self.check_allocate_ip(self.service_out_ip, "out")
        return {'subnet': ip_next, 'start': self.get_start_ip(ip_next),
                'end': self.get_end_ip(ip_next),
                'gateway': self.get_gateway(ip_next),
                'sec_gateway': self.get_secondary_gateway(ip_next)}


Instruction:
How would you explain what the following Python 3 function does
def release_subnet(self, cidr, direc):
        if direc == 'in':
            self.service_in_ip.release_subnet(cidr)
        else:
            self.service_out_ip.release_subnet(cidr)

Response: Routine to release a subnet from the DB.


Instruction:
Can you create a Python 3 function that
fills the DCNM subnet parameters.

Response:
def fill_dcnm_subnet_info(self, tenant_id, subnet, start, end, gateway,
                              sec_gateway, direc):
        """Fills the DCNM subnet parameters.

        Function that fills the subnet parameters for a tenant required by
        DCNM.
        """
        serv_obj = self.get_service_obj(tenant_id)
        fw_dict = serv_obj.get_fw_dict()
        fw_id = fw_dict.get('fw_id')
        if direc == 'in':
            name = fw_id[0:4] + fw_const.IN_SERVICE_SUBNET + (
                fw_id[len(fw_id) - 4:])
        else:
            name = fw_id[0:4] + fw_const.OUT_SERVICE_SUBNET + (
                fw_id[len(fw_id) - 4:])
        subnet_dict = {'enable_dhcp': False,
                       'tenant_id': tenant_id,
                       'name': name,
                       'cidr': subnet + '/24',
                       'gateway_ip': gateway,
                       'secondary_gw': sec_gateway,
                       'ip_version': 4}
        subnet_dict['allocation_pools'] = [{'start': start, 'end': end}]
        # TODO(padkrish) Network ID and subnet ID are not filled.
        return subnet_dict


Instruction:
How would you code a function in Python 3 to
retrieve the DCNM subnet info for a tenant.

Response:
def retrieve_dcnm_subnet_info(self, tenant_id, direc):
        """Retrieves the DCNM subnet info for a tenant. """
        serv_obj = self.get_service_obj(tenant_id)
        subnet_dict = serv_obj.get_dcnm_subnet_dict(direc)
        return subnet_dict


Instruction:
Explain what the following Python 3 code does
def alloc_retrieve_subnet_info(self, tenant_id, direc):
        serv_obj = self.get_service_obj(tenant_id)
        subnet_dict = self.retrieve_dcnm_subnet_info(tenant_id, direc)
        if subnet_dict:
            return subnet_dict
        ip_subnet_dict = self.get_next_ip(tenant_id, direc)
        subnet_dict = self.fill_dcnm_subnet_info(
            tenant_id, ip_subnet_dict.get('subnet'),
            ip_subnet_dict.get('start'), ip_subnet_dict.get('end'),
            ip_subnet_dict.get('gateway'), ip_subnet_dict.get('sec_gateway'),
            direc)
        serv_obj.store_dcnm_subnet_dict(subnet_dict, direc)
        return subnet_dict

Response: Allocate and store Subnet. This routine is called by the DCNM to retrieve the subnet information from the DCNM.


Instruction:
How would you explain what the following Python 3 function does
def retrieve_dcnm_net_info(self, tenant_id, direc):
        serv_obj = self.get_service_obj(tenant_id)
        net_dict = serv_obj.get_dcnm_net_dict(direc)
        return net_dict

Response: Retrieves the DCNM network info for a tenant.


Instruction:
Explain what the following Python 3 code does
def update_dcnm_net_info(self, tenant_id, direc, vlan_id,
                             segmentation_id):
        """Update the DCNM net info with allocated values of seg/vlan. """
        net_dict = self.retrieve_dcnm_net_info(tenant_id, direc)
        if not net_dict:
            return None
        net_dict['vlan_id'] = vlan_id
        if vlan_id != 0:
            net_dict['mob_domain'] = True
        net_dict['segmentation_id'] = segmentation_id
        return net_dict

Response: Update the DCNM net info with allocated values of seg and vlan.


Instruction:
Here you have a function in Python 3, explain what it does
def fill_dcnm_net_info(self, tenant_id, direc, vlan_id=0,
                           segmentation_id=0):
        """Fill DCNM network parameters.

        Function that fills the network parameters for a tenant required by
        DCNM.
        """
        serv_obj = self.get_service_obj(tenant_id)
        fw_dict = serv_obj.get_fw_dict()
        fw_id = fw_dict.get('fw_id')
        net_dict = {'status': 'ACTIVE', 'admin_state_up': True,
                    'tenant_id': tenant_id, 'provider:network_type': 'local',
                    'vlan_id': vlan_id, 'segmentation_id': segmentation_id}
        if vlan_id == 0:
            net_dict.update({'mob_domain': False, 'mob_domain_name': None})
        else:
            net_dict.update({'mob_domain': True})
        # TODO(padkrish) NWK ID are not filled.
        if direc == 'in':
            name = fw_id[0:4] + fw_const.IN_SERVICE_NWK + (
                fw_id[len(fw_id) - 4:])
            net_dict.update({'name': name, 'part_name': None,
                             'config_profile': self.serv_host_prof,
                             'fwd_mode': self.serv_host_mode})
        else:
            name = fw_id[0:4] + fw_const.OUT_SERVICE_NWK + (
                fw_id[len(fw_id) - 4:])
            net_dict.update({'name': name,
                             'part_name': fw_const.SERV_PART_NAME,
                             'config_profile': self.serv_ext_prof,
                             'fwd_mode': self.serv_ext_mode})
        return net_dict

Response: Fill the DCNM network parameters.


Instruction:
How would you implement a function in Python 3 that
retrieves the DCNM Network information. If the dictionary is not already filled it calls fill_dcnm_net_info and store it in tenant obj.

Response:
def retrieve_network_info(self, tenant_id, direc):
        """Retrieve the DCNM Network information.

        Retrieves DCNM net dict if already filled, else, it calls
        routines to fill the net info and store it in tenant obj.
        """
        serv_obj = self.get_service_obj(tenant_id)
        net_dict = self.retrieve_dcnm_net_info(tenant_id, direc)
        if net_dict:
            return net_dict
        net_dict = self.fill_dcnm_net_info(tenant_id, direc)
        serv_obj.store_dcnm_net_dict(net_dict, direc)
        return net_dict


Instruction:
Implement a Python 3 function for
allocating the segmentation ID.

Response:
def alloc_seg(self, net_id):
        """Allocates the segmentation ID. """
        segmentation_id = self.service_segs.allocate_segmentation_id(
            net_id, source=fw_const.FW_CONST)
        return segmentation_id


Instruction:
Create a Python 3 function to
allocate the vlan ID.

Response:
def alloc_vlan(self, net_id):
        """Allocates the vlan ID. """
        vlan_id = self.service_vlans.allocate_segmentation_id(
            net_id, source=fw_const.FW_CONST)
        return vlan_id


Instruction:
Can you generate a brief explanation for the following Python 3 code
def update_subnet_db_info(self, tenant_id, direc, net_id, subnet_id):
        subnet_dict = self.retrieve_dcnm_subnet_info(tenant_id, direc)
        if not subnet_dict:
            LOG.error("Subnet dict not found for tenant %s", tenant_id)
            return
        subnet = subnet_dict['cidr'].split('/')[0]
        if direc == 'in':
            self.service_in_ip.update_subnet(subnet, net_id, subnet_id)
        else:
            self.service_out_ip.update_subnet(subnet, net_id, subnet_id)

Response: Update the subnet DB with Net and Subnet ID given the subnet.


Instruction:
Given the following Python 3 function, write the documentation
def update_net_info(self, tenant_id, direc, vlan_id, segmentation_id):
        serv_obj = self.get_service_obj(tenant_id)
        net_dict = self.update_dcnm_net_info(tenant_id, direc, vlan_id,
                                             segmentation_id)
        serv_obj.store_dcnm_net_dict(net_dict, direc)
        return net_dict

Response: Update the DCNM netinfo with vlan and segmentation ID.


Instruction:
Write a Python 3 script for
functioning to create the service in network in DCNM.

Response:
def _create_service_nwk(self, tenant_id, tenant_name, direc):
        """Function to create the service in network in DCNM. """
        net_dict = self.retrieve_dcnm_net_info(tenant_id, direc)
        net = utils.Dict2Obj(net_dict)
        subnet_dict = self.retrieve_dcnm_subnet_info(tenant_id, direc)
        subnet = utils.Dict2Obj(subnet_dict)
        try:
            self.dcnm_obj.create_service_network(tenant_name, net, subnet)
        except dexc.DfaClientRequestFailed:
            LOG.error("Failed to create network in DCNM %s", direc)
            return False
        return True


Instruction:
Create a Python 3 function for
functioning to delete the service in network in DCNM.

Response:
def _delete_service_nwk(self, tenant_id, tenant_name, direc):
        """Function to delete the service in network in DCNM. """
        net_dict = {}
        if direc == 'in':
            seg, vlan = self.get_in_seg_vlan(tenant_id)
            net_dict['part_name'] = None
        else:
            seg, vlan = self.get_out_seg_vlan(tenant_id)
            net_dict['part_name'] = fw_const.SERV_PART_NAME
        net_dict['segmentation_id'] = seg
        net_dict['vlan'] = vlan
        net = utils.Dict2Obj(net_dict)
        ret = True
        try:
            self.dcnm_obj.delete_service_network(tenant_name, net)
        except dexc.DfaClientRequestFailed:
            LOG.error("Failed to delete network in DCNM %s", direc)
            ret = False
        return ret


Instruction:
Write a Python 3 function that can
retrieve the dummy router net information from service object.

Response:
def get_dummy_router_net(self, tenant_id):
        """Retrieves the dummy router information from service object. """
        if tenant_id not in self.service_attr:
            LOG.error("Fabric not prepared for tenant %s", tenant_id)
            return
        tenant_obj = self.get_service_obj(tenant_id)
        return tenant_obj.get_dummy_router_net()


Instruction:
Here you have a function in Python 3, explain what it does
def _create_out_partition(self, tenant_id, tenant_name):
        vrf_prof_str = self.serv_part_vrf_prof
        self.dcnm_obj.create_partition(tenant_name, fw_const.SERV_PART_NAME,
                                       None, vrf_prof_str,
                                       desc="Service Partition")

Response: Function to create a service partition.


Instruction:
Can you tell what is the following Python 3 function doing
def _update_partition_srvc_node_ip(self, tenant_name, srvc_ip,
                                       vrf_prof=None, part_name=None):
        """Function to update srvc_node address of partition. """
        self.dcnm_obj.update_project(tenant_name, part_name,
                                     service_node_ip=srvc_ip,
                                     vrf_prof=vrf_prof,
                                     desc="Service Partition")

Response: Function to update srvc_node address of partition.


Instruction:
How would you explain what the following Python 3 function does
def _update_partition_dci_id(self, tenant_name, dci_id,
                                 vrf_prof=None, part_name=None):
        """Function to update DCI ID of partition. """
        self.dcnm_obj.update_project(tenant_name, part_name, dci_id=dci_id,
                                     vrf_prof=vrf_prof)

Response: Function to update DCI ID of partition.


Instruction:
Implement a function in Python 3 to
function to update a partition in create.

Response:
def _update_partition_in_create(self, tenant_id, tenant_name):
        """Function to update a  partition. """
        in_subnet_dict = self.get_in_ip_addr(tenant_id)
        # self._update_partition(tenant_name, in_ip)
        # Need more generic thinking on this one TODO(padkrish)
        next_hop = str(netaddr.IPAddress(in_subnet_dict.get('subnet')) + 2)
        self._update_partition_srvc_node_ip(tenant_name, next_hop)


Instruction:
Write a Python 3 script to
function to update a partition.

Response:
def _update_partition_out_create(self, tenant_id, tenant_name):
        """Function to update a  partition. """
        vrf_prof = self.serv_part_vrf_prof
        seg = self.dcnm_obj.get_partition_segmentId(tenant_name,
                                                    fw_const.SERV_PART_NAME)
        if seg is None:
            return False
        else:
            self._update_partition_dci_id(tenant_name, seg,
                                          vrf_prof=vrf_prof,
                                          part_name=fw_const.SERV_PART_NAME)
            return True


Instruction:
Explain what the following Python 3 code does
def _delete_partition(self, tenant_id, tenant_name):
        self.dcnm_obj.delete_partition(tenant_name, fw_const.SERV_PART_NAME)

Response: Private method to delete a service partition.


Instruction:
Can you generate the documentation for the following Python 3 function
def allocate_seg_vlan(self, net_id, is_fw_virt, direc, tenant_id):
        seg = self.alloc_seg(net_id)
        vlan = 0
        # VLAN allocation is only needed for physical firewall case
        if not is_fw_virt:
            vlan = self.alloc_vlan(net_id)
        # Updating the local cache
        self.update_net_info(tenant_id, direc, vlan, seg)

Response: allocate segmentation ID and VLAN ID.


Instruction:
Can you tell what is the following Python 3 function doing
def _create_os_nwk(self, tenant_id, tenant_name, direc, is_fw_virt=False):
        subnet = self.alloc_retrieve_subnet_info(tenant_id, direc)
        network = self.retrieve_network_info(tenant_id, direc)
        net_id, subnet_id = self.create_openstack_network(subnet, network,
                                                          tenant_id,
                                                          tenant_name, direc)
        if not net_id or not subnet_id:
            return net_id, subnet_id
        self.allocate_seg_vlan(net_id, is_fw_virt, direc, tenant_id)
        self.update_subnet_db_info(tenant_id, direc, net_id, subnet_id)
        return net_id, subnet_id

Response: Function to create Openstack network.


Instruction:
Explain what the following Python 3 code does
def _attach_dummy_intf_rtr(self, tenant_id, tenant_name, rtr_id):
        serv_obj = self.get_service_obj(tenant_id)
        fw_dict = serv_obj.get_fw_dict()
        fw_id = fw_dict.get('fw_id')
        rtr_nwk = fw_id[0:4] + fw_const.DUMMY_SERVICE_NWK + (
            fw_id[len(fw_id) - 4:])
        net_id, subnet_id = self.os_helper.create_network(
            rtr_nwk, tenant_id, self.servicedummy_ip_subnet)
        if net_id is None or subnet_id is None:
            return None, None
        net_dict = {}
        net_dict['name'] = rtr_nwk
        self.store_net_db(tenant_id, net_id, net_dict, 'SUCCESS')
        subnet_lst = set()
        subnet_lst.add(subnet_id)
        if rtr_id is None:
            self.os_helper.delete_network(rtr_nwk, tenant_id, subnet_id,
                                          net_id)
            return None, None
        ret = self.os_helper.add_intf_router(rtr_id, tenant_id, subnet_lst)
        if not ret:
            self.os_helper.delete_network(rtr_nwk, tenant_id, subnet_id,
                                          net_id)
            return None, None
        return net_id, subnet_id

Response: Function to create a dummy router and interface.


Instruction:
Make a summary of the following Python 3 code
def _delete_dummy_intf_rtr(self, tenant_id, tenant_name, rtr_id):
        dummy_router_dict = self.get_dummy_router_net(tenant_id)
        ret = self.delete_os_dummy_rtr_nwk(dummy_router_dict.get('router_id'),
                                           dummy_router_dict.get('net_id'),
                                           dummy_router_dict.get('subnet_id'))
        # Release the network DB entry
        self.delete_network_db(dummy_router_dict.get('net_id'))
        return ret

Response: Function to delete a dummy interface of a router.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def create_os_in_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        tenant_name = fw_dict.get('tenant_name')
        try:
            net, subnet = self._create_os_nwk(tenant_id, tenant_name, "in",
                                              is_fw_virt=is_fw_virt)
            if net is None or subnet is None:
                return False
        except Exception as exc:
            # If Openstack network creation fails, IP address is released.
            # Seg, VLAN creation happens only after network creation in
            # Openstack is successful.
            LOG.error("Creation of In Openstack Network failed tenant "
                      "%(tenant)s, Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            return False
        ret = fw_const.OS_IN_NETWORK_CREATE_SUCCESS
        net_dict = self.retrieve_dcnm_net_info(tenant_id, "in")
        subnet_dict = self.retrieve_dcnm_subnet_info(tenant_id, "in")
        # Very unlikely case, so nothing released.
        if not net_dict or not subnet_dict:
            LOG.error("Allocation of net,subnet failed Len net %(len_net)s"
                      "sub %(len_sub)s",
                      {'len_net': len(net_dict), 'len_sub': len(subnet_dict)})
            ret = fw_const.OS_IN_NETWORK_CREATE_FAIL
        # Updating the FW and Nwk DB
        self.store_net_fw_db(tenant_id, net, net_dict, subnet_dict,
                             "in", 'SUCCESS', os_status=ret)
        return True

Response: Create the Openstack IN network and store the values in DB.


Instruction:
Implement a function in Python 3 to
delete the Openstack network and associated segment and VLAN and subnets.

Response:
def _delete_os_nwk(self, tenant_id, tenant_name, direc, is_fw_virt=False):
        """Delete the network created in Openstack.

        Function to delete Openstack network, It also releases the associated
        segmentation, VLAN and subnets.
        """
        serv_obj = self.get_service_obj(tenant_id)
        fw_dict = serv_obj.get_fw_dict()
        fw_id = fw_dict.get('fw_id')
        fw_data, fw_data_dict = self.get_fw(fw_id)
        if fw_data is None:
            LOG.error("Unable to get fw_data for tenant %s", tenant_name)
            return False
        if direc == 'in':
            net_id = fw_data.in_network_id
            seg, vlan = self.get_in_seg_vlan(tenant_id)
            subnet_dict = self.get_in_ip_addr(tenant_id)
        else:
            net_id = fw_data.out_network_id
            seg, vlan = self.get_out_seg_vlan(tenant_id)
            subnet_dict = self.get_out_ip_addr(tenant_id)
        # Delete the Openstack Network
        sub = subnet_dict.get('subnet')
        try:
            ret = self.os_helper.delete_network_all_subnets(net_id)
            if not ret:
                LOG.error("Delete network for ID %(net)s direct %(dir)s "
                          "failed", {'net': net_id, 'dir': direc})
                return False
        except Exception as exc:
            LOG.error("Delete network for ID %(net)s direct %(dir)s failed"
                      " Exc %(exc)s",
                      {'net': net_id, 'dir': direc, 'exc': exc})
            return False

        # Release the segment, VLAN and subnet allocated
        if not is_fw_virt:
            self.service_vlans.release_segmentation_id(vlan)
        self.service_segs.release_segmentation_id(seg)
        self.release_subnet(sub, direc)
        # Release the network DB entry
        self.delete_network_db(net_id)
        return True


Instruction:
Can you generate the documentation for the following Python 3 function
def delete_os_in_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        ret = True
        tenant_name = fw_dict.get('tenant_name')
        try:
            ret = self._delete_os_nwk(tenant_id, tenant_name, "in",
                                      is_fw_virt=is_fw_virt)
        except Exception as exc:
            LOG.error("Deletion of In Openstack Network failed tenant "
                      "%(tenant)s Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            ret = False
        # Updating the FW DB
        if ret:
            res = fw_const.OS_IN_NETWORK_DEL_SUCCESS
        else:
            res = fw_const.OS_IN_NETWORK_DEL_FAIL
        self.update_fw_db_result(tenant_id, os_status=res)
        return ret

Response: Deletes the Openstack In network and updates the DB.


Instruction:
How would you explain what the following Python 3 function does
def delete_os_out_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        ret = True
        tenant_name = fw_dict.get('tenant_name')
        try:
            ret = self._delete_os_nwk(tenant_id, tenant_name, "out",
                                      is_fw_virt=is_fw_virt)
        except Exception as exc:
            LOG.error("Deletion of Out Openstack Network failed tenant "
                      "%(tenant)s, Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            ret = False
        # Updating the FW DB
        if ret:
            res = fw_const.OS_OUT_NETWORK_DEL_SUCCESS
        else:
            res = fw_const.OS_OUT_NETWORK_DEL_FAIL
        self.update_fw_db_result(tenant_id, os_status=res)
        return ret

Response: Deletes the Openstack Out network and updates the DB.


Instruction:
Make a summary of the following Python 3 code
def create_os_dummy_rtr(self, tenant_id, fw_dict, is_fw_virt=False):
        res = fw_const.OS_DUMMY_RTR_CREATE_SUCCESS
        tenant_name = fw_dict.get('tenant_name')
        try:
            rtr_id = fw_dict.get('router_id')
            if rtr_id is None:
                LOG.error("Invalid router id, attaching dummy interface"
                          " failed")
                return False
            if is_fw_virt:
                net_id = subnet_id = None
            else:
                net_id, subnet_id = (
                    self._attach_dummy_intf_rtr(tenant_id, tenant_name,
                                                rtr_id))
                if net_id is None or subnet_id is None:
                    LOG.error("Invalid net_id or subnet_id, creating dummy"
                              " interface failed")
                    return False
        except Exception as exc:
            # Function _attach_dummy_intf_rtr already took care of
            # cleanup for error cases.
            LOG.error("Creation of Openstack Router failed "
                      "tenant %(tenant)s, Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            res = fw_const.OS_DUMMY_RTR_CREATE_FAIL
        self.store_fw_db_router(tenant_id, net_id, subnet_id, rtr_id, res)
        return True

Response: Create the dummy interface and attach it to the router and store the info in DB.


Instruction:
Implement a Python 3 function for
deleting the Openstack Dummy router and store the info in DB.

Response:
def delete_os_dummy_rtr(self, tenant_id, fw_dict, is_fw_virt=False):
        """Delete the Openstack Dummy router and store the info in DB. """
        ret = True
        tenant_name = fw_dict.get('tenant_name')
        try:
            rtr_id = fw_dict.get('router_id')
            if not rtr_id:
                LOG.error("Invalid router id, deleting dummy interface"
                          " failed")
                return False
            if not is_fw_virt:
                ret = self._delete_dummy_intf_rtr(tenant_id, tenant_name,
                                                  rtr_id)
        except Exception as exc:
            # Function _attach_dummy_intf_rtr already took care of
            # cleanup for error cases.
            LOG.error("Deletion of Openstack Router failed tenant "
                      "%(tenant)s, Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            ret = False
        if ret:
            res = fw_const.OS_DUMMY_RTR_DEL_SUCCESS
        else:
            res = fw_const.OS_DUMMY_RTR_DEL_FAIL
        self.update_fw_db_result(tenant_id, os_status=res)
        return ret


Instruction:
Create a Python 3 function for
creating the DCNM In Network and store the result in DB.

Response:
def create_dcnm_in_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        """Create the DCNM In Network and store the result in DB. """
        tenant_name = fw_dict.get('tenant_name')
        ret = self._create_service_nwk(tenant_id, tenant_name, 'in')
        if ret:
            res = fw_const.DCNM_IN_NETWORK_CREATE_SUCCESS
            LOG.info("In Service network created for tenant %s",
                     tenant_id)
        else:
            res = fw_const.DCNM_IN_NETWORK_CREATE_FAIL
            LOG.info("In Service network create failed for tenant %s",
                     tenant_id)
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        return ret


Instruction:
Given the following Python 3 function, write the documentation
def delete_dcnm_in_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        tenant_name = fw_dict.get('tenant_name')
        ret = self._delete_service_nwk(tenant_id, tenant_name, 'in')
        if ret:
            res = fw_const.DCNM_IN_NETWORK_DEL_SUCCESS
            LOG.info("In Service network deleted for tenant %s",
                     tenant_id)
        else:
            res = fw_const.DCNM_IN_NETWORK_DEL_FAIL
            LOG.info("In Service network deleted failed for tenant %s",
                     tenant_id)
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        return ret

Response: Delete the DCNM In Network and store the result in DB.


Instruction:
Implement a Python 3 function for
updating the DCNM s in partition information.

Response:
def update_dcnm_in_part(self, tenant_id, fw_dict, is_fw_virt=False):
        """Update DCNM's in partition information.

        Update the In partition service node IP address in DCNM and
        update the result
        """
        res = fw_const.DCNM_IN_PART_UPDATE_SUCCESS
        tenant_name = fw_dict.get('tenant_name')
        ret = True
        try:
            self._update_partition_in_create(tenant_id, tenant_name)
        except Exception as exc:
            LOG.error("Update of In Partition failed for tenant %(tenant)s"
                      " Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            res = fw_const.DCNM_IN_PART_UPDATE_FAIL
            ret = False
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        LOG.info("In partition updated with service ip addr")
        return ret


Instruction:
Can you create a Python 3 function that
clears the DCNM in partition service information and update the result.

Response:
def clear_dcnm_in_part(self, tenant_id, fw_dict, is_fw_virt=False):
        """Clear the DCNM in partition service information.

        Clear the In partition service node IP address in DCNM and update the
        result.
        """
        res = fw_const.DCNM_IN_PART_UPDDEL_SUCCESS
        tenant_name = fw_dict.get('tenant_name')
        ret = True
        try:
            self._update_partition_in_delete(tenant_name)
        except Exception as exc:
            LOG.error("Clear of In Partition failed for tenant %(tenant)s"
                      " , Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            res = fw_const.DCNM_IN_PART_UPDDEL_FAIL
            ret = False
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        LOG.info("In partition cleared off service ip addr")
        return ret


Instruction:
Make a summary of the following Python 3 code
def create_dcnm_out_part(self, tenant_id, fw_dict, is_fw_virt=False):
        res = fw_const.DCNM_OUT_PART_CREATE_SUCCESS
        tenant_name = fw_dict.get('tenant_name')
        ret = True
        try:
            self._create_out_partition(tenant_id, tenant_name)
        except Exception as exc:
            LOG.error("Create of Out Partition failed for tenant "
                      "%(tenant)s ,Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            res = fw_const.DCNM_OUT_PART_CREATE_FAIL
            ret = False
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        LOG.info("Out partition created")
        return ret

Response: Create the DCNM OUT partition and update the result.


Instruction:
Make a summary of the following Python 3 code
def delete_dcnm_out_part(self, tenant_id, fw_dict, is_fw_virt=False):
        res = fw_const.DCNM_OUT_PART_DEL_SUCCESS
        tenant_name = fw_dict.get('tenant_name')
        ret = True
        try:
            self._delete_partition(tenant_id, tenant_name)
        except Exception as exc:
            LOG.error("deletion of Out Partition failed for tenant "
                      "%(tenant)s, Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            res = fw_const.DCNM_OUT_PART_DEL_FAIL
            ret = False
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        LOG.info("Out partition deleted")
        return ret

Response: Delete the DCNM OUT partition and update the result.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def create_dcnm_out_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        tenant_name = fw_dict.get('tenant_name')
        ret = self._create_service_nwk(tenant_id, tenant_name, 'out')
        if ret:
            res = fw_const.DCNM_OUT_NETWORK_CREATE_SUCCESS
            LOG.info("out Service network created for tenant %s",
                     tenant_id)
        else:
            res = fw_const.DCNM_OUT_NETWORK_CREATE_FAIL
            LOG.info("out Service network create failed for tenant %s",
                     tenant_id)
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        return ret

Response: Create the DCNM OUT Network and update the result.


Instruction:
How would you explain what the following Python 3 function does
def delete_dcnm_out_nwk(self, tenant_id, fw_dict, is_fw_virt=False):
        tenant_name = fw_dict.get('tenant_name')
        ret = self._delete_service_nwk(tenant_id, tenant_name, 'out')
        if ret:
            res = fw_const.DCNM_OUT_NETWORK_DEL_SUCCESS
            LOG.info("out Service network deleted for tenant %s",
                     tenant_id)
        else:
            res = fw_const.DCNM_OUT_NETWORK_DEL_FAIL
            LOG.info("out Service network deleted failed for tenant %s",
                     tenant_id)
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        return ret

Response: Delete the DCNM OUT network and update the result.


Instruction:
Given the following Python 3 function, write the documentation
def update_dcnm_out_part(self, tenant_id, fw_dict, is_fw_virt=False):
        res = fw_const.DCNM_OUT_PART_UPDATE_SUCCESS
        tenant_name = fw_dict.get('tenant_name')
        ret = True
        try:
            ret = self._update_partition_out_create(tenant_id, tenant_name)
            if not ret:
                res = fw_const.DCNM_OUT_PART_UPDATE_FAIL
        except Exception as exc:
            LOG.error("Update of Out Partition failed for tenant "
                      "%(tenant)s Exception %(exc)s",
                      {'tenant': tenant_id, 'exc': str(exc)})
            res = fw_const.DCNM_OUT_PART_UPDATE_FAIL
            ret = False
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        LOG.info("Out partition updated with service ip addr")
        return ret

Response: Update DCNM OUT partition service node IP address and result.


Instruction:
Can you generate the documentation for the following Python 3 function
def clear_dcnm_out_part(self, tenant_id, fw_dict, is_fw_virt=False):
        res = fw_const.DCNM_OUT_PART_UPDDEL_SUCCESS
        self.update_fw_db_result(tenant_id, dcnm_status=res)
        LOG.info("Out partition cleared -noop- with service ip addr")
        return True

Response: Clear the DCNM OUT partition information.


Instruction:
Here you have a function in Python 3, explain what it does
def get_next_create_state(self, state, ret):
        if ret:
            if state == fw_const.FABRIC_PREPARE_DONE_STATE:
                return state
            else:
                return state + 1
        else:
            return state

Response: Return the next create state from previous state.


Instruction:
How would you explain what the following Python 3 function does
def get_next_del_state(self, state, ret):
        if ret:
            if state == fw_const.INIT_STATE:
                return state
            else:
                return state - 1
        else:
            return state

Response: Return the next delete state from previous state.


Instruction:
Here you have a function in Python 3, explain what it does
def get_next_state(self, state, ret, oper):
        if oper == fw_const.FW_CR_OP:
            return self.get_next_create_state(state, ret)
        else:
            return self.get_next_del_state(state, ret)

Response: Returns the next state for a create or delete operation.


Instruction:
Can you write a function in Python 3 where it
runs the create State Machine.

Response:
def run_create_sm(self, tenant_id, fw_dict, is_fw_virt):
        """Runs the create State Machine.

        Goes through every state function until the end or when one state
        returns failure.
        """
        ret = True
        serv_obj = self.get_service_obj(tenant_id)
        state = serv_obj.get_state()
        # Preserve the ordering of the next lines till while
        new_state = serv_obj.fixup_state(fw_const.FW_CR_OP, state)
        serv_obj.store_local_final_result(fw_const.RESULT_FW_CREATE_INIT)
        if state != new_state:
            state = new_state
            serv_obj.store_state(state)
        while ret:
            try:
                ret = self.fabric_fsm[state][0](tenant_id, fw_dict,
                                                is_fw_virt=is_fw_virt)
            except Exception as exc:
                LOG.error("Exception %(exc)s for state %(state)s",
                          {'exc': str(exc), 'state':
                           fw_const.fw_state_fn_dict.get(state)})
                ret = False
            if ret:
                LOG.info("State %s return successfully",
                         fw_const.fw_state_fn_dict.get(state))
            state = self.get_next_state(state, ret, fw_const.FW_CR_OP)
            serv_obj.store_state(state)
            if state == fw_const.FABRIC_PREPARE_DONE_STATE:
                break
        if ret:
            serv_obj.store_local_final_result(fw_const.RESULT_FW_CREATE_DONE)
        return ret


Instruction:
Write a Python 3 script to
run the delete State Machine.

Response:
def run_delete_sm(self, tenant_id, fw_dict, is_fw_virt):
        """Runs the delete State Machine.

        Goes through every state function until the end or when one state
        returns failure.
        """
        # Read the current state from the DB
        ret = True
        serv_obj = self.get_service_obj(tenant_id)
        state = serv_obj.get_state()
        # Preserve the ordering of the next lines till while
        new_state = serv_obj.fixup_state(fw_const.FW_DEL_OP, state)
        serv_obj.store_local_final_result(fw_const.RESULT_FW_DELETE_INIT)
        if state != new_state:
            state = new_state
            serv_obj.store_state(state)
        while ret:
            try:
                ret = self.fabric_fsm[state][1](tenant_id, fw_dict,
                                                is_fw_virt=is_fw_virt)
            except Exception as exc:
                LOG.error("Exception %(exc)s for state %(state)s",
                          {'exc': str(exc), 'state':
                           fw_const.fw_state_fn_del_dict.get(state)})
                ret = False
            if ret:
                LOG.info("State %s return successfully",
                         fw_const.fw_state_fn_del_dict.get(state))
            if state == fw_const.INIT_STATE:
                break
            state = self.get_next_state(state, ret, fw_const.FW_DEL_OP)
            serv_obj.store_state(state)
        return ret


Instruction:
Write a Python 3 function for
returning the key associated with the dict.

Response:
def get_key_state(self, status, state_dict):
        """Returns the key associated with the dict. """
        for key, val in state_dict.items():
            if val == status:
                return key


Instruction:
Explain what the following Python 3 code does
def pop_fw_state(self, compl_result, os_status, dcnm_status):
        res_list = compl_result.split('(')
        state_num = None
        if len(res_list) > 1:
            state_num = int(res_list[1].split(')')[0])
        else:
            if res_list[0] == fw_const.RESULT_FW_CREATE_INIT:
                if os_status is None:
                    state_num = fw_const.INIT_STATE
            elif res_list[0] == fw_const.RESULT_FW_CREATE_DONE:
                state_num = fw_const.FABRIC_PREPARE_DONE_STATE
            elif res_list[0] == fw_const.RESULT_FW_DELETE_INIT:
                if os_status == fw_const.OS_CREATE_SUCCESS and (
                   dcnm_status == fw_const.DCNM_CREATE_SUCCESS):
                    state_num = fw_const.FABRIC_PREPARE_DONE_STATE
        return state_num

Response: Populate the state of the cache.


Instruction:
Can you create a Python 3 function that
populates the local cache.

Response:
def pop_fw_local(self, tenant_id, net_id, direc, node_ip):
        """Populate the local cache.

        Read the Network DB and populate the local cache.
        Read the subnet from the Subnet DB, given the net_id and populate the
        cache.
        """
        net = self.get_network(net_id)
        serv_obj = self.get_service_obj(tenant_id)
        serv_obj.update_fw_local_cache(net_id, direc, node_ip)
        if net is not None:
            net_dict = self.fill_dcnm_net_info(tenant_id, direc, net.vlan,
                                               net.segmentation_id)
            serv_obj.store_dcnm_net_dict(net_dict, direc)
        if direc == "in":
            subnet = self.service_in_ip.get_subnet_by_netid(net_id)
        else:
            subnet = self.service_out_ip.get_subnet_by_netid(net_id)
        if subnet is not None:
            subnet_dict = self.fill_dcnm_subnet_info(
                tenant_id, subnet,
                self.get_start_ip(subnet), self.get_end_ip(subnet),
                self.get_gateway(subnet), self.get_secondary_gateway(subnet),
                direc)
            serv_obj.store_dcnm_subnet_dict(subnet_dict, direc)


Instruction:
Can you tell what is the following Python 3 function doing
def populate_local_cache_tenant(self, fw_id, fw_data):
        tenant_id = fw_data.get('tenant_id')
        self.create_serv_obj(tenant_id)
        serv_obj = self.get_service_obj(tenant_id)
        serv_obj.create_fw_db(fw_id, fw_data.get('name'), tenant_id)
        self.pop_fw_local(tenant_id, fw_data.get('in_network_id'), "in",
                          fw_data.get('in_service_node_ip'))
        self.pop_fw_local(tenant_id, fw_data.get('out_network_id'), "out",
                          fw_data.get('out_service_node_ip'))
        serv_obj.update_fw_local_result_str(fw_data.get('os_status'),
                                            fw_data.get('dcnm_status'),
                                            fw_data.get('device_status'))
        compl_res = fw_data.get('result')
        result = compl_res.split('(')[0]
        serv_obj.store_local_final_result(result)
        state = self.pop_fw_state(compl_res, fw_data.get('os_status'),
                                  fw_data.get('dcnm_status'))
        if state is None:
            LOG.error("Unable to get state complete result %(res)s"
                      " OS status %(os)s, dcnm status %(dcnm)s",
                      {'res': compl_res, 'os': fw_data.get('os_status'),
                       'dcnm': fw_data.get('dcnm_status')})
        serv_obj.store_state(state, popl_db=False)
        if state == fw_const.FABRIC_PREPARE_DONE_STATE:
            serv_obj.set_fabric_create(True)
        router_id = fw_data.get('router_id')
        rout_net_id = fw_data.get('router_net_id')
        rout_subnet_id = fw_data.get('router_subnet_id')
        # Result is already populated above, so pass None below.
        # And, the result passed should be a string
        serv_obj.update_fw_local_router(rout_net_id, rout_subnet_id, router_id,
                                        None)

Response: Populate the local cache for a given tenant.


Instruction:
How would you code a function in Python 3 to
populate the local cache from DB.

Response:
def populate_local_cache(self):
        """Populate the local cache from DB.

        Read the entries from FW DB and Calls routines to populate the cache.
        """
        fw_dict = self.get_all_fw_db()
        for fw_id in fw_dict:
            LOG.info("Populating cache for FW %s", fw_id)
            fw_data = fw_dict[fw_id]
            self.populate_local_cache_tenant(fw_id, fw_data)


Instruction:
Given the following Python 3 function, write the documentation
def delete_os_dummy_rtr_nwk(self, rtr_id, net_id, subnet_id):
        subnet_lst = set()
        subnet_lst.add(subnet_id)
        ret = self.os_helper.delete_intf_router(None, None, rtr_id, subnet_lst)
        if not ret:
            return ret
        return self.os_helper.delete_network_all_subnets(net_id)

Response: Delete the dummy interface to the router.


Instruction:
Make a summary of the following Python 3 code
def delete_os_nwk_db(self, net_id, seg, vlan):
        if seg is not None:
            self.service_segs.release_segmentation_id(seg)
        if vlan is not None:
            self.service_vlans.release_segmentation_id(vlan)
        self.os_helper.delete_network_all_subnets(net_id)
        # There's a chance that OS network got created but it's ID
        # was not put in DB
        # So, deleting networks in os that has part of the special
        # name
        self.os_helper.delete_network_subname(fw_const.IN_SERVICE_NWK)
        self.delete_network_db(net_id)
        self.clear_fw_entry_by_netid(net_id)
        self.service_in_ip.release_subnet_by_netid(net_id)
        self.service_out_ip.release_subnet_by_netid(net_id)

Response: Delete the Openstack Network from the database.


Instruction:
Can you generate the documentation for the following Python 3 function
def correct_db_restart(self):
        LOG.info("Checking consistency of DB")
        # Any Segments allocated that's not in Network or FW DB, release it
        seg_netid_dict = self.service_segs.get_seg_netid_src(fw_const.FW_CONST)
        vlan_netid_dict = self.service_vlans.get_seg_netid_src(
            fw_const.FW_CONST)
        for netid in seg_netid_dict:
            net = self.get_network(netid)
            fw_net = self.get_fw_by_netid(netid)
            if not net or not fw_net:
                if netid in vlan_netid_dict:
                    vlan_net = vlan_netid_dict[netid]
                else:
                    vlan_net = None
                self.delete_os_nwk_db(netid, seg_netid_dict[netid], vlan_net)
                LOG.info("Allocated segment for net %s not in DB "
                         "returning", net)
                return
        # Any VLANs allocated that's not in Network or FW DB, release it
        # For Virtual case, this list will be empty
        for netid in vlan_netid_dict:
            net = self.get_network(netid)
            fw_net = self.get_fw_by_netid(netid)
            if not net or not fw_net:
                if netid in seg_netid_dict:
                    vlan_net = seg_netid_dict[netid]
                else:
                    vlan_net = None
                self.delete_os_nwk_db(netid, vlan_net, vlan_netid_dict[netid])
                LOG.info("Allocated vlan for net %s not in DB returning",
                         net)
                return
        # Release all IP's from DB that has no NetID or SubnetID
        self.service_in_ip.release_subnet_no_netid()
        self.service_out_ip.release_subnet_no_netid()
        # It leaves out following possibilities not covered by above.
        # 1. Crash can happen just after creating FWID in DB (for init state)
        # 2. Crash can happen after 1 + IP address allocation
        # 3. Crash can happen after 2 + create OS network
        # IP address allocated will be freed as above.
        # Only OS network will remain for case 3.
        # Also, create that FW DB entry only if that FWID didn't exist.

        # Delete all dummy networks created for dummy router from OS if it's
        # ID is not in NetDB
        # Delete all dummy routers and its associated networks/subnetfrom OS
        # if it's ID is not in FWDB
        fw_dict = self.get_all_fw_db()
        for fw_id in fw_dict:
            rtr_nwk = fw_id[0:4] + fw_const.DUMMY_SERVICE_NWK + (
                fw_id[len(fw_id) - 4:])
            net_list = self.os_helper.get_network_by_name(rtr_nwk)
            # TODO(padkrish) Come back to finish this. Not sure of this.
            # The router interface should be deleted first and then the network
            # Try using show_router
            for net in net_list:
                # Check for if it's there in NetDB
                net_db_item = self.get_network(net.get('id'))
                if not net_db_item:
                    self.os_helper.delete_network_all_subnets(net.get('id'))
                    LOG.info("Router Network %s not in DB, returning",
                             net.get('id'))
                    return
            rtr_name = fw_id[0:4] + fw_const.DUMMY_SERVICE_RTR + (
                fw_id[len(fw_id) - 4:])
            rtr_list = self.os_helper.get_rtr_by_name(rtr_name)
            for rtr in rtr_list:
                fw_db_item = self.get_fw_by_rtrid(rtr.get('id'))
                if not fw_db_item:
                    # There should be only one
                    if not net_list:
                        LOG.error("net_list len is 0, router net not "
                                  "found")
                        return
                    fw_type = fw_dict[fw_id].get('fw_type')
                    if fw_type == fw_const.FW_TENANT_EDGE:
                        rtr_net = net_list[0]
                        rtr_subnet_lt = (
                            self.os_helper.get_subnets_for_net(rtr_net))
                        if rtr_subnet_lt is None:
                            LOG.error("router subnet not found for "
                                      "net %s", rtr_net)
                            return
                        rtr_subnet_id = rtr_subnet_lt[0].get('id')
                        LOG.info("Deleted dummy router network %s",
                                 rtr.get('id'))
                        ret = self.delete_os_dummy_rtr_nwk(rtr.get('id'),
                                                           rtr_net.get('id'),
                                                           rtr_subnet_id)
                        return ret
        LOG.info("Done Checking consistency of DB, no issues")

Response: This function checks that the DB is consistent after unexpected restarts.


Instruction:
Can you write a function in Python 3 where it
tops level routine to prepare the fabric.

Response:
def prepare_fabric_fw(self, tenant_id, fw_dict, is_fw_virt, result):
        """Top level routine to prepare the fabric. """
        try:
            with self.mutex_lock:
                ret = self._prepare_fabric_fw_internal(tenant_id, fw_dict,
                                                       is_fw_virt, result)
        except Exception as exc:
            LOG.error("Exception raised in create fabric %s", str(exc))
            return False
        return ret


Instruction:
Make a summary of the following Python 3 code
def delete_fabric_fw_internal(self, tenant_id, fw_dict, is_fw_virt,
                                  result):
        """Internal routine to delete the fabric configuration.

        This runs the SM and deletes the entries from DB and local cache.
        """
        if not self.auto_nwk_create:
            LOG.info("Auto network creation disabled")
            return False
        try:
            tenant_name = fw_dict.get('tenant_name')
            fw_name = fw_dict.get('fw_name')
            if tenant_id not in self.service_attr:
                LOG.error("Service obj not created for tenant %s",
                          tenant_name)
                return False
            # A check for is_fabric_create is not needed since a delete
            # may be issued even when create is not completely done.
            # For example, some state such as create stuff in DCNM failed and
            # SM for create is in the process of retrying. A delete can be
            # issue at that time. If we have a check for is_fabric_create
            # then delete operation will not go through.
            if result == fw_const.RESULT_FW_DELETE_DONE:
                LOG.error("Fabric for tenant %s already deleted",
                          tenant_id)
                return True
            ret = self.run_delete_sm(tenant_id, fw_dict, is_fw_virt)
            self.service_attr[tenant_id].set_fabric_create(False)
            if ret:
                LOG.info("Delete SM completed successfully for tenant"
                         "%(tenant)s FW %(fw)s",
                         {'tenant': tenant_name, 'fw': fw_name})
                self.service_attr[tenant_id].destroy_local_fw_db()
                self.delete_serv_obj(tenant_id)
            else:
                LOG.error("Delete SM failed for tenant"
                          "%(tenant)s FW %(fw)s",
                          {'tenant': tenant_name, 'fw': fw_name})
            # TODO(padkrish) Equivalent of create_fw_db for delete.
        except Exception as exc:
            LOG.error("Exception raised in delete fabric int %s",
                      str(exc))
            return False
        return ret

Response: Internal routine to delete the fabric configuration.


Instruction:
Can you create a Python 3 function that
tops level routine to unconfigure the fabric.

Response:
def delete_fabric_fw(self, tenant_id, fw_dict, is_fw_virt, result):
        """Top level routine to unconfigure the fabric. """
        try:
            with self.mutex_lock:
                ret = self.delete_fabric_fw_internal(tenant_id, fw_dict,
                                                     is_fw_virt, result)
        except Exception as exc:
            LOG.error("Exception raised in delete fabric %s", str(exc))
            return False
        return ret