Method to update network-ipv6's

        :param networkipv6s: List containing network-ipv6's desired to updated
        :return: None
975757
def update(self, networkipv6s):
        

        data = {'networks': networkipv6s}
        networkipv6s_ids = [str(networkipv6.get('id'))
                            for networkipv6 in networkipv6s]

        return super(ApiNetworkIPv6, self).put('api/v3/networkv6/%s/' %
                                               ';'.join(networkipv6s_ids), data)
140921
def deploy(self, id_networkv6):
        

        data = dict()
        uri = 'api/networkv6/%s/equipments/' % id_networkv6

        return super(ApiNetworkIPv6, self).post(uri, data=data)
1353065
def list_cidr_ips_ipv6(cidr):
    '''
    
    '''
    ips = netaddr.IPNetwork(cidr)
    return [six.text_type(ip.ipv6()) for ip in list(ips)]
700737
public void setResourceAwsEc2InstanceIpV6Addresses(java.util.Collection<IpFilter> resourceAwsEc2InstanceIpV6Addresses) {
        if (resourceAwsEc2InstanceIpV6Addresses == null) {
            this.resourceAwsEc2InstanceIpV6Addresses = null;
            return;
        }

        this.resourceAwsEc2InstanceIpV6Addresses = new java.util.ArrayList<IpFilter>(resourceAwsEc2InstanceIpV6Addresses);
    }
885549
def modify_network_interface
      @hosts.each do |host|
        instance = host['instance']
        host['sg_cidr_ips'] = host['sg_cidr_ips'] || '0.0.0.0/0';
        sg_cidr_ips = host['sg_cidr_ips'].split(',')

        # Define tags for the instance
        @logger.notify("aws-sdk: Update network_interface for #{host.name}")

        security_group = ensure_group(instance[:network_interfaces].first, Beaker::EC2Helper.amiports(host), sg_cidr_ips)
        ping_security_group = ensure_ping_group(instance[:network_interfaces].first, sg_cidr_ips)

        client.modify_network_interface_attribute(
          :network_interface_id => "#{instance[:network_interfaces].first[:network_interface_id]}",
          :groups => [security_group.group_id, ping_security_group.group_id],
        )
      end

      nil
    end
893344
public void setIpv6Ranges(java.util.Collection<Ipv6Range> ipv6Ranges) {
        if (ipv6Ranges == null) {
            this.ipv6Ranges = null;
            return;
        }

        this.ipv6Ranges = new com.amazonaws.internal.SdkInternalList<Ipv6Range>(ipv6Ranges);
    }
811609
def update(self):
        
        for node in self.get_all_nodes():
            try:
                node.update_ips()

                # If we previously did not have a preferred_ip or the
                # preferred_ip is not in the current list, then try to connect
                # to one of the node ips and update the preferred_ip.
                if node.ips and \
                        not (node.preferred_ip and \
                                         node.preferred_ip in node.ips):
                    node.connect()
            except InstanceError as ex:
                log.warning("Ignoring error updating information on node %s: %s",
                            node, ex)
        self.repository.save_or_update(self)
3169
def create_api_network_ipv6(self):
        """"""

        return ApiNetworkIPv6(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
628018
def expand_ipv6 (ip, num):
    
    i = ip.find("::")
    prefix = ip[:i]
    suffix = ip[i + 2:]
    count = prefix.count(":") + suffix.count(":")
    if prefix:
        count += 1
        prefix = prefix + ":"
    if suffix:
        count += 1
        suffix = ":" + suffix
    if count >= num:
        raise ValueError("invalid ipv6 number: %s" % ip)
    fill = (num - count - 1) * "0:" + "0"
    return prefix + fill + suffix
459102
public static base_response update(nitro_service client, bridgegroup resource) throws Exception {
		bridgegroup updateresource = new bridgegroup();
		updateresource.id = resource.id;
		updateresource.ipv6dynamicrouting = resource.ipv6dynamicrouting;
		return updateresource.update_resource(client);
	}
435775
public void setIpv6CidrBlockAssociationSet(java.util.Collection<SubnetIpv6CidrBlockAssociation> ipv6CidrBlockAssociationSet) {
        if (ipv6CidrBlockAssociationSet == null) {
            this.ipv6CidrBlockAssociationSet = null;
            return;
        }

        this.ipv6CidrBlockAssociationSet = new com.amazonaws.internal.SdkInternalList<SubnetIpv6CidrBlockAssociation>(ipv6CidrBlockAssociationSet);
    }
1045552
def update(cls):
        
        ifaddrs = getifaddrs()
        # Create new interfaces
        for ifname in ifaddrs.keys():
            if filter(ifname.startswith, cls.NAME_FILTER):
                cls.objects.get_or_create(name=ifname)

        # Delete no longer existing ones
        cls.objects.exclude(name__in=ifaddrs.keys()).delete()
670535
def servers_update_addresses(request, servers, all_tenants=False):
    

    # NOTE(e0ne): we don't need to call neutron if we have no instances
    if not servers:
        return

    # Get all (filtered for relevant servers) information from Neutron
    try:
        # NOTE(e0ne): we need tuple here to work with @memoized decorator.
        # @memoized works with hashable arguments only.
        ports = list_resources_with_long_filters(
            port_list, 'device_id',
            tuple([instance.id for instance in servers]),
            request=request)
        fips = FloatingIpManager(request)
        if fips.is_supported():
            floating_ips = list_resources_with_long_filters(
                fips.list, 'port_id', tuple([port.id for port in ports]),
                all_tenants=all_tenants)
        else:
            floating_ips = []
        # NOTE(e0ne): we need frozenset here to work with @memoized decorator.
        # @memoized works with hashable arguments only
        networks = list_resources_with_long_filters(
            network_list, 'id', frozenset([port.network_id for port in ports]),
            request=request)
    except neutron_exc.NotFound as e:
        LOG.error('Neutron resource does not exist. %s', e)
        return
    except Exception as e:
        LOG.error('Unable to connect to Neutron: %s', e)
        error_message = _('Unable to connect to Neutron.')
        messages.error(request, error_message)
        return

    # Map instance to its ports
    instances_ports = collections.defaultdict(list)
    for port in ports:
        instances_ports[port.device_id].append(port)

    # Map port to its floating ips
    ports_floating_ips = collections.defaultdict(list)
    for fip in floating_ips:
        ports_floating_ips[fip.port_id].append(fip)

    # Map network id to its name
    network_names = dict((network.id, network.name_or_id)
                         for network in networks)

    for server in servers:
        try:
            addresses = _server_get_addresses(
                request,
                server,
                instances_ports,
                ports_floating_ips,
                network_names)
        except Exception as e:
            LOG.error(six.text_type(e))
        else:
            server.addresses = addresses
1362935
def _get_ipv6addrs(self):
        
        addrs = self._get_addrs()
        ipv6addrs = addrs.get(netifaces.AF_INET6)
        if not ipv6addrs:
            return {}
        return ipv6addrs[0]
151149
def _get_ipv6_network_from_address(address):
    
    if address['addr'].startswith('fe80') or address['addr'] == "::1":
        return None

    prefix = address['netmask'].split("/")
    if len(prefix) > 1:
        netmask = prefix[1]
    else:
        netmask = address['netmask']
    return netaddr.IPNetwork("%s/%s" % (address['addr'],
                                        netmask))
763436
public static mps_network_config update(nitro_service client, mps_network_config resource) throws Exception
	{
		resource.validate("modify");
		return ((mps_network_config[]) resource.update_resource(client))[0];
	}
364817
def enable_static_ip_config_v6(self, ipv6_address, ipv6_network_mask_prefix_length):
        
        if not isinstance(ipv6_address, basestring):
            raise TypeError("ipv6_address can only be an instance of type basestring")
        if not isinstance(ipv6_network_mask_prefix_length, baseinteger):
            raise TypeError("ipv6_network_mask_prefix_length can only be an instance of type baseinteger")
        self._call("enableStaticIPConfigV6",
                     in_p=[ipv6_address, ipv6_network_mask_prefix_length])