Java IPAddressVO.getAssociatedWithNetworkId方法代码示例

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@Override
@DB
public boolean disassociatePublicIpAddress(final long addrId, final long userId, final Account caller) {

    boolean success = true;
    // Cleanup all ip address resources - PF/LB/Static nat rules
    if (!cleanupIpResources(addrId, userId, caller)) {
        success = false;
        s_logger.warn("Failed to release resources for ip address id=" + addrId);
    }

    final IPAddressVO ip = markIpAsUnavailable(addrId);
    if (ip == null) {
        return true;
    }

    if (s_logger.isDebugEnabled()) {
        s_logger.debug("Releasing ip id=" + addrId + "; sourceNat = " + ip.isSourceNat());
    }

    if (ip.getAssociatedWithNetworkId() != null) {
        final Network network = _networksDao.findById(ip.getAssociatedWithNetworkId());
        try {
            if (!applyIpAssociations(network, true)) {
                s_logger.warn("Unable to apply ip address associations for " + network);
                success = false;
            }
        } catch (final ResourceUnavailableException e) {
            throw new CloudRuntimeException("We should never get to here because we used true when applyIpAssociations", e);
        }
    } else {
        if (ip.getState() == IpAddress.State.Releasing) {
            _ipAddressDao.unassignIpAddress(ip.getId());
        }
    }

    if (success) {
        s_logger.debug("Released a public ip id=" + addrId);
    }

    return success;
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
protected boolean updateIpResourceCount(final IPAddressVO ip) {
    // don't increment resource count for direct and dedicated ip addresses
    return (ip.getAssociatedWithNetworkId() != null || ip.getVpcId() != null) && !isIpDedicated(ip);
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@DB
private boolean releaseIpAddressInternal(final long ipAddressId) throws InsufficientAddressCapacityException {
    final Long userId = CallContext.current().getCallingUserId();
    final Account caller = CallContext.current().getCallingAccount();

    // Verify input parameters
    final IPAddressVO ipVO = _ipAddressDao.findById(ipAddressId);
    if (ipVO == null) {
        throw new InvalidParameterValueException("Unable to find ip address by id");
    }

    if (ipVO.getAllocatedTime() == null) {
        s_logger.debug("Ip Address id= " + ipAddressId + " is not allocated, so do nothing.");
        return true;
    }

    // verify permissions
    if (ipVO.getAllocatedToAccountId() != null) {
        _accountMgr.checkAccess(caller, null, true, ipVO);
    }

    if (ipVO.isSourceNat()) {
        throw new IllegalArgumentException("ip address is used for source nat purposes and can not be disassociated.");
    }

    final VlanVO vlan = _vlanDao.findById(ipVO.getVlanId());
    if (!vlan.getVlanType().equals(VlanType.VirtualNetwork)) {
        throw new IllegalArgumentException("only ip addresses that belong to a virtual network may be disassociated.");
    }

    // don't allow releasing system ip address
    if (ipVO.getSystem()) {
        final InvalidParameterValueException ex = new InvalidParameterValueException("Can't release system IP address with specified id");
        ex.addProxyObject(ipVO.getUuid(), "systemIpAddrId");
        throw ex;
    }

    final boolean success = _ipAddrMgr.disassociatePublicIpAddress(ipAddressId, userId, caller);

    if (success) {
        final Long networkId = ipVO.getAssociatedWithNetworkId();
        if (networkId != null) {
            final Network guestNetwork = getNetwork(networkId);
            final NetworkOffering offering = _entityMgr.findById(NetworkOffering.class, guestNetwork.getNetworkOfferingId());
            final Long vmId = ipVO.getAssociatedWithVmId();
            if (offering.getElasticIp() && vmId != null) {
                _rulesMgr.getSystemIpAndEnableStaticNatForVm(_userVmDao.findById(vmId), true);
                return true;
            }
        }
    } else {
        s_logger.warn("Failed to release public ip address id=" + ipAddressId);
    }
    return success;
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
protected void isIpReadyForStaticNat(final long vmId, final IPAddressVO ipAddress, final String vmIp, final Account caller, final long callerUserId) throws
        NetworkRuleConflictException,
        ResourceUnavailableException {
    if (ipAddress.isSourceNat()) {
        throw new InvalidParameterValueException("Can't enable static, ip address " + ipAddress + " is a sourceNat ip address");
    }

    if (!ipAddress.isOneToOneNat()) { // Dont allow to enable static nat if PF/LB rules exist for the IP
        final List<FirewallRuleVO> portForwardingRules = _firewallDao.listByIpAndPurposeAndNotRevoked(ipAddress.getId(), Purpose.PortForwarding);
        if (portForwardingRules != null && !portForwardingRules.isEmpty()) {
            throw new NetworkRuleConflictException("Failed to enable static nat for the ip address " + ipAddress + " as it already has PortForwarding rules assigned");
        }

        final List<FirewallRuleVO> loadBalancingRules = _firewallDao.listByIpAndPurposeAndNotRevoked(ipAddress.getId(), Purpose.LoadBalancing);
        if (loadBalancingRules != null && !loadBalancingRules.isEmpty()) {
            throw new NetworkRuleConflictException("Failed to enable static nat for the ip address " + ipAddress + " as it already has LoadBalancing rules assigned");
        }
    } else if (ipAddress.getAssociatedWithVmId() != null && ipAddress.getAssociatedWithVmId().longValue() != vmId) {
        throw new NetworkRuleConflictException("Failed to enable static for the ip address " + ipAddress + " and vm id=" + vmId +
                " as it's already assigned to antoher vm");
    }

    //check wether the vm ip is alreday associated with any public ip address
    final IPAddressVO oldIP = _ipAddressDao.findByAssociatedVmIdAndVmIp(vmId, vmIp);

    if (oldIP != null) {
        // If elasticIP functionality is supported in the network, we always have to disable static nat on the old
        // ip in order to re-enable it on the new one
        final Long networkId = oldIP.getAssociatedWithNetworkId();
        final VMInstanceVO vm = _vmInstanceDao.findById(vmId);

        boolean reassignStaticNat = false;
        if (networkId != null) {
            final Network guestNetwork = _networkModel.getNetwork(networkId);
            final NetworkOffering offering = _entityMgr.findById(NetworkOffering.class, guestNetwork.getNetworkOfferingId());
            if (offering.getElasticIp()) {
                reassignStaticNat = true;
            }
        }

        // If there is public ip address already associated with the vm, throw an exception
        if (!reassignStaticNat) {
            throw new InvalidParameterValueException("Failed to enable static nat on the  ip " +
                    ipAddress.getAddress() + " with Id " + ipAddress.getUuid() + " as the vm " + vm.getInstanceName() + " with Id " +
                    vm.getUuid() + " is already associated with another public ip " + oldIP.getAddress() + " with id " +
                    oldIP.getUuid());
        }
        // unassign old static nat rule
        s_logger.debug("Disassociating static nat for ip " + oldIP);
        if (!disableStaticNat(oldIP.getId(), caller, callerUserId, true)) {
            throw new CloudRuntimeException("Failed to disable old static nat rule for vm " + vm.getInstanceName() +
                    " with id " + vm.getUuid() + "  and public ip " + oldIP);
        }
    }
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@Override
@DB
@ActionEvent(eventType = EventTypes.EVENT_NET_RULE_ADD, eventDescription = "creating static nat rule", create = true)
public StaticNatRule createStaticNatRule(final StaticNatRule rule, final boolean openFirewall) throws NetworkRuleConflictException {
    final Account caller = CallContext.current().getCallingAccount();

    final Long ipAddrId = rule.getSourceIpAddressId();

    final IPAddressVO ipAddress = _ipAddressDao.findById(ipAddrId);

    // Validate ip address
    if (ipAddress == null) {
        throw new InvalidParameterValueException("Unable to create static nat rule; ip id=" + ipAddrId + " doesn't exist in the system");
    } else if (ipAddress.isSourceNat() || !ipAddress.isOneToOneNat() || ipAddress.getAssociatedWithVmId() == null) {
        throw new NetworkRuleConflictException("Can't do static nat on ip address: " + ipAddress.getAddress());
    }

    _firewallMgr.validateFirewallRule(caller, ipAddress, rule.getSourcePortStart(), rule.getSourcePortEnd(), rule.getProtocol(), Purpose.StaticNat,
            FirewallRuleType.User, null, rule.getTrafficType());

    final Long networkId = ipAddress.getAssociatedWithNetworkId();
    final Long accountId = ipAddress.getAllocatedToAccountId();
    final Long domainId = ipAddress.getAllocatedInDomainId();

    _networkModel.checkIpForService(ipAddress, Service.StaticNat, null);

    final Network network = _networkModel.getNetwork(networkId);
    final NetworkOffering off = _entityMgr.findById(NetworkOffering.class, network.getNetworkOfferingId());
    if (off.getElasticIp()) {
        throw new InvalidParameterValueException("Can't create ip forwarding rules for the network where elasticIP service is enabled");
    }

    //String dstIp = _networkModel.getIpInNetwork(ipAddress.getAssociatedWithVmId(), networkId);
    final String dstIp = ipAddress.getVmIp();
    return Transaction.execute(new TransactionCallbackWithException<StaticNatRule, NetworkRuleConflictException>() {
        @Override
        public StaticNatRule doInTransaction(final TransactionStatus status) throws NetworkRuleConflictException {

            FirewallRuleVO newRule =
                    new FirewallRuleVO(rule.getXid(), rule.getSourceIpAddressId(), rule.getSourcePortStart(), rule.getSourcePortEnd(), rule.getProtocol().toLowerCase(),
                            networkId, accountId, domainId, rule.getPurpose(), null, null, null, null, null);

            newRule = _firewallDao.persist(newRule);

            // create firewallRule for 0.0.0.0/0 cidr
            if (openFirewall) {
                _firewallMgr.createRuleForAllCidrs(ipAddrId, caller, rule.getSourcePortStart(), rule.getSourcePortEnd(), rule.getProtocol(), null, null,
                        newRule.getId(), networkId);
            }

            try {
                _firewallMgr.detectRulesConflict(newRule);
                if (!_firewallDao.setStateToAdd(newRule)) {
                    throw new CloudRuntimeException("Unable to update the state to add for " + newRule);
                }
                CallContext.current().setEventDetails("Rule Id: " + newRule.getId());

                final StaticNatRule staticNatRule = new StaticNatRuleImpl(newRule, dstIp);

                return staticNatRule;
            } catch (final Exception e) {
                if (newRule != null) {
                    // no need to apply the rule as it wasn't programmed on the backend yet
                    _firewallMgr.revokeRelatedFirewallRule(newRule.getId(), false);
                    _firewallMgr.removeRule(newRule);
                }

                if (e instanceof NetworkRuleConflictException) {
                    throw (NetworkRuleConflictException) e;
                }
                throw new CloudRuntimeException("Unable to add static nat rule for the ip id=" + newRule.getSourceIpAddressId(), e);
            }
        }
    });
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@Override
public boolean disableStaticNat(final long ipId, final Account caller, final long callerUserId, final boolean releaseIpIfElastic) throws ResourceUnavailableException {
    boolean success = true;

    final IPAddressVO ipAddress = _ipAddressDao.findById(ipId);
    checkIpAndUserVm(ipAddress, null, caller, false);
    final long networkId = ipAddress.getAssociatedWithNetworkId();

    if (!ipAddress.isOneToOneNat()) {
        final InvalidParameterValueException ex = new InvalidParameterValueException("One to one nat is not enabled for the specified ip id");
        ex.addProxyObject(ipAddress.getUuid(), "ipId");
        throw ex;
    }

    // Revoke all firewall rules for the ip
    try {
        s_logger.debug("Revoking all " + Purpose.Firewall + "rules as a part of disabling static nat for public IP id=" + ipId);
        if (!_firewallMgr.revokeFirewallRulesForIp(ipId, callerUserId, caller)) {
            s_logger.warn("Unable to revoke all the firewall rules for ip id=" + ipId + " as a part of disable statis nat");
            success = false;
        }
    } catch (final ResourceUnavailableException e) {
        s_logger.warn("Unable to revoke all firewall rules for ip id=" + ipId + " as a part of ip release", e);
        success = false;
    }

    if (!revokeAllPFAndStaticNatRulesForIp(ipId, callerUserId, caller)) {
        s_logger.warn("Unable to revoke all static nat rules for ip " + ipAddress);
        success = false;
    }

    if (success) {
        final boolean isIpSystem = ipAddress.getSystem();
        ipAddress.setOneToOneNat(false);
        ipAddress.setAssociatedWithVmId(null);
        ipAddress.setVmIp(null);
        if (isIpSystem && !releaseIpIfElastic) {
            ipAddress.setSystem(false);
        }
        _ipAddressDao.update(ipAddress.getId(), ipAddress);
        _vpcMgr.unassignIPFromVpcNetwork(ipAddress.getId(), networkId);

        if (isIpSystem && releaseIpIfElastic && !_ipAddrMgr.handleSystemIpRelease(ipAddress)) {
            s_logger.warn("Failed to release system ip address " + ipAddress);
            success = false;
        }

        return true;
    } else {
        s_logger.warn("Failed to disable one to one nat for the ip address id" + ipId);
        return false;
    }
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@Override
@DB
public boolean disassociatePublicIpAddress(long addrId, long userId, Account caller) {

    boolean success = true;
    // Cleanup all ip address resources - PF/LB/Static nat rules
    if (!cleanupIpResources(addrId, userId, caller)) {
        success = false;
        s_logger.warn("Failed to release resources for ip address id=" + addrId);
    }

    IPAddressVO ip = markIpAsUnavailable(addrId);
    if (ip == null) {
        return true;
    }

    if (s_logger.isDebugEnabled()) {
        s_logger.debug("Releasing ip id=" + addrId + "; sourceNat = " + ip.isSourceNat());
    }

    if (ip.getAssociatedWithNetworkId() != null) {
        Network network = _networksDao.findById(ip.getAssociatedWithNetworkId());
        try {
            if (!applyIpAssociations(network, rulesContinueOnErrFlag)) {
                s_logger.warn("Unable to apply ip address associations for " + network);
                success = false;
            }
        } catch (ResourceUnavailableException e) {
            throw new CloudRuntimeException("We should never get to here because we used true when applyIpAssociations", e);
        }
    } else {
        if (ip.getState() == IpAddress.State.Releasing) {
            _ipAddressDao.unassignIpAddress(ip.getId());
        }
    }

    if (success) {
        if (ip.isPortable()) {
            releasePortableIpAddress(addrId);
        }
        s_logger.debug("Released a public ip id=" + addrId);
    }

    return success;
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
protected boolean updateIpResourceCount(IPAddressVO ip) {
    // don't increment resource count for direct and dedicated ip addresses
    return (ip.getAssociatedWithNetworkId() != null || ip.getVpcId() != null) && !isIpDedicated(ip);
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@DB
private boolean releaseIpAddressInternal(long ipAddressId) throws InsufficientAddressCapacityException {
    Long userId = CallContext.current().getCallingUserId();
    Account caller = CallContext.current().getCallingAccount();

    // Verify input parameters
    IPAddressVO ipVO = _ipAddressDao.findById(ipAddressId);
    if (ipVO == null) {
        throw new InvalidParameterValueException("Unable to find ip address by id");
    }

    if (ipVO.getAllocatedTime() == null) {
        s_logger.debug("Ip Address id= " + ipAddressId + " is not allocated, so do nothing.");
        return true;
    }

    // verify permissions
    if (ipVO.getAllocatedToAccountId() != null) {
        _accountMgr.checkAccess(caller, null, true, ipVO);
    }

    if (ipVO.isSourceNat()) {
        throw new IllegalArgumentException("ip address is used for source nat purposes and can not be disassociated.");
    }

    VlanVO vlan = _vlanDao.findById(ipVO.getVlanId());
    if (!vlan.getVlanType().equals(VlanType.VirtualNetwork)) {
        throw new IllegalArgumentException("only ip addresses that belong to a virtual network may be disassociated.");
    }

    // don't allow releasing system ip address
    if (ipVO.getSystem()) {
        throwInvalidIdException("Can't release system IP address with specified id", ipVO.getUuid(), "systemIpAddrId");
    }

    boolean success = _ipAddrMgr.disassociatePublicIpAddress(ipAddressId, userId, caller);

    if (success) {
        Long networkId = ipVO.getAssociatedWithNetworkId();
        if (networkId != null) {
            Network guestNetwork = getNetwork(networkId);
            NetworkOffering offering = _entityMgr.findById(NetworkOffering.class, guestNetwork.getNetworkOfferingId());
            Long vmId = ipVO.getAssociatedWithVmId();
            if (offering.getElasticIp() && vmId != null) {
                _rulesMgr.getSystemIpAndEnableStaticNatForVm(_userVmDao.findById(vmId), true);
                return true;
            }
        }
    } else {
        s_logger.warn("Failed to release public ip address id=" + ipAddressId);
    }
    return success;
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@Override
@DB
@ActionEvent(eventType = EventTypes.EVENT_NET_RULE_ADD, eventDescription = "creating static nat rule", create = true)
public StaticNatRule createStaticNatRule(final StaticNatRule rule, final boolean openFirewall) throws NetworkRuleConflictException {
    final Account caller = CallContext.current().getCallingAccount();

    final Long ipAddrId = rule.getSourceIpAddressId();

    IPAddressVO ipAddress = _ipAddressDao.findById(ipAddrId);

    // Validate ip address
    if (ipAddress == null) {
        throw new InvalidParameterValueException("Unable to create static nat rule; ip id=" + ipAddrId + " doesn't exist in the system");
    } else if (ipAddress.isSourceNat() || !ipAddress.isOneToOneNat() || ipAddress.getAssociatedWithVmId() == null) {
        throw new NetworkRuleConflictException("Can't do static nat on ip address: " + ipAddress.getAddress());
    }

    _firewallMgr.validateFirewallRule(caller, ipAddress, rule.getSourcePortStart(), rule.getSourcePortEnd(), rule.getProtocol(), Purpose.StaticNat,
        FirewallRuleType.User, null, rule.getTrafficType());

    final Long networkId = ipAddress.getAssociatedWithNetworkId();
    final Long accountId = ipAddress.getAllocatedToAccountId();
    final Long domainId = ipAddress.getAllocatedInDomainId();

    _networkModel.checkIpForService(ipAddress, Service.StaticNat, null);

    Network network = _networkModel.getNetwork(networkId);
    NetworkOffering off = _entityMgr.findById(NetworkOffering.class, network.getNetworkOfferingId());
    if (off.getElasticIp()) {
        throw new InvalidParameterValueException("Can't create ip forwarding rules for the network where elasticIP service is enabled");
    }

    //String dstIp = _networkModel.getIpInNetwork(ipAddress.getAssociatedWithVmId(), networkId);
    final String dstIp = ipAddress.getVmIp();
    return Transaction.execute(new TransactionCallbackWithException<StaticNatRule, NetworkRuleConflictException>() {
        @Override
        public StaticNatRule doInTransaction(TransactionStatus status) throws NetworkRuleConflictException {

            FirewallRuleVO newRule =
                new FirewallRuleVO(rule.getXid(), rule.getSourceIpAddressId(), rule.getSourcePortStart(), rule.getSourcePortEnd(), rule.getProtocol().toLowerCase(),
                    networkId, accountId, domainId, rule.getPurpose(), null, null, null, null, null);

            newRule = _firewallDao.persist(newRule);

            // create firewallRule for 0.0.0.0/0 cidr
            if (openFirewall) {
                _firewallMgr.createRuleForAllCidrs(ipAddrId, caller, rule.getSourcePortStart(), rule.getSourcePortEnd(), rule.getProtocol(), null, null,
                    newRule.getId(), networkId);
            }

            try {
                _firewallMgr.detectRulesConflict(newRule);
                if (!_firewallDao.setStateToAdd(newRule)) {
                    throw new CloudRuntimeException("Unable to update the state to add for " + newRule);
                }
                CallContext.current().setEventDetails("Rule Id: " + newRule.getId());
                UsageEventUtils.publishUsageEvent(EventTypes.EVENT_NET_RULE_ADD, newRule.getAccountId(), 0, newRule.getId(), null, FirewallRule.class.getName(),
                    newRule.getUuid());

                StaticNatRule staticNatRule = new StaticNatRuleImpl(newRule, dstIp);

                return staticNatRule;
            } catch (Exception e) {
                if (newRule != null) {
                    // no need to apply the rule as it wasn't programmed on the backend yet
                    _firewallMgr.revokeRelatedFirewallRule(newRule.getId(), false);
                    _firewallMgr.removeRule(newRule);
                }

                if (e instanceof NetworkRuleConflictException) {
                    throw (NetworkRuleConflictException)e;
                }
                throw new CloudRuntimeException("Unable to add static nat rule for the ip id=" + newRule.getSourceIpAddressId(), e);
            }
        }
    });

}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
protected void isIpReadyForStaticNat(long vmId, IPAddressVO ipAddress, String vmIp, Account caller, long callerUserId) throws NetworkRuleConflictException,
    ResourceUnavailableException {
    if (ipAddress.isSourceNat()) {
        throw new InvalidParameterValueException("Can't enable static, ip address " + ipAddress + " is a sourceNat ip address");
    }

    if (!ipAddress.isOneToOneNat()) { // Dont allow to enable static nat if PF/LB rules exist for the IP
        List<FirewallRuleVO> portForwardingRules = _firewallDao.listByIpAndPurposeAndNotRevoked(ipAddress.getId(), Purpose.PortForwarding);
        if (portForwardingRules != null && !portForwardingRules.isEmpty()) {
            throw new NetworkRuleConflictException("Failed to enable static nat for the ip address " + ipAddress + " as it already has PortForwarding rules assigned");
        }

        List<FirewallRuleVO> loadBalancingRules = _firewallDao.listByIpAndPurposeAndNotRevoked(ipAddress.getId(), Purpose.LoadBalancing);
        if (loadBalancingRules != null && !loadBalancingRules.isEmpty()) {
            throw new NetworkRuleConflictException("Failed to enable static nat for the ip address " + ipAddress + " as it already has LoadBalancing rules assigned");
        }
    } else if (ipAddress.getAssociatedWithVmId() != null && ipAddress.getAssociatedWithVmId().longValue() != vmId) {
        throw new NetworkRuleConflictException("Failed to enable static for the ip address " + ipAddress + " and vm id=" + vmId +
            " as it's already assigned to antoher vm");
    }

    //check wether the vm ip is alreday associated with any public ip address
    IPAddressVO oldIP = _ipAddressDao.findByAssociatedVmIdAndVmIp(vmId, vmIp);

    if (oldIP != null) {
        // If elasticIP functionality is supported in the network, we always have to disable static nat on the old
        // ip in order to re-enable it on the new one
        Long networkId = oldIP.getAssociatedWithNetworkId();
        VMInstanceVO vm = _vmInstanceDao.findById(vmId);

        boolean reassignStaticNat = false;
        if (networkId != null) {
            Network guestNetwork = _networkModel.getNetwork(networkId);
            NetworkOffering offering = _entityMgr.findById(NetworkOffering.class, guestNetwork.getNetworkOfferingId());
            if (offering.getElasticIp()) {
                reassignStaticNat = true;
            }
        }

        // If there is public ip address already associated with the vm, throw an exception
        if (!reassignStaticNat) {
            throw new InvalidParameterValueException("Failed to enable static nat on the  ip " +
                      ipAddress.getAddress()+" with Id " +ipAddress.getUuid()+" as the vm " +vm.getInstanceName() + " with Id " +
                    vm.getUuid() +" is already associated with another public ip " + oldIP.getAddress() +" with id "+
                    oldIP.getUuid());
        }
    // unassign old static nat rule
    s_logger.debug("Disassociating static nat for ip " + oldIP);
    if (!disableStaticNat(oldIP.getId(), caller, callerUserId, true)) {
            throw new CloudRuntimeException("Failed to disable old static nat rule for vm "+ vm.getInstanceName() +
                    " with id "+vm.getUuid() +"  and public ip " + oldIP);
        }
    }
}
 

import com.cloud.network.dao.IPAddressVO; //导入方法依赖的package包/类
@Override
public boolean disableStaticNat(long ipId, Account caller, long callerUserId, boolean releaseIpIfElastic) throws ResourceUnavailableException {
    boolean success = true;

    IPAddressVO ipAddress = _ipAddressDao.findById(ipId);
    checkIpAndUserVm(ipAddress, null, caller, false);
    long networkId = ipAddress.getAssociatedWithNetworkId();

    if (!ipAddress.isOneToOneNat()) {
        InvalidParameterValueException ex = new InvalidParameterValueException("One to one nat is not enabled for the specified ip id");
        ex.addProxyObject(ipAddress.getUuid(), "ipId");
        throw ex;
    }

    ipAddress.setRuleState(IpAddress.State.Releasing);
    _ipAddressDao.update(ipAddress.getId(), ipAddress);
    ipAddress = _ipAddressDao.findById(ipId);

    // Revoke all firewall rules for the ip
    try {
        s_logger.debug("Revoking all " + Purpose.Firewall + "rules as a part of disabling static nat for public IP id=" + ipId);
        if (!_firewallMgr.revokeFirewallRulesForIp(ipId, callerUserId, caller)) {
            s_logger.warn("Unable to revoke all the firewall rules for ip id=" + ipId + " as a part of disable statis nat");
            success = false;
        }
    } catch (ResourceUnavailableException e) {
        s_logger.warn("Unable to revoke all firewall rules for ip id=" + ipId + " as a part of ip release", e);
        success = false;
    }

    if (!revokeAllPFAndStaticNatRulesForIp(ipId, callerUserId, caller)) {
        s_logger.warn("Unable to revoke all static nat rules for ip " + ipAddress);
        success = false;
    }

    if (success) {
        boolean isIpSystem = ipAddress.getSystem();
        ipAddress.setOneToOneNat(false);
        ipAddress.setAssociatedWithVmId(null);
        ipAddress.setRuleState(null);
        ipAddress.setVmIp(null);
        if (isIpSystem && !releaseIpIfElastic) {
            ipAddress.setSystem(false);
        }
        _ipAddressDao.update(ipAddress.getId(), ipAddress);
        _vpcMgr.unassignIPFromVpcNetwork(ipAddress.getId(), networkId);

        if (isIpSystem && releaseIpIfElastic && !_ipAddrMgr.handleSystemIpRelease(ipAddress)) {
            s_logger.warn("Failed to release system ip address " + ipAddress);
            success = false;
        }

        return true;
    } else {
        s_logger.warn("Failed to disable one to one nat for the ip address id" + ipId);
        ipAddress = _ipAddressDao.findById(ipId);
        ipAddress.setRuleState(null);
        _ipAddressDao.update(ipAddress.getId(), ipAddress);
        return false;
    }
}