Unassigns a global IP from a target.
515838
def cli(env, identifier):
    """"""

    mgr = SoftLayer.NetworkManager(env.client)
    global_ip_id = helpers.resolve_id(mgr.resolve_global_ip_ids, identifier,
                                      name='global ip')
    mgr.unassign_global_ip(global_ip_id)
714349
def clear_global(self):
        
        vname = self.varname
        logger.debug(f'global clearning {vname}')
        if vname in globals():
            logger.debug('removing global instance var: {}'.format(vname))
            del globals()[vname]
909211
def untrust(self, scope, vk):
        """"""
        self.data['verifiers'].remove({'scope': scope, 'vk': vk})
        return self
638404
def unregisterAPI(self, name):
        
        if name.startswith('public/'):
            target = 'public'
            name = name[len('public/'):]
        else:
            target = self.servicename
            name = name
        removes = [m for m in self.handler.handlers.keys() if m.target == target and m.name == name]
        for m in removes:
            self.handler.unregisterHandler(m)
705177
public void unPublishPort() {
        // unregister with epmd
        OtpEpmd.unPublishPort(this);

        // close the local descriptor (if we have one)
        try {
            if (super.epmd != null) {
                super.epmd.close();
            }
        } catch (final IOException e) {/* ignore close errors */
        }
        super.epmd = null;
    }
761678
public static void removeSipSubcontext(Context envCtx) {
		try {
			envCtx.destroySubcontext(SIP_SUBCONTEXT);
		} catch (NamingException e) {
			logger.error(sm.getString("naming.unbindFailed", e));
		}
	}
948991
def remove_included_ip_range(from, to)
      from_ip = IPAddr.new(from)
      to_ip   = IPAddr.new(to)
      (from_ip..to_ip)
      raise 'Invalid IP range specified' if (from_ip..to_ip).to_a.size.zero?
      @included_scan_targets[:addresses].reject! { |t| t.eql? IPRange.new(from, to) }
    rescue ArgumentError => e
      raise "#{e.message} in given IP range"
    end
405495
def remove_exclusion(host_or_ip)
      asset = host_or_ip
      unless host_or_ip.respond_to?(:host) || host_or_ip.respond_to?(:from)
        # Attept to convert String to appropriate object.
        asset = HostOrIP.convert(host_or_ip)
      end
      @asset_exclusions = asset_exclusions.reject { |a| a.eql? asset }
    end
139772
def floating_ip_disassociate(self, server_name, floating_ip):
        '''
        
        '''
        nt_ks = self.compute_conn
        server_ = self.server_by_name(server_name)
        server = nt_ks.servers.get(server_.__dict__['id'])
        server.remove_floating_ip(floating_ip)
        return self.floating_ip_list()[floating_ip]
689940
def unassign_floating_ip(kwargs=None, call=None):
    '''
    
    '''
    if call != 'function':
        log.error(
            'The inassign_floating_ip function must be called with -f or --function.'
        )
        return False

    if not kwargs:
        kwargs = {}

    if 'floating_ip' not in kwargs:
        log.error('A floating IP is required.')
        return False

    result = query(method='floating_ips',
                   command=kwargs['floating_ip'] + '/actions',
                   args={'type': 'unassign'},
                   http_method='post')

    return result
949285
def remove_mapping(agent, prefix, ip):
    """"""
    return _broadcast(agent, RemoveMappingManager,
                      RecordType.record_A, prefix, ip)
586096
def deny(self, ip):
        
        self.blacklist.append(ip)
        self.whitelist.clear()
398576
def _RemoveForwardedIps(self, forwarded_ips, interface):
    
    for address in forwarded_ips:
      self.ip_forwarding_utils.RemoveForwardedIp(address, interface)
967249
def remove_global(self, name):
        
        with self._lock:
            if self._gpayload is not None:
                if name in self._gpayload:
                    del self._gpayload[name]
                if not self._gpayload:
                    self._gpayload = None
1016740
public static base_responses unset(nitro_service client, String ipv6address[], String args[]) throws Exception {
		base_responses result = null;
		if (ipv6address != null && ipv6address.length > 0) {
			nsip6 unsetresources[] = new nsip6[ipv6address.length];
			for (int i=0;i<ipv6address.length;i++){
				unsetresources[i] = new nsip6();
				unsetresources[i].ipv6address = ipv6address[i];
			}
			result = unset_bulk_request(client, unsetresources,args);
		}
		return result;
	}
59440
public void unbindEIP() throws Exception {
        InstanceInfo myInfo = applicationInfoManager.getInfo();
        String myPublicIP = null;
        if (myInfo != null
                && myInfo.getDataCenterInfo().getName() == Name.Amazon) {
            myPublicIP = ((AmazonInfo) myInfo.getDataCenterInfo())
                    .get(MetaDataKey.publicIpv4);
            if (myPublicIP == null) {
                logger.info("Instance is not associated with an EIP. Will not try to unbind");
                return;
            }

            try {
                AmazonEC2 ec2Service = getEC2Service();
                DescribeAddressesRequest describeAddressRequest = new DescribeAddressesRequest()
                        .withPublicIps(myPublicIP);
                DescribeAddressesResult result = ec2Service.describeAddresses(describeAddressRequest);
                if ((result.getAddresses() != null) && (!result.getAddresses().isEmpty())) {
                    Address eipAddress = result.getAddresses().get(0);
                    DisassociateAddressRequest dissociateRequest = new DisassociateAddressRequest();
                    String domain = eipAddress.getDomain();
                    if ("vpc".equals(domain)) {
                        dissociateRequest.setAssociationId(eipAddress.getAssociationId());
                    } else {
                        dissociateRequest.setPublicIp(eipAddress.getPublicIp());
                    }

                    ec2Service.disassociateAddress(dissociateRequest);
                    logger.info("Dissociated the EIP {} from this instance", myPublicIP);
                }
            } catch (Throwable e) {
                throw new RuntimeException("Cannot dissociate address from this instance", e);
            }
        }

    }
872851
def geolocate(self, ip: str):
        
        url_path = "/api/geoloc/{ip}".format(ip=ip)
        return self._request_without_api(path=url_path)