diff --git a/api/src/com/cloud/exception/RequestLimitException.java b/api/src/com/cloud/exception/RequestLimitException.java new file mode 100644 index 00000000000..0142f8e8726 --- /dev/null +++ b/api/src/com/cloud/exception/RequestLimitException.java @@ -0,0 +1,43 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.exception; + +import com.cloud.utils.SerialVersionUID; +import com.cloud.utils.exception.CloudRuntimeException; + +/** + * Exception thrown if number of requests is over api rate limit set. + * @author minc + * + */ +public class RequestLimitException extends CloudRuntimeException { + + private static final long serialVersionUID = SerialVersionUID.AccountLimitException; + + protected RequestLimitException() { + super(); + } + + public RequestLimitException(String msg) { + super(msg); + } + + public RequestLimitException(String msg, Throwable cause) { + super(msg, cause); + } + +} diff --git a/api/src/com/cloud/network/NetworkModel.java b/api/src/com/cloud/network/NetworkModel.java new file mode 100644 index 00000000000..9baa0ec435c --- /dev/null +++ b/api/src/com/cloud/network/NetworkModel.java @@ -0,0 +1,252 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import com.cloud.dc.Vlan; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.hypervisor.Hypervisor.HypervisorType; +import com.cloud.network.Network.Capability; +import com.cloud.network.Network.Provider; +import com.cloud.network.Network.Service; +import com.cloud.network.Networks.TrafficType; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.UserDataServiceProvider; +import com.cloud.offering.NetworkOffering; +import com.cloud.user.Account; +import com.cloud.vm.Nic; +import com.cloud.vm.NicProfile; +import com.cloud.vm.VirtualMachine; + + +/** + * The NetworkModel presents a read-only view into the Network data such as L2 networks, + * Nics, PublicIps, NetworkOfferings, traffic labels, physical networks and the like + * The idea is that only the orchestration core should be able to modify the data, while other + * participants in the orchestration can use this interface to query the data. + */ +public interface NetworkModel { + + /** + * Lists IP addresses that belong to VirtualNetwork VLANs + * + * @param accountId + * - account that the IP address should belong to + * @param associatedNetworkId + * TODO + * @param sourceNat + * - (optional) true if the IP address should be a source NAT address + * @return - list of IP addresses + */ + List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat); + + List getSystemAccountNetworkOfferings(String... offeringNames); + + List getNics(long vmId); + + String getNextAvailableMacAddressInNetwork(long networkConfigurationId) throws InsufficientAddressCapacityException; + + PublicIpAddress getPublicIpAddress(long ipAddressId); + + List listPodVlans(long podId); + + List listNetworksUsedByVm(long vmId, boolean isSystem); + + Nic getNicInNetwork(long vmId, long networkId); + + List getNicsForTraffic(long vmId, TrafficType type); + + Network getDefaultNetworkForVm(long vmId); + + Nic getDefaultNic(long vmId); + + UserDataServiceProvider getUserDataUpdateProvider(Network network); + + boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId); + + Map getNetworkServiceCapabilities(long networkId, Service service); + + boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services); + + Network getNetworkWithSecurityGroupEnabled(Long zoneId); + + String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId); + + List listNetworksForAccount(long accountId, long zoneId, Network.GuestType type); + + List listAllNetworksInAllZonesByType(Network.GuestType type); + + String getGlobalGuestDomainSuffix(); + + String getStartIpAddress(long networkId); + + String getIpInNetwork(long vmId, long networkId); + + String getIpInNetworkIncludingRemoved(long vmId, long networkId); + + Long getPodIdForVlan(long vlanDbId); + + List listNetworkOfferingsForUpgrade(long networkId); + + boolean isSecurityGroupSupportedInNetwork(Network network); + + boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider); + + boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName); + + String getNetworkTag(HypervisorType hType, Network network); + + List getElementServices(Provider provider); + + boolean canElementEnableIndividualServices(Provider provider); + + boolean areServicesSupportedInNetwork(long networkId, Service... services); + + boolean isNetworkSystem(Network network); + + Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service); + + Long getPhysicalNetworkId(Network network); + + boolean getAllowSubdomainAccessGlobal(); + + boolean isProviderForNetwork(Provider provider, long networkId); + + boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId); + + void canProviderSupportServices(Map> providersMap); + + List getPhysicalNetworkInfo(long dcId, HypervisorType hypervisorType); + + boolean canAddDefaultSecurityGroup(); + + List listNetworkOfferingServices(long networkOfferingId); + + boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services); + + Map> getIpToServices(List publicIps, boolean rulesRevoked, + boolean includingFirewall); + + Map> getProviderToIpList(Network network, Map> ipToServices); + + boolean checkIpForService(IpAddress ip, Service service, Long networkId); + + void checkCapabilityForProvider(Set providers, Service service, Capability cap, String capValue); + + Provider getDefaultUniqueProviderForService(String serviceName); + + void checkNetworkPermissions(Account owner, Network network); + + String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType); + + String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType); + + String getDefaultPublicTrafficLabel(long dcId, HypervisorType vmware); + + String getDefaultGuestTrafficLabel(long dcId, HypervisorType vmware); + + /** + * @param providerName + * @return + */ + NetworkElement getElementImplementingProvider(String providerName); + + /** + * @param accountId + * @param zoneId + * @return + */ + String getAccountNetworkDomain(long accountId, long zoneId); + + /** + * @return + */ + String getDefaultNetworkDomain(); + + /** + * @param ntwkOffId + * @return + */ + List getNtwkOffDistinctProviders(long ntwkOffId); + + /** + * @param accountId + * @param dcId + * @param sourceNat + * @return + */ + List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat); + + /** + * @param zoneId + * @param trafficType + * @return + */ + List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType); + + /** + * @param guestNic + * @return + */ + boolean isPrivateGateway(Nic guestNic); + + Map> getNetworkCapabilities(long networkId); + + Network getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType); + + Long getDedicatedNetworkDomain(long networkId); + + Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId); + + List listSupportedNetworkServiceProviders(String serviceName); + + List listNetworksByVpc(long vpcId); + + boolean canUseForDeploy(Network network); + + Network getExclusiveGuestNetwork(long zoneId); + + long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType); + + Integer getNetworkRate(long networkId, Long vmId); + + boolean isVmPartOfNetwork(long vmId, long ntwkId); + + PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType); + + Network getNetwork(long networkId); + + IpAddress getIp(long sourceIpAddressId); + + boolean isNetworkAvailableInDomain(long networkId, long domainId); + + NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri); + + Set getAvailableIps(Network network, String requestedIp); + + String getDomainNetworkDomain(long domainId, long zoneId); + + PublicIpAddress getSourceNatIpAddressForGuestNetwork(Account owner, Network guestNetwork); + + boolean isNetworkInlineMode(Network network); + +} \ No newline at end of file diff --git a/api/src/com/cloud/network/NetworkService.java b/api/src/com/cloud/network/NetworkService.java index b3332a345b3..786afb1e107 100755 --- a/api/src/com/cloud/network/NetworkService.java +++ b/api/src/com/cloud/network/NetworkService.java @@ -17,8 +17,6 @@ package com.cloud.network; import java.util.List; -import java.util.Map; -import java.util.Set; import org.apache.cloudstack.api.command.admin.usage.ListTrafficTypeImplementorsCmd; import org.apache.cloudstack.api.command.user.network.RestartNetworkCmd; @@ -29,14 +27,17 @@ import com.cloud.exception.InsufficientAddressCapacityException; import com.cloud.exception.InsufficientCapacityException; import com.cloud.exception.ResourceAllocationException; import com.cloud.exception.ResourceUnavailableException; -import com.cloud.network.Network.Capability; -import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.Networks.TrafficType; import com.cloud.user.Account; import com.cloud.user.User; import com.cloud.utils.Pair; +/** + * The NetworkService interface is the "public" api to entities that make requests to the orchestration engine + * Such entities are usually the admin and end-user API. + * + */ public interface NetworkService { List getIsolatedNetworksOwnedByAccountInZone(long zoneId, Account owner); @@ -64,24 +65,12 @@ public interface NetworkService { IpAddress getIp(long id); - NetworkProfile convertNetworkToNetworkProfile(long networkId); - - Map> getNetworkCapabilities(long networkId); - - boolean isNetworkAvailableInDomain(long networkId, long domainId); - - Long getDedicatedNetworkDomain(long networkId); Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr); - Integer getNetworkRate(long networkId, Long vmId); - Network getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType); - - Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId); - - PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, + PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, List isolationMethods, String broadcastDomainRange, Long domainId, List tags, String name); Pair, Integer> searchPhysicalNetworks(Long id, Long zoneId, String keyword, @@ -94,8 +83,6 @@ public interface NetworkService { List listNetworkServices(String providerName); - List listSupportedNetworkServiceProviders(String serviceName); - PhysicalNetworkServiceProvider addProviderToPhysicalNetwork(Long physicalNetworkId, String providerName, Long destinationPhysicalNetworkId, List enabledServices); @@ -127,17 +114,14 @@ public interface NetworkService { Pair, Integer> listTrafficTypes(Long physicalNetworkId); - PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType); Network getExclusiveGuestNetwork(long zoneId); List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd); List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner); - - List listNetworksByVpc(long vpcId); - - boolean isVmPartOfNetwork(long vmId, long ntwkId); + + /** * @param networkId @@ -170,9 +154,5 @@ public interface NetworkService { Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, String vlan, String startIp, String endIP, String gateway, String netmask, long networkOwnerId, Long vpcId) throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException; - /** - * @param network - * @return - */ - boolean canUseForDeploy(Network network); + } diff --git a/api/src/com/cloud/network/element/IpDeployer.java b/api/src/com/cloud/network/element/IpDeployer.java index 55b21abe9ab..c92d3e3cf2d 100644 --- a/api/src/com/cloud/network/element/IpDeployer.java +++ b/api/src/com/cloud/network/element/IpDeployer.java @@ -24,8 +24,9 @@ import com.cloud.network.Network; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.PublicIpAddress; +import com.cloud.utils.component.Adapter; -public interface IpDeployer { +public interface IpDeployer extends Adapter{ /** * Apply ip addresses to this network * @param network diff --git a/api/src/com/cloud/network/element/RemoteAccessVPNServiceProvider.java b/api/src/com/cloud/network/element/RemoteAccessVPNServiceProvider.java index 4625d22f6a5..4950ed92cab 100644 --- a/api/src/com/cloud/network/element/RemoteAccessVPNServiceProvider.java +++ b/api/src/com/cloud/network/element/RemoteAccessVPNServiceProvider.java @@ -22,8 +22,9 @@ import com.cloud.exception.ResourceUnavailableException; import com.cloud.network.Network; import com.cloud.network.RemoteAccessVpn; import com.cloud.network.VpnUser; +import com.cloud.utils.component.Adapter; -public interface RemoteAccessVPNServiceProvider extends NetworkElement, IpDeployingRequester { +public interface RemoteAccessVPNServiceProvider extends Adapter { String[] applyVpnUsers(RemoteAccessVpn vpn, List users) throws ResourceUnavailableException; boolean startVpn(Network network, RemoteAccessVpn vpn) throws ResourceUnavailableException; diff --git a/api/src/com/cloud/network/element/Site2SiteVpnServiceProvider.java b/api/src/com/cloud/network/element/Site2SiteVpnServiceProvider.java index a61273a8159..dd451324a72 100644 --- a/api/src/com/cloud/network/element/Site2SiteVpnServiceProvider.java +++ b/api/src/com/cloud/network/element/Site2SiteVpnServiceProvider.java @@ -17,10 +17,10 @@ package com.cloud.network.element; import com.cloud.exception.ResourceUnavailableException; -import com.cloud.network.Network; import com.cloud.network.Site2SiteVpnConnection; +import com.cloud.utils.component.Adapter; -public interface Site2SiteVpnServiceProvider extends NetworkElement { +public interface Site2SiteVpnServiceProvider extends Adapter { boolean startSite2SiteVpn(Site2SiteVpnConnection conn) throws ResourceUnavailableException; boolean stopSite2SiteVpn(Site2SiteVpnConnection conn) throws ResourceUnavailableException; diff --git a/api/src/com/cloud/server/ManagementService.java b/api/src/com/cloud/server/ManagementService.java index fb8af1a5b4b..5302daa493b 100755 --- a/api/src/com/cloud/server/ManagementService.java +++ b/api/src/com/cloud/server/ManagementService.java @@ -25,6 +25,7 @@ import java.util.Set; import com.cloud.alert.Alert; import org.apache.cloudstack.api.ServerApiException; import org.apache.cloudstack.api.command.admin.cluster.ListClustersCmd; +import org.apache.cloudstack.api.command.admin.host.ListHostsCmd; import org.apache.cloudstack.api.command.admin.host.UpdateHostPasswordCmd; import org.apache.cloudstack.api.command.admin.pod.ListPodsByCmd; import org.apache.cloudstack.api.command.admin.resource.ListAlertsCmd; @@ -140,6 +141,14 @@ public interface ManagementService { */ Pair, Integer> searchForPods(ListPodsByCmd cmd); + /** + * Searches for servers by the specified search criteria Can search by: "name", "type", "state", "dataCenterId", + * "podId" + * + * @param cmd + * @return List of Hosts + */ + Pair, Integer> searchForServers(ListHostsCmd cmd); /** * Creates a new template @@ -384,7 +393,7 @@ public interface ManagementService { * @return Pair, List> List of all Hosts in VM's cluster and list of Hosts with * enough capacity */ - Pair, List> listHostsForMigrationOfVM(Long vmId, Long startIndex, Long pageSize); + Pair, Integer>, List> listHostsForMigrationOfVM(Long vmId, Long startIndex, Long pageSize); String[] listEventTypes(); diff --git a/api/src/org/apache/cloudstack/acl/APIChecker.java b/api/src/org/apache/cloudstack/acl/APIChecker.java index 0d0dfd1be4e..2e2b73ba782 100644 --- a/api/src/org/apache/cloudstack/acl/APIChecker.java +++ b/api/src/org/apache/cloudstack/acl/APIChecker.java @@ -17,6 +17,7 @@ package org.apache.cloudstack.acl; import com.cloud.exception.PermissionDeniedException; +import com.cloud.exception.RequestLimitException; import com.cloud.user.User; import com.cloud.utils.component.Adapter; @@ -26,5 +27,5 @@ public interface APIChecker extends Adapter { // If true, apiChecker has checked the operation // If false, apiChecker is unable to handle the operation or not implemented // On exception, checkAccess failed don't allow - boolean checkAccess(User user, String apiCommandName) throws PermissionDeniedException; + boolean checkAccess(User user, String apiCommandName) throws PermissionDeniedException, RequestLimitException; } diff --git a/api/src/org/apache/cloudstack/acl/APILimitChecker.java b/api/src/org/apache/cloudstack/acl/APILimitChecker.java new file mode 100644 index 00000000000..110742c059d --- /dev/null +++ b/api/src/org/apache/cloudstack/acl/APILimitChecker.java @@ -0,0 +1,30 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.acl; + +import org.apache.cloudstack.api.ServerApiException; + +import com.cloud.user.Account; +import com.cloud.utils.component.Adapter; + +/** + * APILimitChecker checks if we should block an API request based on pre-set account based api limit. + */ +public interface APILimitChecker extends Adapter { + // Interface for checking if the account is over its api limit + void checkLimit(Account account) throws ServerApiException; +} diff --git a/api/src/org/apache/cloudstack/api/command/admin/host/ListHostsCmd.java b/api/src/org/apache/cloudstack/api/command/admin/host/ListHostsCmd.java index 82f329f4b7e..876da9a6bda 100644 --- a/api/src/org/apache/cloudstack/api/command/admin/host/ListHostsCmd.java +++ b/api/src/org/apache/cloudstack/api/command/admin/host/ListHostsCmd.java @@ -168,17 +168,16 @@ public class ListHostsCmd extends BaseListCmd { if (getVirtualMachineId() == null) { response = _queryService.searchForServers(this); } else { - List result = new ArrayList(); + Pair,Integer> result; List hostsWithCapacity = new ArrayList(); - Pair, List> hostsForMigration = _mgr.listHostsForMigrationOfVM(getVirtualMachineId(), - this.getStartIndex(), this.getPageSizeVal()); + Pair,Integer>, List> hostsForMigration = _mgr.listHostsForMigrationOfVM(getVirtualMachineId(), this.getStartIndex(), this.getPageSizeVal()); result = hostsForMigration.first(); hostsWithCapacity = hostsForMigration.second(); response = new ListResponse(); List hostResponses = new ArrayList(); - for (Host host : result) { + for (Host host : result.first()) { HostResponse hostResponse = _responseGenerator.createHostResponse(host, getDetails()); Boolean suitableForMigration = false; if (hostsWithCapacity.contains(host)) { @@ -189,7 +188,7 @@ public class ListHostsCmd extends BaseListCmd { hostResponses.add(hostResponse); } - response.setResponses(hostResponses); + response.setResponses(hostResponses, result.second()); } response.setResponseName(getCommandName()); this.setResponseObject(response); diff --git a/client/pom.xml b/client/pom.xml index 1bbae1f7d08..7ebe50c48f9 100644 --- a/client/pom.xml +++ b/client/pom.xml @@ -30,6 +30,11 @@ cloud-plugin-acl-static-role-based ${project.version} + + org.apache.cloudstack + cloud-plugin-api-limit-account-based + ${project.version} + org.apache.cloudstack cloud-plugin-api-discovery diff --git a/client/tomcatconf/commands.properties.in b/client/tomcatconf/commands.properties.in index 91b99dd34da..d13ccb0a5ee 100644 --- a/client/tomcatconf/commands.properties.in +++ b/client/tomcatconf/commands.properties.in @@ -513,3 +513,8 @@ configureSimulator=1 #### api discovery commands listApis=15 + +#### API Rate Limit service command + +getApiLimit=15 +resetApiLimit=1 diff --git a/client/tomcatconf/components.xml.in b/client/tomcatconf/components.xml.in index bb39839c820..c41d4f4f18f 100755 --- a/client/tomcatconf/components.xml.in +++ b/client/tomcatconf/components.xml.in @@ -54,6 +54,11 @@ under the License. true + + 1 + 25 + 50000 + @@ -162,6 +167,59 @@ under the License. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -180,6 +238,7 @@ under the License. + diff --git a/core/src/com/cloud/network/resource/TrafficSentinelResource.java b/core/src/com/cloud/network/resource/TrafficSentinelResource.java index a13e080b7e4..22deccffdd5 100644 --- a/core/src/com/cloud/network/resource/TrafficSentinelResource.java +++ b/core/src/com/cloud/network/resource/TrafficSentinelResource.java @@ -108,7 +108,7 @@ public class TrafficSentinelResource implements ServerResource { cmd.setPod(""); cmd.setPrivateIpAddress(_ip); cmd.setStorageIpAddress(""); - cmd.setVersion(""); + cmd.setVersion(TrafficSentinelResource.class.getPackage().getImplementationVersion()); cmd.setGuid(_guid); return new StartupCommand[]{cmd}; } diff --git a/patches/systemvm/debian/config/opt/cloud/bin/checkbatchs2svpn.sh b/patches/systemvm/debian/config/opt/cloud/bin/checkbatchs2svpn.sh new file mode 100755 index 00000000000..80e3213753b --- /dev/null +++ b/patches/systemvm/debian/config/opt/cloud/bin/checkbatchs2svpn.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +for i in $* +do + info=`/opt/cloud/bin/checks2svpn.sh $i` + ret=$? + echo -n "$i:$ret:$info&" +done + diff --git a/plugins/api/rate-limit/pom.xml b/plugins/api/rate-limit/pom.xml new file mode 100644 index 00000000000..1f0330916a9 --- /dev/null +++ b/plugins/api/rate-limit/pom.xml @@ -0,0 +1,51 @@ + + + 4.0.0 + cloud-plugin-api-limit-account-based + Apache CloudStack Plugin - API Rate Limit + + org.apache.cloudstack + cloudstack-plugins + 4.1.0-SNAPSHOT + ../../pom.xml + + + install + src + test + + + test/resources + + + + + org.apache.maven.plugins + maven-surefire-plugin + + -Xmx1024m + + org/apache/cloudstack/ratelimit/integration/* + + + + + + diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/api/command/admin/ratelimit/ResetApiLimitCmd.java b/plugins/api/rate-limit/src/org/apache/cloudstack/api/command/admin/ratelimit/ResetApiLimitCmd.java new file mode 100644 index 00000000000..58cab186570 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/api/command/admin/ratelimit/ResetApiLimitCmd.java @@ -0,0 +1,99 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.api.command.admin.ratelimit; + +import org.apache.cloudstack.api.ACL; +import org.apache.cloudstack.api.APICommand; +import org.apache.cloudstack.api.ApiConstants; +import org.apache.cloudstack.api.ApiErrorCode; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.Parameter; +import org.apache.cloudstack.api.PlugService; +import org.apache.cloudstack.api.ServerApiException; +import org.apache.cloudstack.api.response.AccountResponse; +import org.apache.cloudstack.api.response.ApiLimitResponse; +import org.apache.cloudstack.api.response.SuccessResponse; +import org.apache.cloudstack.ratelimit.ApiRateLimitService; +import org.apache.log4j.Logger; + +import com.cloud.user.Account; +import com.cloud.user.UserContext; + +@APICommand(name = "resetApiLimit", responseObject=ApiLimitResponse.class, description="Reset api count") +public class ResetApiLimitCmd extends BaseCmd { + private static final Logger s_logger = Logger.getLogger(ResetApiLimitCmd.class.getName()); + + private static final String s_name = "resetapilimitresponse"; + + @PlugService + ApiRateLimitService _apiLimitService; + + ///////////////////////////////////////////////////// + //////////////// API parameters ///////////////////// + ///////////////////////////////////////////////////// + + @ACL + @Parameter(name=ApiConstants.ACCOUNT, type=CommandType.UUID, entityType=AccountResponse.class, + description="the ID of the acount whose limit to be reset") + private Long accountId; + + ///////////////////////////////////////////////////// + /////////////////// Accessors /////////////////////// + ///////////////////////////////////////////////////// + + + public Long getAccountId() { + return accountId; + } + + + public void setAccountId(Long accountId) { + this.accountId = accountId; + } + + + ///////////////////////////////////////////////////// + /////////////// API Implementation/////////////////// + ///////////////////////////////////////////////////// + + + @Override + public String getCommandName() { + return s_name; + } + + @Override + public long getEntityOwnerId() { + Account account = UserContext.current().getCaller(); + if (account != null) { + return account.getId(); + } + + return Account.ACCOUNT_ID_SYSTEM; // no account info given, parent this command to SYSTEM so ERROR events are tracked + } + + @Override + public void execute(){ + boolean result = _apiLimitService.resetApiLimit(this.accountId); + if (result) { + SuccessResponse response = new SuccessResponse(getCommandName()); + this.setResponseObject(response); + } else { + throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to reset api limit counter"); + } + } +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/api/command/user/ratelimit/GetApiLimitCmd.java b/plugins/api/rate-limit/src/org/apache/cloudstack/api/command/user/ratelimit/GetApiLimitCmd.java new file mode 100644 index 00000000000..2b7b8e6dbc1 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/api/command/user/ratelimit/GetApiLimitCmd.java @@ -0,0 +1,89 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.api.command.user.ratelimit; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.cloudstack.api.ACL; +import org.apache.cloudstack.api.ApiConstants; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.BaseListCmd; +import org.apache.cloudstack.api.Parameter; +import org.apache.cloudstack.api.PlugService; +import org.apache.cloudstack.api.ServerApiException; +import org.apache.cloudstack.api.BaseCmd.CommandType; +import org.apache.cloudstack.api.command.admin.ratelimit.ResetApiLimitCmd; +import org.apache.cloudstack.api.response.AccountResponse; +import org.apache.cloudstack.api.response.ApiLimitResponse; +import org.apache.cloudstack.api.response.PhysicalNetworkResponse; +import org.apache.log4j.Logger; + +import org.apache.cloudstack.api.APICommand; +import org.apache.cloudstack.api.response.ListResponse; +import org.apache.cloudstack.ratelimit.ApiRateLimitService; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.InvalidParameterValueException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.user.Account; +import com.cloud.user.UserContext; +import com.cloud.utils.exception.CloudRuntimeException; + +@APICommand(name = "getApiLimit", responseObject=ApiLimitResponse.class, description="Get API limit count for the caller") +public class GetApiLimitCmd extends BaseCmd { + private static final Logger s_logger = Logger.getLogger(GetApiLimitCmd.class.getName()); + + private static final String s_name = "getapilimitresponse"; + + @PlugService + ApiRateLimitService _apiLimitService; + + + + + ///////////////////////////////////////////////////// + /////////////// API Implementation/////////////////// + ///////////////////////////////////////////////////// + + @Override + public String getCommandName() { + return s_name; + } + + @Override + public long getEntityOwnerId() { + Account account = UserContext.current().getCaller(); + if (account != null) { + return account.getId(); + } + + return Account.ACCOUNT_ID_SYSTEM; // no account info given, parent this command to SYSTEM so ERROR events are tracked + } + + @Override + public void execute(){ + Account caller = UserContext.current().getCaller(); + ApiLimitResponse response = _apiLimitService.searchApiLimit(caller); + response.setResponseName(getCommandName()); + response.setObjectName("apilimit"); + this.setResponseObject(response); + } +} + + diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/api/response/ApiLimitResponse.java b/plugins/api/rate-limit/src/org/apache/cloudstack/api/response/ApiLimitResponse.java new file mode 100644 index 00000000000..245e8f15d8a --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/api/response/ApiLimitResponse.java @@ -0,0 +1,82 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.api.response; + +import org.apache.cloudstack.api.ApiConstants; +import com.cloud.serializer.Param; +import com.google.gson.annotations.SerializedName; +import org.apache.cloudstack.api.BaseResponse; + + +public class ApiLimitResponse extends BaseResponse { + @SerializedName(ApiConstants.ACCOUNT_ID) @Param(description="the account uuid of the api remaining count") + private String accountId; + + @SerializedName(ApiConstants.ACCOUNT) @Param(description="the account name of the api remaining count") + private String accountName; + + @SerializedName("apiIssued") @Param(description="number of api already issued") + private int apiIssued; + + @SerializedName("apiAllowed") @Param(description="currently allowed number of apis") + private int apiAllowed; + + @SerializedName("expireAfter") @Param(description="seconds left to reset counters") + private long expireAfter; + + public void setAccountId(String accountId) { + this.accountId = accountId; + } + + public void setAccountName(String accountName) { + this.accountName = accountName; + } + + public void setApiIssued(int apiIssued) { + this.apiIssued = apiIssued; + } + + public void setApiAllowed(int apiAllowed) { + this.apiAllowed = apiAllowed; + } + + public void setExpireAfter(long duration) { + this.expireAfter = duration; + } + + public String getAccountId() { + return accountId; + } + + public String getAccountName() { + return accountName; + } + + public int getApiIssued() { + return apiIssued; + } + + public int getApiAllowed() { + return apiAllowed; + } + + public long getExpireAfter() { + return expireAfter; + } + + +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/ApiRateLimitService.java b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/ApiRateLimitService.java new file mode 100644 index 00000000000..c5b715019b6 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/ApiRateLimitService.java @@ -0,0 +1,37 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +import org.apache.cloudstack.api.response.ApiLimitResponse; +import com.cloud.user.Account; +import com.cloud.utils.component.PluggableService; + +/** + * Provide API rate limit service + * @author minc + * + */ +public interface ApiRateLimitService extends PluggableService{ + + public ApiLimitResponse searchApiLimit(Account caller); + + public boolean resetApiLimit(Long accountId); + + public void setTimeToLive(int timeToLive); + + public void setMaxAllowed(int max); +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/ApiRateLimitServiceImpl.java b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/ApiRateLimitServiceImpl.java new file mode 100644 index 00000000000..303b92da5ed --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/ApiRateLimitServiceImpl.java @@ -0,0 +1,196 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import net.sf.ehcache.Cache; +import net.sf.ehcache.CacheManager; + +import org.apache.log4j.Logger; + +import org.apache.cloudstack.acl.APIChecker; +import org.apache.cloudstack.api.command.admin.ratelimit.ResetApiLimitCmd; +import org.apache.cloudstack.api.command.user.ratelimit.GetApiLimitCmd; +import org.apache.cloudstack.api.response.ApiLimitResponse; + +import com.cloud.exception.PermissionDeniedException; +import com.cloud.exception.RequestLimitException; +import com.cloud.user.Account; +import com.cloud.user.AccountService; +import com.cloud.user.User; +import com.cloud.utils.component.AdapterBase; +import com.cloud.utils.component.Inject; + +@Local(value = APIChecker.class) +public class ApiRateLimitServiceImpl extends AdapterBase implements APIChecker, ApiRateLimitService { + private static final Logger s_logger = Logger.getLogger(ApiRateLimitServiceImpl.class); + + /** + * Fixed time duration where api rate limit is set, in seconds + */ + private int timeToLive = 1; + + /** + * Max number of api requests during timeToLive duration. + */ + private int maxAllowed = 30; + + private LimitStore _store = null; + + @Inject + AccountService _accountService; + + + + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + super.configure(name, params); + + if (_store == null) { + // not configured yet, note that since this class is both adapter + // and pluggableService, so this method + // may be invoked twice in ComponentLocator. + // get global configured duration and max values + Object duration = params.get("api.throttling.interval"); + if (duration != null) { + timeToLive = Integer.parseInt((String) duration); + } + Object maxReqs = params.get("api.throttling.max"); + if (maxReqs != null) { + maxAllowed = Integer.parseInt((String) maxReqs); + } + // create limit store + EhcacheLimitStore cacheStore = new EhcacheLimitStore(); + int maxElements = 10000; + Object cachesize = params.get("api.throttling.cachesize"); + if ( cachesize != null ){ + maxElements = Integer.parseInt((String)cachesize); + } + CacheManager cm = CacheManager.create(); + Cache cache = new Cache("api-limit-cache", maxElements, false, false, timeToLive, timeToLive); + cm.addCache(cache); + s_logger.info("Limit Cache created with timeToLive=" + timeToLive + ", maxAllowed=" + maxAllowed + ", maxElements=" + maxElements ); + cacheStore.setCache(cache); + _store = cacheStore; + + } + + return true; + + } + + + + @Override + public ApiLimitResponse searchApiLimit(Account caller) { + ApiLimitResponse response = new ApiLimitResponse(); + response.setAccountId(caller.getUuid()); + response.setAccountName(caller.getAccountName()); + StoreEntry entry = _store.get(caller.getId()); + if (entry == null) { + + /* Populate the entry, thus unlocking any underlying mutex */ + entry = _store.create(caller.getId(), timeToLive); + response.setApiIssued(0); + response.setApiAllowed(maxAllowed); + response.setExpireAfter(timeToLive); + } + else{ + response.setApiIssued(entry.getCounter()); + response.setApiAllowed(maxAllowed - entry.getCounter()); + response.setExpireAfter(entry.getExpireDuration()); + } + + return response; + } + + + + @Override + public boolean resetApiLimit(Long accountId) { + if ( accountId != null ){ + _store.create(accountId, timeToLive); + } + else{ + _store.resetCounters(); + } + return true; + } + + + + @Override + public boolean checkAccess(User user, String apiCommandName) throws PermissionDeniedException, RequestLimitException { + Long accountId = user.getAccountId(); + Account account = _accountService.getAccount(accountId); + if ( _accountService.isRootAdmin(account.getType())){ + // no API throttling on root admin + return true; + } + StoreEntry entry = _store.get(accountId); + + if (entry == null) { + + /* Populate the entry, thus unlocking any underlying mutex */ + entry = _store.create(accountId, timeToLive); + } + + /* Increment the client count and see whether we have hit the maximum allowed clients yet. */ + int current = entry.incrementAndGet(); + + if (current <= maxAllowed) { + s_logger.trace("account (" + account.getAccountId() + "," + account.getAccountName() + ") has current count = " + current); + return true; + } else { + long expireAfter = entry.getExpireDuration(); + // for this exception, we can just show the same message to user and admin users. + String msg = "The given user has reached his/her account api limit, please retry after " + expireAfter + " ms."; + s_logger.warn(msg); + throw new RequestLimitException(msg); + } + } + + + @Override + public List> getCommands() { + List> cmdList = new ArrayList>(); + cmdList.add(ResetApiLimitCmd.class); + cmdList.add(GetApiLimitCmd.class); + return cmdList; + } + + + @Override + public void setTimeToLive(int timeToLive) { + this.timeToLive = timeToLive; + } + + + + @Override + public void setMaxAllowed(int max) { + this.maxAllowed = max; + + } + + +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/EhcacheLimitStore.java b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/EhcacheLimitStore.java new file mode 100644 index 00000000000..659cf81b0e6 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/EhcacheLimitStore.java @@ -0,0 +1,99 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +import net.sf.ehcache.Ehcache; +import net.sf.ehcache.Element; +import net.sf.ehcache.constructs.blocking.BlockingCache; +import net.sf.ehcache.constructs.blocking.LockTimeoutException; + +/** + * A Limit store implementation using Ehcache. + * @author minc + * + */ +public class EhcacheLimitStore implements LimitStore { + + + private BlockingCache cache; + + + public void setCache(Ehcache cache) { + BlockingCache ref; + + if (!(cache instanceof BlockingCache)) { + ref = new BlockingCache(cache); + cache.getCacheManager().replaceCacheWithDecoratedCache(cache, new BlockingCache(cache)); + } else { + ref = (BlockingCache) cache; + } + + this.cache = ref; + } + + + @Override + public StoreEntry create(Long key, int timeToLive) { + StoreEntryImpl result = new StoreEntryImpl(timeToLive); + Element element = new Element(key, result); + element.setTimeToLive(timeToLive); + cache.put(element); + return result; + } + + @Override + public StoreEntry get(Long key) { + + Element entry = null; + + try { + + /* This may block. */ + entry = cache.get(key); + } catch (LockTimeoutException e) { + throw new RuntimeException(); + } catch (RuntimeException e) { + + /* Release the lock that may have been acquired. */ + cache.put(new Element(key, null)); + } + + StoreEntry result = null; + + if (entry != null) { + + /* + * We don't need to check isExpired() on the result, since ehcache takes care of expiring entries for us. + * c.f. the get(Key) implementation in this class. + */ + result = (StoreEntry) entry.getObjectValue(); + } + + return result; + } + + + + @Override + public void resetCounters() { + cache.removeAll(); + + } + + + +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/LimitStore.java b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/LimitStore.java new file mode 100644 index 00000000000..a5e086b3029 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/LimitStore.java @@ -0,0 +1,51 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +import com.cloud.user.Account; + +/** + * Interface to define how an api limit store should work. + * @author minc + * + */ +public interface LimitStore { + + /** + * Returns a store entry for the given account. A value of null means that there is no + * such entry and the calling client must call create to avoid + * other clients potentially being blocked without any hope of progressing. A non-null + * entry means that it has not expired and can be used to determine whether the current client should be allowed to + * proceed with the rate-limited action or not. + * + */ + StoreEntry get(Long account); + + /** + * Creates a new store entry + * + * @param account + * the user account, key to the store + * @param timeToLiveInSecs + * the positive time-to-live in seconds + * @return a non-null entry + */ + StoreEntry create(Long account, int timeToLiveInSecs); + + void resetCounters(); + +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/StoreEntry.java b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/StoreEntry.java new file mode 100644 index 00000000000..76e8a2d9281 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/StoreEntry.java @@ -0,0 +1,33 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +/** + * Interface for each entry in LimitStore. + * @author minc + * + */ +public interface StoreEntry { + + int getCounter(); + + int incrementAndGet(); + + boolean isExpired(); + + long getExpireDuration(); /* seconds to reset counter */ +} diff --git a/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/StoreEntryImpl.java b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/StoreEntryImpl.java new file mode 100644 index 00000000000..e8143e52370 --- /dev/null +++ b/plugins/api/rate-limit/src/org/apache/cloudstack/ratelimit/StoreEntryImpl.java @@ -0,0 +1,64 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Implementation of limit store entry. + * @author minc + * + */ +public class StoreEntryImpl implements StoreEntry { + + private final long expiry; + + private final AtomicInteger counter; + + StoreEntryImpl(int timeToLive) { + this.expiry = System.currentTimeMillis() + timeToLive * 1000; + this.counter = new AtomicInteger(0); + } + + + @Override + public boolean isExpired() { + return System.currentTimeMillis() > expiry; + } + + + + @Override + public long getExpireDuration() { + if ( isExpired() ) + return 0; // already expired + else { + return expiry - System.currentTimeMillis(); + } + } + + + @Override + public int incrementAndGet() { + return this.counter.incrementAndGet(); + } + + @Override + public int getCounter(){ + return this.counter.get(); + } +} diff --git a/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/ApiRateLimitTest.java b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/ApiRateLimitTest.java new file mode 100644 index 00000000000..85eeaaf4223 --- /dev/null +++ b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/ApiRateLimitTest.java @@ -0,0 +1,226 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit; + +import java.util.Collections; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.api.response.ApiLimitResponse; +import org.apache.cloudstack.ratelimit.ApiRateLimitServiceImpl; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +import com.cloud.exception.RequestLimitException; +import com.cloud.user.Account; +import com.cloud.user.AccountService; +import com.cloud.user.AccountVO; +import com.cloud.user.User; +import com.cloud.user.UserVO; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +public class ApiRateLimitTest { + + static ApiRateLimitServiceImpl _limitService = new ApiRateLimitServiceImpl(); + static AccountService _accountService = mock(AccountService.class); + private static long acctIdSeq = 5L; + private static Account testAccount; + + @BeforeClass + public static void setUp() throws ConfigurationException { + + _limitService.configure("ApiRateLimitTest", Collections. emptyMap()); + + _limitService._accountService = _accountService; + + // Standard responses + AccountVO acct = new AccountVO(acctIdSeq); + acct.setType(Account.ACCOUNT_TYPE_NORMAL); + acct.setAccountName("demo"); + testAccount = acct; + + when(_accountService.getAccount(5L)).thenReturn(testAccount); + when(_accountService.isRootAdmin(Account.ACCOUNT_TYPE_NORMAL)).thenReturn(false); + } + + @Before + public void testSetUp() { + // reset counter for each test + _limitService.resetApiLimit(null); + } + + private User createFakeUser(){ + UserVO user = new UserVO(); + user.setAccountId(acctIdSeq); + return user; + } + + private boolean isUnderLimit(User key){ + try{ + _limitService.checkAccess(key, null); + return true; + } + catch (RequestLimitException ex){ + return false; + } + } + + @Test + public void sequentialApiAccess() { + int allowedRequests = 1; + _limitService.setMaxAllowed(allowedRequests); + _limitService.setTimeToLive(1); + + User key = createFakeUser(); + assertTrue("Allow for the first request", isUnderLimit(key)); + + assertFalse("Second request should be blocked, since we assume that the two api " + + " accesses take less than a second to perform", isUnderLimit(key)); + } + + @Test + public void canDoReasonableNumberOfApiAccessPerSecond() throws Exception { + int allowedRequests = 200; + _limitService.setMaxAllowed(allowedRequests); + _limitService.setTimeToLive(1); + + User key = createFakeUser(); + + for (int i = 0; i < allowedRequests; i++) { + assertTrue("We should allow " + allowedRequests + " requests per second, but failed at request " + i, isUnderLimit(key)); + } + + + assertFalse("We should block >" + allowedRequests + " requests per second", isUnderLimit(key)); + } + + @Test + public void multipleClientsCanAccessWithoutBlocking() throws Exception { + int allowedRequests = 200; + _limitService.setMaxAllowed(allowedRequests); + _limitService.setTimeToLive(1); + + + final User key = createFakeUser(); + + int clientCount = allowedRequests; + Runnable[] clients = new Runnable[clientCount]; + final boolean[] isUsable = new boolean[clientCount]; + + final CountDownLatch startGate = new CountDownLatch(1); + + final CountDownLatch endGate = new CountDownLatch(clientCount); + + + for (int i = 0; i < isUsable.length; ++i) { + final int j = i; + clients[j] = new Runnable() { + + /** + * {@inheritDoc} + */ + @Override + public void run() { + try { + startGate.await(); + + isUsable[j] = isUnderLimit(key); + + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + endGate.countDown(); + } + } + }; + } + + ExecutorService executor = Executors.newFixedThreadPool(clientCount); + + for (Runnable runnable : clients) { + executor.execute(runnable); + } + + startGate.countDown(); + + endGate.await(); + + for (boolean b : isUsable) { + assertTrue("Concurrent client request should be allowed within limit", b); + } + } + + @Test + public void expiryOfCounterIsSupported() throws Exception { + int allowedRequests = 1; + _limitService.setMaxAllowed(allowedRequests); + _limitService.setTimeToLive(1); + + User key = this.createFakeUser(); + + assertTrue("The first request should be allowed", isUnderLimit(key)); + + // Allow the token to expire + Thread.sleep(1001); + + assertTrue("Another request after interval should be allowed as well", isUnderLimit(key)); + } + + @Test + public void verifyResetCounters() throws Exception { + int allowedRequests = 1; + _limitService.setMaxAllowed(allowedRequests); + _limitService.setTimeToLive(1); + + User key = this.createFakeUser(); + + assertTrue("The first request should be allowed", isUnderLimit(key)); + + assertFalse("Another request should be blocked", isUnderLimit(key)); + + _limitService.resetApiLimit(key.getAccountId()); + + assertTrue("Another request should be allowed after reset counter", isUnderLimit(key)); + } + + + @Test + public void verifySearchCounter() throws Exception { + int allowedRequests = 10; + _limitService.setMaxAllowed(allowedRequests); + _limitService.setTimeToLive(1); + + User key = this.createFakeUser(); + + for ( int i = 0; i < 5; i++ ){ + assertTrue("Issued 5 requests", isUnderLimit(key)); + } + + ApiLimitResponse response = _limitService.searchApiLimit(testAccount); + assertEquals("apiIssued is incorrect", 5, response.getApiIssued()); + assertEquals("apiAllowed is incorrect", 5, response.getApiAllowed()); + assertTrue("expiredAfter is incorrect", response.getExpireAfter() < 1000); + + } + +} diff --git a/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/APITest.java b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/APITest.java new file mode 100644 index 00000000000..7701b1515b0 --- /dev/null +++ b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/APITest.java @@ -0,0 +1,211 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit.integration; + +import java.io.BufferedReader; +import java.io.EOFException; +import java.io.InputStreamReader; +import java.math.BigInteger; +import java.net.HttpURLConnection; +import java.net.URL; +import java.net.URLEncoder; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.HashMap; +import java.util.Iterator; + +import org.apache.cloudstack.api.response.SuccessResponse; + +import com.cloud.api.ApiGsonHelper; +import com.cloud.utils.exception.CloudRuntimeException; +import com.google.gson.Gson; + +/** + * Base class for API Test + * + * @author Min Chen + * + */ +public abstract class APITest { + + protected String rootUrl = "http://localhost:8080/client/api"; + protected String sessionKey = null; + protected String cookieToSent = null; + + + /** + * Sending an api request through Http GET + * @param command command name + * @param params command query parameters in a HashMap + * @return http request response string + */ + protected String sendRequest(String command, HashMap params){ + try { + // Construct query string + StringBuilder sBuilder = new StringBuilder(); + sBuilder.append("command="); + sBuilder.append(command); + if ( params != null && params.size() > 0){ + Iterator keys = params.keySet().iterator(); + while (keys.hasNext()){ + String key = keys.next(); + sBuilder.append("&"); + sBuilder.append(key); + sBuilder.append("="); + sBuilder.append(URLEncoder.encode(params.get(key), "UTF-8")); + } + } + + // Construct request url + String reqUrl = rootUrl + "?" + sBuilder.toString(); + + // Send Http GET request + URL url = new URL(reqUrl); + HttpURLConnection conn = (HttpURLConnection) url.openConnection(); + conn.setRequestMethod("GET"); + + if ( !command.equals("login") && cookieToSent != null){ + // add the cookie to a request + conn.setRequestProperty("Cookie", cookieToSent); + } + conn.connect(); + + + if ( command.equals("login")){ + // if it is login call, store cookie + String headerName=null; + for (int i=1; (headerName = conn.getHeaderFieldKey(i))!=null; i++) { + if (headerName.equals("Set-Cookie")) { + String cookie = conn.getHeaderField(i); + cookie = cookie.substring(0, cookie.indexOf(";")); + String cookieName = cookie.substring(0, cookie.indexOf("=")); + String cookieValue = cookie.substring(cookie.indexOf("=") + 1, cookie.length()); + cookieToSent = cookieName + "=" + cookieValue; + } + } + } + + // Get the response + StringBuilder response = new StringBuilder(); + BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream())); + String line; + try { + while ((line = rd.readLine()) != null) { + response.append(line); + } + } catch (EOFException ex) { + // ignore this exception + System.out.println("EOF exception due to java bug"); + } + rd.close(); + + + + return response.toString(); + + } catch (Exception e) { + throw new CloudRuntimeException("Problem with sending api request", e); + } + } + + protected String createMD5String(String password) { + MessageDigest md5; + try { + md5 = MessageDigest.getInstance("MD5"); + } catch (NoSuchAlgorithmException e) { + throw new CloudRuntimeException("Error", e); + } + + md5.reset(); + BigInteger pwInt = new BigInteger(1, md5.digest(password.getBytes())); + + // make sure our MD5 hash value is 32 digits long... + StringBuffer sb = new StringBuffer(); + String pwStr = pwInt.toString(16); + int padding = 32 - pwStr.length(); + for (int i = 0; i < padding; i++) { + sb.append('0'); + } + sb.append(pwStr); + return sb.toString(); + } + + + protected Object fromSerializedString(String result, Class repCls) { + try { + if (result != null && !result.isEmpty()) { + // get real content + int start; + int end; + if (repCls == LoginResponse.class || repCls == SuccessResponse.class) { + + start = result.indexOf('{', result.indexOf('{') + 1); // find + // the + // second + // { + + end = result.lastIndexOf('}', result.lastIndexOf('}') - 1); // find + // the + // second + // } + // backwards + + } else { + // get real content + start = result.indexOf('{', result.indexOf('{', result.indexOf('{') + 1) + 1); // find + // the + // third + // { + end = result.lastIndexOf('}', result.lastIndexOf('}', result.lastIndexOf('}') - 1) - 1); // find + // the + // third + // } + // backwards + } + if (start < 0 || end < 0) { + throw new CloudRuntimeException("Response format is wrong: " + result); + } + String content = result.substring(start, end + 1); + Gson gson = ApiGsonHelper.getBuilder().create(); + return gson.fromJson(content, repCls); + } + return null; + } catch (RuntimeException e) { + throw new CloudRuntimeException("Caught runtime exception when doing GSON deserialization on: " + result, e); + } + } + + /** + * Login call + * @param username user name + * @param password password (plain password, we will do MD5 hash here for you) + * @return login response string + */ + protected void login(String username, String password) + { + //String md5Psw = createMD5String(password); + // send login request + HashMap params = new HashMap(); + params.put("response", "json"); + params.put("username", username); + params.put("password", password); + String result = this.sendRequest("login", params); + LoginResponse loginResp = (LoginResponse)fromSerializedString(result, LoginResponse.class); + sessionKey = loginResp.getSessionkey(); + + } +} diff --git a/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/LoginResponse.java b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/LoginResponse.java new file mode 100644 index 00000000000..719f39c0a5e --- /dev/null +++ b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/LoginResponse.java @@ -0,0 +1,142 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit.integration; + +import org.apache.cloudstack.api.BaseResponse; + +import com.cloud.serializer.Param; +import com.google.gson.annotations.SerializedName; + +/** + * Login Response object + * + * @author Min Chen + * + */ +public class LoginResponse extends BaseResponse { + + @SerializedName("timeout") + @Param(description = "session timeout period") + private String timeout; + + @SerializedName("sessionkey") + @Param(description = "login session key") + private String sessionkey; + + @SerializedName("username") + @Param(description = "login username") + private String username; + + @SerializedName("userid") + @Param(description = "login user internal uuid") + private String userid; + + @SerializedName("firstname") + @Param(description = "login user firstname") + private String firstname; + + @SerializedName("lastname") + @Param(description = "login user lastname") + private String lastname; + + @SerializedName("account") + @Param(description = "login user account type") + private String account; + + @SerializedName("domainid") + @Param(description = "login user domain id") + private String domainid; + + @SerializedName("type") + @Param(description = "login user type") + private int type; + + public String getTimeout() { + return timeout; + } + + public void setTimeout(String timeout) { + this.timeout = timeout; + } + + public String getSessionkey() { + return sessionkey; + } + + public void setSessionkey(String sessionkey) { + this.sessionkey = sessionkey; + } + + public String getUsername() { + return username; + } + + public void setUsername(String username) { + this.username = username; + } + + public String getUserid() { + return userid; + } + + public void setUserid(String userid) { + this.userid = userid; + } + + public String getFirstname() { + return firstname; + } + + public void setFirstname(String firstname) { + this.firstname = firstname; + } + + public String getLastname() { + return lastname; + } + + public void setLastname(String lastname) { + this.lastname = lastname; + } + + public String getAccount() { + return account; + } + + public void setAccount(String account) { + this.account = account; + } + + public String getDomainid() { + return domainid; + } + + public void setDomainid(String domainid) { + this.domainid = domainid; + } + + public int getType() { + return type; + } + + public void setType(int type) { + this.type = type; + } + + + +} diff --git a/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/RateLimitIntegrationTest.java b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/RateLimitIntegrationTest.java new file mode 100644 index 00000000000..72d354c6c77 --- /dev/null +++ b/plugins/api/rate-limit/test/org/apache/cloudstack/ratelimit/integration/RateLimitIntegrationTest.java @@ -0,0 +1,214 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package org.apache.cloudstack.ratelimit.integration; + +import static org.junit.Assert.*; + +import java.util.HashMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import org.apache.cloudstack.api.response.ApiLimitResponse; +import org.apache.cloudstack.api.response.SuccessResponse; +import org.junit.Before; +import org.junit.Test; + +import com.cloud.utils.exception.CloudRuntimeException; + + +/** + * Test fixture to do integration rate limit test. + * Currently we commented out this test suite since it requires a real MS and Db running. + * + * @author Min Chen + * + */ +public class RateLimitIntegrationTest extends APITest { + + private static int apiMax = 25; // assuming ApiRateLimitService set api.throttling.max = 25 + + @Before + public void setup(){ + // always reset count for each testcase + login("admin", "password"); + + // issue reset api limit calls + final HashMap params = new HashMap(); + params.put("response", "json"); + params.put("sessionkey", sessionKey); + String resetResult = sendRequest("resetApiLimit", params); + assertNotNull("Reset count failed!", fromSerializedString(resetResult, SuccessResponse.class)); + + } + + + @Test + public void testNoApiLimitOnRootAdmin() throws Exception { + // issue list Accounts calls + final HashMap params = new HashMap(); + params.put("response", "json"); + params.put("listAll", "true"); + params.put("sessionkey", sessionKey); + // assuming ApiRateLimitService set api.throttling.max = 25 + int clientCount = 26; + Runnable[] clients = new Runnable[clientCount]; + final boolean[] isUsable = new boolean[clientCount]; + + final CountDownLatch startGate = new CountDownLatch(1); + + final CountDownLatch endGate = new CountDownLatch(clientCount); + + + for (int i = 0; i < isUsable.length; ++i) { + final int j = i; + clients[j] = new Runnable() { + + /** + * {@inheritDoc} + */ + @Override + public void run() { + try { + startGate.await(); + + sendRequest("listAccounts", params); + + isUsable[j] = true; + + } catch (CloudRuntimeException e){ + isUsable[j] = false; + e.printStackTrace(); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + endGate.countDown(); + } + } + }; + } + + ExecutorService executor = Executors.newFixedThreadPool(clientCount); + + for (Runnable runnable : clients) { + executor.execute(runnable); + } + + startGate.countDown(); + + endGate.await(); + + int rejectCount = 0; + for ( int i = 0; i < isUsable.length; ++i){ + if ( !isUsable[i]) + rejectCount++; + } + + assertEquals("No request should be rejected!", 0, rejectCount); + + } + + + @Test + public void testApiLimitOnUser() throws Exception { + // log in using normal user + login("demo", "password"); + // issue list Accounts calls + final HashMap params = new HashMap(); + params.put("response", "json"); + params.put("listAll", "true"); + params.put("sessionkey", sessionKey); + + int clientCount = apiMax + 1; + Runnable[] clients = new Runnable[clientCount]; + final boolean[] isUsable = new boolean[clientCount]; + + final CountDownLatch startGate = new CountDownLatch(1); + + final CountDownLatch endGate = new CountDownLatch(clientCount); + + + for (int i = 0; i < isUsable.length; ++i) { + final int j = i; + clients[j] = new Runnable() { + + /** + * {@inheritDoc} + */ + @Override + public void run() { + try { + startGate.await(); + + sendRequest("listAccounts", params); + + isUsable[j] = true; + + } catch (CloudRuntimeException e){ + isUsable[j] = false; + e.printStackTrace(); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + endGate.countDown(); + } + } + }; + } + + ExecutorService executor = Executors.newFixedThreadPool(clientCount); + + for (Runnable runnable : clients) { + executor.execute(runnable); + } + + startGate.countDown(); + + endGate.await(); + + int rejectCount = 0; + for ( int i = 0; i < isUsable.length; ++i){ + if ( !isUsable[i]) + rejectCount++; + } + + assertEquals("Only one request should be rejected!", 1, rejectCount); + + } + + @Test + public void testGetApiLimitOnUser() throws Exception { + // log in using normal user + login("demo", "password"); + + // issue an api call + HashMap params = new HashMap(); + params.put("response", "json"); + params.put("listAll", "true"); + params.put("sessionkey", sessionKey); + sendRequest("listAccounts", params); + + // issue get api limit calls + final HashMap params2 = new HashMap(); + params2.put("response", "json"); + params2.put("sessionkey", sessionKey); + String getResult = sendRequest("getApiLimit", params2); + ApiLimitResponse getLimitResp = (ApiLimitResponse)fromSerializedString(getResult, ApiLimitResponse.class); + assertEquals("Issued api count is incorrect!", 2, getLimitResp.getApiIssued() ); // should be 2 apis issues plus this getlimit api + assertEquals("Allowed api count is incorrect!", apiMax -2, getLimitResp.getApiAllowed()); + } +} diff --git a/plugins/hypervisors/kvm/src/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java b/plugins/hypervisors/kvm/src/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java index b65b53114bf..eac60f4df41 100755 --- a/plugins/hypervisors/kvm/src/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java +++ b/plugins/hypervisors/kvm/src/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java @@ -3225,8 +3225,11 @@ public class LibvirtComputingResource extends ServerResourceBase implements } try { - //we use libvirt since we passed a libvirt connection to cleanupDisk - KVMStoragePool pool = _storagePoolMgr.getStoragePool(null, poolUuid); + // we use libvirt as storage adaptor since we passed a libvirt + // connection to cleanupDisk. We pass a storage type that maps + // to libvirt adaptor. + KVMStoragePool pool = _storagePoolMgr.getStoragePool( + StoragePoolType.Filesystem, poolUuid); if (pool != null) { pool.delete(); } diff --git a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/guru/VMwareGuru.java b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/guru/VMwareGuru.java index 546df5f2389..ca03866d49e 100644 --- a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/guru/VMwareGuru.java +++ b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/guru/VMwareGuru.java @@ -48,7 +48,7 @@ import com.cloud.hypervisor.HypervisorGuruBase; import com.cloud.hypervisor.vmware.VmwareCleanupMaid; import com.cloud.hypervisor.vmware.manager.VmwareManager; import com.cloud.hypervisor.vmware.mo.VirtualEthernetCardType; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; import com.cloud.network.dao.NetworkDao; @@ -84,7 +84,7 @@ public class VMwareGuru extends HypervisorGuruBase implements HypervisorGuru { @Inject VmwareManager _vmwareMgr; @Inject SecondaryStorageVmManager _secStorageMgr; @Inject CheckPointManager _checkPointMgr; - @Inject NetworkManager _networkMgr; + @Inject NetworkModel _networkMgr; protected VMwareGuru() { super(); diff --git a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java index a75640bedfe..684df54ccd5 100755 --- a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java +++ b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/VmwareServerDiscoverer.java @@ -50,7 +50,7 @@ import com.cloud.hypervisor.vmware.mo.HostMO; import com.cloud.hypervisor.vmware.resource.VmwareContextFactory; import com.cloud.hypervisor.vmware.resource.VmwareResource; import com.cloud.hypervisor.vmware.util.VmwareContext; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.dao.CiscoNexusVSMDeviceDao; import com.cloud.resource.Discoverer; import com.cloud.resource.DiscovererBase; @@ -84,7 +84,7 @@ public class VmwareServerDiscoverer extends DiscovererBase implements Discoverer @Inject ResourceManager _resourceMgr; @Inject CiscoNexusVSMDeviceDao _nexusDao; @Inject - NetworkManager _netmgr; + NetworkModel _netmgr; @Override public Map> find(long dcId, Long podId, Long clusterId, URI url, diff --git a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/manager/VmwareManagerImpl.java b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/manager/VmwareManagerImpl.java index 64ded51b453..c450312c1a7 100755 --- a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/manager/VmwareManagerImpl.java +++ b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/manager/VmwareManagerImpl.java @@ -73,7 +73,7 @@ import com.cloud.hypervisor.vmware.mo.VmwareHostType; import com.cloud.utils.ssh.SshHelper; import com.cloud.hypervisor.vmware.util.VmwareContext; import com.cloud.network.CiscoNexusVSMDeviceVO; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.dao.CiscoNexusVSMDeviceDao; import com.cloud.org.Cluster.ClusterType; import com.cloud.secstorage.CommandExecLogDao; @@ -113,7 +113,7 @@ public class VmwareManagerImpl implements VmwareManager, VmwareStorageMount, Lis @Inject AgentManager _agentMgr; @Inject - protected NetworkManager _netMgr; + protected NetworkModel _netMgr; @Inject HostDao _hostDao; @Inject ClusterDao _clusterDao; @Inject ClusterDetailsDao _clusterDetailsDao; diff --git a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java index a444cfec197..dd917f75a6e 100755 --- a/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java +++ b/plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/resource/VmwareResource.java @@ -3984,7 +3984,7 @@ public class VmwareResource implements StoragePoolResource, ServerResource, Vmwa cmd.setHypervisorType(HypervisorType.VMware); cmd.setStateChanges(changes); cmd.setCluster(_cluster); - cmd.setVersion(hostApiVersion); + cmd.setHypervisorVersion(hostApiVersion); List storageCmds = initializeLocalStorage(); StartupCommand[] answerCmds = new StartupCommand[1 + storageCmds.size()]; diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java index 34cbe086452..201b397c280 100644 --- a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java +++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java @@ -36,7 +36,7 @@ import com.cloud.network.Network; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks.TrafficType; import com.cloud.network.PhysicalNetworkServiceProvider; import com.cloud.network.PublicIpAddress; @@ -57,7 +57,7 @@ import com.cloud.vm.VirtualMachineProfile; public class ElasticLoadBalancerElement extends AdapterBase implements LoadBalancingServiceProvider, IpDeployer { private static final Logger s_logger = Logger.getLogger(ElasticLoadBalancerElement.class); private static final Map> capabilities = setCapabilities(); - @Inject NetworkManager _networkManager; + @Inject NetworkModel _networkManager; @Inject ElasticLoadBalancerManager _lbMgr; @Inject ConfigurationDao _configDao; @Inject NetworkOfferingDao _networkOfferingDao; diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java index 736307ba176..82c6120f266 100644 --- a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java +++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java @@ -79,6 +79,7 @@ import com.cloud.network.Network; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; import com.cloud.network.PhysicalNetworkServiceProvider; @@ -100,8 +101,8 @@ import com.cloud.network.router.VpcVirtualNetworkApplianceManager; import com.cloud.network.rules.FirewallRule; import com.cloud.network.rules.FirewallRule.Purpose; import com.cloud.network.rules.LoadBalancer; +import com.cloud.offering.NetworkOffering; import com.cloud.offering.ServiceOffering; -import com.cloud.offerings.NetworkOfferingVO; import com.cloud.offerings.dao.NetworkOfferingDao; import com.cloud.service.ServiceOfferingVO; import com.cloud.service.dao.ServiceOfferingDao; @@ -147,6 +148,8 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { @Inject AgentManager _agentMgr; @Inject + NetworkModel _networkModel; + @Inject NetworkManager _networkMgr; @Inject LoadBalancerDao _loadBalancerDao = null; @@ -291,7 +294,7 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { String protocol = rule.getProtocol(); String algorithm = rule.getAlgorithm(); - String elbIp = _networkMgr.getIp(rule.getSourceIpAddressId()).getAddress() + String elbIp = _networkModel.getIp(rule.getSourceIpAddressId()).getAddress() .addr(); int srcPort = rule.getSourcePortStart(); String uuid = rule.getUuid(); @@ -472,7 +475,7 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { try { - if (_networkMgr.isNetworkSystem(guestNetwork) || guestNetwork.getGuestType() == Network.GuestType.Shared) { + if (_networkModel.isNetworkSystem(guestNetwork) || guestNetwork.getGuestType() == Network.GuestType.Shared) { owner = _accountService.getSystemAccount(); } @@ -494,8 +497,8 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { s_logger.debug("Creating the ELB vm " + id); } - List offerings = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemControlNetwork); - NetworkOfferingVO controlOffering = offerings.get(0); + List offerings = _networkModel.getSystemAccountNetworkOfferings(NetworkOffering.SystemControlNetwork); + NetworkOffering controlOffering = offerings.get(0); NetworkVO controlConfig = _networkMgr.setupNetwork(_systemAcct, controlOffering, plan, null, null, false).get(0); List> networks = new ArrayList>(2); @@ -507,7 +510,7 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { VMTemplateVO template = _templateDao.findSystemVMTemplate(dcId); String typeString = "ElasticLoadBalancerVm"; - Long physicalNetworkId = _networkMgr.getPhysicalNetworkId(guestNetwork); + Long physicalNetworkId = _networkModel.getPhysicalNetworkId(guestNetwork); PhysicalNetworkServiceProvider provider = _physicalProviderDao.findByServiceProvider(physicalNetworkId, typeString); if (provider == null) { throw new CloudRuntimeException("Cannot find service provider " + typeString + " in physical network " + physicalNetworkId); @@ -593,7 +596,7 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { @DB public PublicIp allocDirectIp(Account account, long guestNetworkId) throws InsufficientAddressCapacityException { - Network frontEndNetwork = _networkMgr.getNetwork(guestNetworkId); + Network frontEndNetwork = _networkModel.getNetwork(guestNetworkId); Transaction txn = Transaction.currentTxn(); txn.start(); @@ -620,7 +623,7 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { @DB public LoadBalancer handleCreateLoadBalancerRule(CreateLoadBalancerRuleCmd lb, Account account, long networkId) throws InsufficientAddressCapacityException, NetworkRuleConflictException { //this part of code is executed when the LB provider is Elastic Load Balancer vm - if (!_networkMgr.isProviderSupportServiceInNetwork(lb.getNetworkId(), Service.Lb, Provider.ElasticLoadBalancerVm)) { + if (!_networkModel.isProviderSupportServiceInNetwork(lb.getNetworkId(), Service.Lb, Provider.ElasticLoadBalancerVm)) { return null; } @@ -659,7 +662,7 @@ ElasticLoadBalancerManager, Manager, VirtualMachineGuru { throw new NetworkRuleConflictException("ELB: Found existing load balancers matching requested new LB"); } - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); IPAddressVO ipAddr = _ipAddressDao.findById(ipId); LoadBalancer result = null; diff --git a/plugins/network-elements/f5/src/com/cloud/network/element/F5ExternalLoadBalancerElement.java b/plugins/network-elements/f5/src/com/cloud/network/element/F5ExternalLoadBalancerElement.java index 70faaccc461..2e6f6e7a517 100644 --- a/plugins/network-elements/f5/src/com/cloud/network/element/F5ExternalLoadBalancerElement.java +++ b/plugins/network-elements/f5/src/com/cloud/network/element/F5ExternalLoadBalancerElement.java @@ -65,7 +65,7 @@ import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkExternalLoadBalancerVO; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; import com.cloud.network.PhysicalNetwork; @@ -93,13 +93,14 @@ import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachineProfile; import com.google.gson.Gson; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class, LoadBalancingServiceProvider.class, + IpDeployer.class}) public class F5ExternalLoadBalancerElement extends ExternalLoadBalancerDeviceManagerImpl implements LoadBalancingServiceProvider, IpDeployer, F5ExternalLoadBalancerElementService, ExternalLoadBalancerDeviceManager { private static final Logger s_logger = Logger.getLogger(F5ExternalLoadBalancerElement.class); @Inject - NetworkManager _networkManager; + NetworkModel _networkManager; @Inject ConfigurationManager _configMgr; @Inject diff --git a/plugins/network-elements/f5/src/com/cloud/network/resource/F5BigIpResource.java b/plugins/network-elements/f5/src/com/cloud/network/resource/F5BigIpResource.java index c9c3711bfc1..80a7a85dc85 100644 --- a/plugins/network-elements/f5/src/com/cloud/network/resource/F5BigIpResource.java +++ b/plugins/network-elements/f5/src/com/cloud/network/resource/F5BigIpResource.java @@ -196,7 +196,7 @@ public class F5BigIpResource implements ServerResource { cmd.setPod(""); cmd.setPrivateIpAddress(_ip); cmd.setStorageIpAddress(""); - cmd.setVersion(""); + cmd.setVersion(F5BigIpResource.class.getPackage().getImplementationVersion()); cmd.setGuid(_guid); return new StartupCommand[]{cmd}; } diff --git a/plugins/network-elements/juniper-srx/src/com/cloud/network/element/JuniperSRXExternalFirewallElement.java b/plugins/network-elements/juniper-srx/src/com/cloud/network/element/JuniperSRXExternalFirewallElement.java index ead2af9396d..5038cc801ac 100644 --- a/plugins/network-elements/juniper-srx/src/com/cloud/network/element/JuniperSRXExternalFirewallElement.java +++ b/plugins/network-elements/juniper-srx/src/com/cloud/network/element/JuniperSRXExternalFirewallElement.java @@ -64,7 +64,7 @@ import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkExternalFirewallVO; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.PhysicalNetwork; import com.cloud.network.PhysicalNetworkServiceProvider; @@ -93,7 +93,9 @@ import com.cloud.vm.ReservationContext; import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachineProfile; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class, FirewallServiceProvider.class, + PortForwardingServiceProvider.class, IpDeployer.class, + SourceNatServiceProvider.class, RemoteAccessVPNServiceProvider.class}) public class JuniperSRXExternalFirewallElement extends ExternalFirewallDeviceManagerImpl implements SourceNatServiceProvider, FirewallServiceProvider, PortForwardingServiceProvider, RemoteAccessVPNServiceProvider, IpDeployer, JuniperSRXFirewallElementService, StaticNatServiceProvider { @@ -102,7 +104,7 @@ public class JuniperSRXExternalFirewallElement extends ExternalFirewallDeviceMan private static final Map> capabilities = setCapabilities(); @Inject - NetworkManager _networkManager; + NetworkModel _networkManager; @Inject HostDao _hostDao; @Inject diff --git a/plugins/network-elements/juniper-srx/src/com/cloud/network/resource/JuniperSrxResource.java b/plugins/network-elements/juniper-srx/src/com/cloud/network/resource/JuniperSrxResource.java index f823ab8af4f..11ff2960e4b 100644 --- a/plugins/network-elements/juniper-srx/src/com/cloud/network/resource/JuniperSrxResource.java +++ b/plugins/network-elements/juniper-srx/src/com/cloud/network/resource/JuniperSrxResource.java @@ -447,7 +447,7 @@ public class JuniperSrxResource implements ServerResource { cmd.setPod(""); cmd.setPrivateIpAddress(_ip); cmd.setStorageIpAddress(""); - cmd.setVersion(""); + cmd.setVersion(JuniperSrxResource.class.getPackage().getImplementationVersion()); cmd.setGuid(_guid); return new StartupCommand[]{cmd}; } diff --git a/plugins/network-elements/netscaler/src/com/cloud/network/element/NetscalerElement.java b/plugins/network-elements/netscaler/src/com/cloud/network/element/NetscalerElement.java index c0f91bb42d2..c2dc1e059d0 100644 --- a/plugins/network-elements/netscaler/src/com/cloud/network/element/NetscalerElement.java +++ b/plugins/network-elements/netscaler/src/com/cloud/network/element/NetscalerElement.java @@ -77,7 +77,7 @@ import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkExternalLoadBalancerVO; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; import com.cloud.network.PhysicalNetwork; @@ -113,7 +113,7 @@ import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachineProfile; import com.google.gson.Gson; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class, StaticNatServiceProvider.class, LoadBalancingServiceProvider.class}) public class NetscalerElement extends ExternalLoadBalancerDeviceManagerImpl implements LoadBalancingServiceProvider, NetscalerLoadBalancerElementService, ExternalLoadBalancerDeviceManager, IpDeployer, StaticNatServiceProvider { @@ -122,7 +122,7 @@ StaticNatServiceProvider { public static final AutoScaleCounterType AutoScaleCounterNetscaler = new AutoScaleCounterType("netscaler"); @Inject - NetworkManager _networkManager; + NetworkModel _networkManager; @Inject ConfigurationManager _configMgr; @Inject @@ -130,7 +130,7 @@ StaticNatServiceProvider { @Inject AgentManager _agentMgr; @Inject - NetworkManager _networkMgr; + NetworkModel _networkMgr; @Inject HostDao _hostDao; @Inject diff --git a/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java b/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java index afb01353e1e..ca8c8a71c7d 100644 --- a/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java +++ b/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java @@ -369,7 +369,7 @@ public class NetscalerResource implements ServerResource { cmd.setPod(""); cmd.setPrivateIpAddress(_ip); cmd.setStorageIpAddress(""); - cmd.setVersion(""); + cmd.setVersion(NetscalerResource.class.getPackage().getImplementationVersion()); cmd.setGuid(_guid); return new StartupCommand[]{cmd}; } diff --git a/plugins/network-elements/nicira-nvp/src/com/cloud/network/element/NiciraNvpElement.java b/plugins/network-elements/nicira-nvp/src/com/cloud/network/element/NiciraNvpElement.java index 6bcaeeeb235..de03fa26f25 100644 --- a/plugins/network-elements/nicira-nvp/src/com/cloud/network/element/NiciraNvpElement.java +++ b/plugins/network-elements/nicira-nvp/src/com/cloud/network/element/NiciraNvpElement.java @@ -76,6 +76,7 @@ import org.apache.cloudstack.network.ExternalNetworkDeviceManager.NetworkDevice; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks; import com.cloud.network.Networks.BroadcastDomainType; @@ -120,7 +121,9 @@ import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachineProfile; import com.cloud.vm.dao.NicDao; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class, ConnectivityProvider.class, + SourceNatServiceProvider.class, StaticNatServiceProvider.class, + PortForwardingServiceProvider.class, IpDeployer.class} ) public class NiciraNvpElement extends AdapterBase implements ConnectivityProvider, SourceNatServiceProvider, PortForwardingServiceProvider, StaticNatServiceProvider, @@ -155,6 +158,8 @@ public class NiciraNvpElement extends AdapterBase implements @Inject NetworkManager _networkManager; @Inject + NetworkModel _networkModel; + @Inject ConfigurationManager _configMgr; @Inject NetworkServiceMapDao _ntwkSrvcDao; @@ -178,7 +183,7 @@ public class NiciraNvpElement extends AdapterBase implements return false; } - if (!_networkManager.isProviderForNetwork(getProvider(), + if (!_networkModel.isProviderForNetwork(getProvider(), network.getId())) { s_logger.debug("NiciraNvpElement is not a provider for network " + network.getDisplayText()); @@ -242,58 +247,50 @@ public class NiciraNvpElement extends AdapterBase implements * Lock the network as we might need to do multiple operations that * should be done only once. */ - Network lock = _networkDao.acquireInLockTable(network.getId(), - _networkManager.getNetworkLockTimeout()); - if (lock == null) { - throw new ConcurrentOperationException("Unable to lock network " - + network.getId()); +// Network lock = _networkDao.acquireInLockTable(network.getId(), +// _networkModel.getNetworkLockTimeout()); +// if (lock == null) { +// throw new ConcurrentOperationException("Unable to lock network " +// + network.getId()); +// } + + // Implement SourceNat immediately as we have al the info already + if (_networkModel.isProviderSupportServiceInNetwork( + network.getId(), Service.SourceNat, Provider.NiciraNvp)) { + s_logger.debug("Apparently we are supposed to provide SourceNat on this network"); + + PublicIp sourceNatIp = _networkManager + .assignSourceNatIpAddressToGuestNetwork(owner, network); + String publicCidr = sourceNatIp.getAddress().addr() + "/" + + NetUtils.getCidrSize(sourceNatIp.getVlanNetmask()); + String internalCidr = network.getGateway() + "/" + + network.getCidr().split("/")[1]; + long vlanid = (Vlan.UNTAGGED.equals(sourceNatIp.getVlanTag())) ? 0 + : Long.parseLong(sourceNatIp.getVlanTag()); + + CreateLogicalRouterCommand cmd = new CreateLogicalRouterCommand( + niciraNvpHost.getDetail("l3gatewayserviceuuid"), vlanid, + network.getBroadcastUri().getSchemeSpecificPart(), + "router-" + network.getDisplayText(), publicCidr, + sourceNatIp.getGateway(), internalCidr, context + .getDomain().getName() + + "-" + + context.getAccount().getAccountName()); + CreateLogicalRouterAnswer answer = (CreateLogicalRouterAnswer) _agentMgr + .easySend(niciraNvpHost.getId(), cmd); + if (answer.getResult() == false) { + s_logger.error("Failed to create Logical Router for network " + + network.getDisplayText()); + return false; + } + + // Store the uuid so we can easily find it during cleanup + NiciraNvpRouterMappingVO routermapping = + new NiciraNvpRouterMappingVO(answer.getLogicalRouterUuid(), network.getId()); + _niciraNvpRouterMappingDao.persist(routermapping); } - try { - // Implement SourceNat immediately as we have al the info already - if (_networkManager.isProviderSupportServiceInNetwork( - network.getId(), Service.SourceNat, Provider.NiciraNvp)) { - s_logger.debug("Apparently we are supposed to provide SourceNat on this network"); - PublicIp sourceNatIp = _networkManager - .assignSourceNatIpAddressToGuestNetwork(owner, network); - String publicCidr = sourceNatIp.getAddress().addr() + "/" - + NetUtils.getCidrSize(sourceNatIp.getVlanNetmask()); - String internalCidr = network.getGateway() + "/" - + network.getCidr().split("/")[1]; - long vlanid = (Vlan.UNTAGGED.equals(sourceNatIp.getVlanTag())) ? 0 - : Long.parseLong(sourceNatIp.getVlanTag()); - - CreateLogicalRouterCommand cmd = new CreateLogicalRouterCommand( - niciraNvpHost.getDetail("l3gatewayserviceuuid"), vlanid, - network.getBroadcastUri().getSchemeSpecificPart(), - "router-" + network.getDisplayText(), publicCidr, - sourceNatIp.getGateway(), internalCidr, context - .getDomain().getName() - + "-" - + context.getAccount().getAccountName()); - CreateLogicalRouterAnswer answer = (CreateLogicalRouterAnswer) _agentMgr - .easySend(niciraNvpHost.getId(), cmd); - if (answer.getResult() == false) { - s_logger.error("Failed to create Logical Router for network " - + network.getDisplayText()); - return false; - } - - // Store the uuid so we can easily find it during cleanup - NiciraNvpRouterMappingVO routermapping = - new NiciraNvpRouterMappingVO(answer.getLogicalRouterUuid(), network.getId()); - _niciraNvpRouterMappingDao.persist(routermapping); - } - } finally { - if (lock != null) { - _networkDao.releaseFromLockTable(lock.getId()); - if (s_logger.isDebugEnabled()) { - s_logger.debug("Lock is released for network id " - + lock.getId() + " as a part of router startup in " - + dest); - } - } - } + return true; } @@ -442,7 +439,7 @@ public class NiciraNvpElement extends AdapterBase implements NiciraNvpDeviceVO niciraNvpDevice = devices.get(0); HostVO niciraNvpHost = _hostDao.findById(niciraNvpDevice.getHostId()); - if (_networkManager.isProviderSupportServiceInNetwork(network.getId(), + if (_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.SourceNat, Provider.NiciraNvp)) { s_logger.debug("Apparently we were providing SourceNat on this network"); @@ -892,7 +889,7 @@ public class NiciraNvpElement extends AdapterBase implements List staticNatRules = new ArrayList(); for (StaticNat rule : rules) { - IpAddress sourceIp = _networkManager.getIp(rule.getSourceIpAddressId()); + IpAddress sourceIp = _networkModel.getIp(rule.getSourceIpAddressId()); // Force the nat rule into the StaticNatRuleTO, no use making a new TO object // we only need the source and destination ip. Unfortunately no mention if a rule // is new. @@ -940,7 +937,7 @@ public class NiciraNvpElement extends AdapterBase implements List portForwardingRules = new ArrayList(); for (PortForwardingRule rule : rules) { - IpAddress sourceIp = _networkManager.getIp(rule.getSourceIpAddressId()); + IpAddress sourceIp = _networkModel.getIp(rule.getSourceIpAddressId()); Vlan vlan = _vlanDao.findById(sourceIp.getVlanId()); PortForwardingRuleTO ruleTO = new PortForwardingRuleTO((PortForwardingRule) rule, vlan.getVlanTag(), sourceIp.getAddress().addr()); portForwardingRules.add(ruleTO); diff --git a/plugins/network-elements/nicira-nvp/src/com/cloud/network/guru/NiciraNvpGuestNetworkGuru.java b/plugins/network-elements/nicira-nvp/src/com/cloud/network/guru/NiciraNvpGuestNetworkGuru.java index 99be680a5c6..d7b8cfb1fdb 100644 --- a/plugins/network-elements/nicira-nvp/src/com/cloud/network/guru/NiciraNvpGuestNetworkGuru.java +++ b/plugins/network-elements/nicira-nvp/src/com/cloud/network/guru/NiciraNvpGuestNetworkGuru.java @@ -41,7 +41,7 @@ import com.cloud.host.dao.HostDao; import com.cloud.host.dao.HostDetailsDao; import com.cloud.network.Network; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkVO; import com.cloud.network.Network.GuestType; @@ -70,10 +70,9 @@ import com.cloud.vm.VirtualMachineProfile; public class NiciraNvpGuestNetworkGuru extends GuestNetworkGuru { private static final Logger s_logger = Logger.getLogger(NiciraNvpGuestNetworkGuru.class); - @Inject - NetworkManager _externalNetworkManager; + @Inject - NetworkManager _networkMgr; + NetworkModel _networkModel; @Inject NetworkDao _networkDao; @Inject @@ -153,7 +152,7 @@ public class NiciraNvpGuestNetworkGuru extends GuestNetworkGuru { long dcId = dest.getDataCenter().getId(); //get physical network id - long physicalNetworkId = _networkMgr.findPhysicalNetworkId(dcId, offering.getTags(), offering.getTrafficType()); + long physicalNetworkId = _networkModel.findPhysicalNetworkId(dcId, offering.getTags(), offering.getTrafficType()); NetworkVO implemented = new NetworkVO(network.getTrafficType(), network.getMode(), network.getBroadcastDomainType(), network.getNetworkOfferingId(), State.Allocated, network.getDataCenterId(), physicalNetworkId); diff --git a/plugins/network-elements/nicira-nvp/src/com/cloud/network/resource/NiciraNvpResource.java b/plugins/network-elements/nicira-nvp/src/com/cloud/network/resource/NiciraNvpResource.java index 12ed72a1fd5..027f451b154 100644 --- a/plugins/network-elements/nicira-nvp/src/com/cloud/network/resource/NiciraNvpResource.java +++ b/plugins/network-elements/nicira-nvp/src/com/cloud/network/resource/NiciraNvpResource.java @@ -166,7 +166,7 @@ public class NiciraNvpResource implements ServerResource { sc.setPod(""); sc.setPrivateIpAddress(""); sc.setStorageIpAddress(""); - sc.setVersion(""); + sc.setVersion(NiciraNvpResource.class.getPackage().getImplementationVersion()); return new StartupCommand[] { sc }; } diff --git a/plugins/network-elements/nicira-nvp/test/com/cloud/network/element/NiciraNvpElementTest.java b/plugins/network-elements/nicira-nvp/test/com/cloud/network/element/NiciraNvpElementTest.java index acfd3bcdb9e..09d50a33a64 100644 --- a/plugins/network-elements/nicira-nvp/test/com/cloud/network/element/NiciraNvpElementTest.java +++ b/plugins/network-elements/nicira-nvp/test/com/cloud/network/element/NiciraNvpElementTest.java @@ -33,6 +33,7 @@ import com.cloud.network.Network.GuestType; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks.BroadcastDomainType; import com.cloud.network.Networks.TrafficType; import com.cloud.network.dao.NetworkServiceMapDao; @@ -48,6 +49,7 @@ public class NiciraNvpElementTest { NiciraNvpElement _element = new NiciraNvpElement(); NetworkManager _networkManager = mock(NetworkManager.class); + NetworkModel _networkModel = mock(NetworkModel.class); NetworkServiceMapDao _ntwkSrvcDao = mock (NetworkServiceMapDao.class); @Before @@ -55,9 +57,10 @@ public class NiciraNvpElementTest { _element._resourceMgr = mock(ResourceManager.class); _element._networkManager = _networkManager; _element._ntwkSrvcDao = _ntwkSrvcDao; + _element._networkModel = _networkModel; // Standard responses - when(_networkManager.isProviderForNetwork(Provider.NiciraNvp, 42L)).thenReturn(true); + when(_networkModel.isProviderForNetwork(Provider.NiciraNvp, 42L)).thenReturn(true); _element.configure("NiciraNvpTestElement", Collections. emptyMap()); } @@ -81,12 +84,12 @@ public class NiciraNvpElementTest { // No nvp provider in the network assertFalse(_element.canHandle(net, Service.Connectivity)); - when(_networkManager.isProviderForNetwork(Provider.NiciraNvp, 42L)).thenReturn(false); + when(_networkModel.isProviderForNetwork(Provider.NiciraNvp, 42L)).thenReturn(false); when(_ntwkSrvcDao.canProviderSupportServiceInNetwork(42L, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true); // NVP provider does not provide Connectivity for this network assertFalse(_element.canHandle(net, Service.Connectivity)); - when(_networkManager.isProviderForNetwork(Provider.NiciraNvp, 42L)).thenReturn(true); + when(_networkModel.isProviderForNetwork(Provider.NiciraNvp, 42L)).thenReturn(true); // Only service Connectivity is supported assertFalse(_element.canHandle(net, Service.Dhcp)); diff --git a/plugins/network-elements/nicira-nvp/test/com/cloud/network/guru/NiciraNvpGuestNetworkGuruTest.java b/plugins/network-elements/nicira-nvp/test/com/cloud/network/guru/NiciraNvpGuestNetworkGuruTest.java index e37b2f42105..124e28f496a 100644 --- a/plugins/network-elements/nicira-nvp/test/com/cloud/network/guru/NiciraNvpGuestNetworkGuruTest.java +++ b/plugins/network-elements/nicira-nvp/test/com/cloud/network/guru/NiciraNvpGuestNetworkGuruTest.java @@ -44,6 +44,7 @@ import com.cloud.network.Network.GuestType; import com.cloud.network.Network.Service; import com.cloud.network.Network.State; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.BroadcastDomainType; @@ -67,6 +68,8 @@ public class NiciraNvpGuestNetworkGuruTest { NetworkOfferingServiceMapDao nosd = mock(NetworkOfferingServiceMapDao.class); AgentManager agentmgr = mock (AgentManager.class); NetworkManager netmgr = mock (NetworkManager.class); + NetworkModel netmodel = mock (NetworkModel.class); + HostDao hostdao = mock (HostDao.class); NetworkDao netdao = mock(NetworkDao.class); NiciraNvpGuestNetworkGuru guru; @@ -80,7 +83,7 @@ public class NiciraNvpGuestNetworkGuruTest { guru._niciraNvpDao = nvpdao; guru._dcDao = dcdao; guru._ntwkOfferingSrvcDao = nosd; - guru._networkMgr = netmgr; + guru._networkModel = netmodel; guru._hostDao = hostdao; guru._agentMgr = agentmgr; guru._networkDao = netdao; @@ -261,7 +264,7 @@ public class NiciraNvpGuestNetworkGuruTest { when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt"); when(niciraHost.getId()).thenReturn(42L); - when(netmgr.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); + when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); Domain dom = mock(Domain.class); when(dom.getName()).thenReturn("domain"); Account acc = mock(Account.class); @@ -318,7 +321,7 @@ public class NiciraNvpGuestNetworkGuruTest { when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt"); when(niciraHost.getId()).thenReturn(42L); - when(netmgr.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); + when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); Domain dom = mock(Domain.class); when(dom.getName()).thenReturn("domain"); Account acc = mock(Account.class); @@ -374,7 +377,7 @@ public class NiciraNvpGuestNetworkGuruTest { when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt"); when(niciraHost.getId()).thenReturn(42L); - when(netmgr.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); + when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); Domain dom = mock(Domain.class); when(dom.getName()).thenReturn("domain"); Account acc = mock(Account.class); @@ -432,7 +435,7 @@ public class NiciraNvpGuestNetworkGuruTest { when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt"); when(niciraHost.getId()).thenReturn(42L); - when(netmgr.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); + when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L); Domain dom = mock(Domain.class); when(dom.getName()).thenReturn("domain"); Account acc = mock(Account.class); diff --git a/plugins/network-elements/ovs/src/com/cloud/network/element/OvsElement.java b/plugins/network-elements/ovs/src/com/cloud/network/element/OvsElement.java index 5e8639c3188..e8285587957 100644 --- a/plugins/network-elements/ovs/src/com/cloud/network/element/OvsElement.java +++ b/plugins/network-elements/ovs/src/com/cloud/network/element/OvsElement.java @@ -40,7 +40,7 @@ import com.cloud.vm.ReservationContext; import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachineProfile; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class}) public class OvsElement extends AdapterBase implements NetworkElement { @Inject OvsTunnelManager _ovsTunnelMgr; diff --git a/plugins/network-elements/ovs/src/com/cloud/network/guru/OvsGuestNetworkGuru.java b/plugins/network-elements/ovs/src/com/cloud/network/guru/OvsGuestNetworkGuru.java index 16e1ecc1cec..30a11294051 100644 --- a/plugins/network-elements/ovs/src/com/cloud/network/guru/OvsGuestNetworkGuru.java +++ b/plugins/network-elements/ovs/src/com/cloud/network/guru/OvsGuestNetworkGuru.java @@ -16,8 +16,6 @@ // under the License. package com.cloud.network.guru; -import java.util.List; - import javax.ejb.Local; import org.apache.log4j.Logger; @@ -29,32 +27,25 @@ import com.cloud.deploy.DeploymentPlan; import com.cloud.event.EventTypes; import com.cloud.event.EventUtils; import com.cloud.event.EventVO; -import com.cloud.exception.InsufficientAddressCapacityException; import com.cloud.exception.InsufficientVirtualNetworkCapcityException; import com.cloud.network.Network; -import com.cloud.network.NetworkManager; +import com.cloud.network.Network.GuestType; +import com.cloud.network.Network.State; import com.cloud.network.NetworkVO; +import com.cloud.network.Networks.BroadcastDomainType; +import com.cloud.network.PhysicalNetwork; +import com.cloud.network.PhysicalNetwork.IsolationMethod; import com.cloud.network.ovs.OvsTunnelManager; import com.cloud.offering.NetworkOffering; import com.cloud.user.Account; import com.cloud.user.UserContext; import com.cloud.utils.component.Inject; -import com.cloud.vm.Nic.ReservationStrategy; -import com.cloud.vm.NicProfile; import com.cloud.vm.ReservationContext; -import com.cloud.vm.VirtualMachine; -import com.cloud.vm.VirtualMachineProfile; -import com.cloud.network.Networks.BroadcastDomainType; -import com.cloud.network.Network.GuestType; -import com.cloud.network.Network.State; -import com.cloud.network.PhysicalNetwork; -import com.cloud.network.PhysicalNetwork.IsolationMethod; @Local(value=NetworkGuru.class) public class OvsGuestNetworkGuru extends GuestNetworkGuru { private static final Logger s_logger = Logger.getLogger(OvsGuestNetworkGuru.class); - @Inject NetworkManager _externalNetworkManager; @Inject OvsTunnelManager _ovsTunnelMgr; OvsGuestNetworkGuru() { diff --git a/plugins/pom.xml b/plugins/pom.xml index a42ae2967b1..7bb60a990fb 100644 --- a/plugins/pom.xml +++ b/plugins/pom.xml @@ -32,6 +32,7 @@ test + api/rate-limit api/discovery acl/static-role-based deployment-planners/user-concentrated-pod diff --git a/pom.xml b/pom.xml index c440a660322..35d6520ce6b 100644 --- a/pom.xml +++ b/pom.xml @@ -160,7 +160,6 @@ utils deps/XenServerJava plugins - awsapi patches client test @@ -359,11 +358,47 @@ + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + + org.apache.maven.plugins + + + maven-antrun-plugin + + [1.7,) + + run + + + + + + + + + + + + awsapi + + awsapi + + developer diff --git a/server/src/com/cloud/acl/DomainChecker.java b/server/src/com/cloud/acl/DomainChecker.java index 9bb1cce8171..24f632ba9be 100755 --- a/server/src/com/cloud/acl/DomainChecker.java +++ b/server/src/com/cloud/acl/DomainChecker.java @@ -26,7 +26,7 @@ import com.cloud.domain.Domain; import com.cloud.domain.dao.DomainDao; import com.cloud.exception.PermissionDeniedException; import com.cloud.network.Network; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.offering.DiskOffering; import com.cloud.offering.ServiceOffering; import com.cloud.projects.ProjectManager; @@ -42,20 +42,14 @@ import com.cloud.utils.component.Inject; @Local(value = SecurityChecker.class) public class DomainChecker extends AdapterBase implements SecurityChecker { - - @Inject - DomainDao _domainDao; - @Inject - AccountDao _accountDao; - @Inject - LaunchPermissionDao _launchPermissionDao; - @Inject - ProjectManager _projectMgr; - @Inject - ProjectAccountDao _projecAccountDao; - @Inject - NetworkManager _networkMgr; - + + @Inject DomainDao _domainDao; + @Inject AccountDao _accountDao; + @Inject LaunchPermissionDao _launchPermissionDao; + @Inject ProjectManager _projectMgr; + @Inject ProjectAccountDao _projecAccountDao; + @Inject NetworkModel _networkMgr; + protected DomainChecker() { super(); } diff --git a/server/src/com/cloud/agent/manager/AgentManagerImpl.java b/server/src/com/cloud/agent/manager/AgentManagerImpl.java index 8141fdbe3e0..fd5b3bdcb69 100755 --- a/server/src/com/cloud/agent/manager/AgentManagerImpl.java +++ b/server/src/com/cloud/agent/manager/AgentManagerImpl.java @@ -28,6 +28,8 @@ import java.util.Random; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; @@ -94,6 +96,7 @@ import com.cloud.resource.Discoverer; import com.cloud.resource.ResourceManager; import com.cloud.resource.ResourceState; import com.cloud.resource.ServerResource; +import com.cloud.server.ManagementService; import com.cloud.storage.StorageManager; import com.cloud.storage.StorageService; import com.cloud.storage.dao.StoragePoolDao; @@ -220,7 +223,8 @@ public class AgentManagerImpl implements AgentManager, HandlerFactory, Manager { protected ExecutorService _executor; protected ThreadPoolExecutor _connectExecutor; - + protected ScheduledExecutorService _directAgentExecutor; + protected StateMachine2 _statusStateMachine = Status.getStateMachine(); @Inject ResourceManager _resourceMgr; @@ -280,10 +284,15 @@ public class AgentManagerImpl implements AgentManager, HandlerFactory, Manager { new LinkedBlockingQueue(), new NamedThreadFactory("AgentConnectTaskPool")); //allow core threads to time out even when there are no items in the queue _connectExecutor.allowCoreThreadTimeOut(true); - - _connection = new NioServer("AgentManager", _port, workers + 10, this); + _connection = new NioServer("AgentManager", _port, workers + 10, this); s_logger.info("Listening on " + _port + " with " + workers + " workers"); + + value = configs.get(Config.DirectAgentPoolSize.key()); + int size = NumbersUtil.parseInt(value, 500); + _directAgentExecutor = new ScheduledThreadPoolExecutor(size, new NamedThreadFactory("DirectAgent")); + s_logger.debug("Created DirectAgentAttache pool with size: " + size); + return true; } @@ -909,10 +918,16 @@ public class AgentManagerImpl implements AgentManager, HandlerFactory, Manager { s_logger.info("Investigating why host " + hostId + " has disconnected with event " + event); final Status determinedState = investigate(attache); + // if state cannot be determined do nothing and bail out + if (determinedState == null) { + s_logger.warn("Agent state cannot be determined, do nothing"); + return false; + } + final Status currentStatus = host.getStatus(); s_logger.info("The state determined is " + determinedState); - if (determinedState == null || determinedState == Status.Down) { + if (determinedState == Status.Down) { s_logger.error("Host is down: " + host.getId() + "-" + host.getName() + ". Starting HA on the VMs"); event = Status.Event.HostDown; } else if (determinedState == Status.Up) { @@ -1521,7 +1536,9 @@ public class AgentManagerImpl implements AgentManager, HandlerFactory, Manager { attache.setMaintenanceMode(false); } } - - - + + public ScheduledExecutorService getDirectAgentPool() { + return _directAgentExecutor; + } + } diff --git a/server/src/com/cloud/agent/manager/DirectAgentAttache.java b/server/src/com/cloud/agent/manager/DirectAgentAttache.java index 848c7e6c624..9b7d69f1aba 100755 --- a/server/src/com/cloud/agent/manager/DirectAgentAttache.java +++ b/server/src/com/cloud/agent/manager/DirectAgentAttache.java @@ -18,14 +18,11 @@ package com.cloud.agent.manager; import java.util.ArrayList; import java.util.List; -import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; -import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; import org.apache.log4j.Logger; -import com.cloud.agent.AgentManager; import com.cloud.agent.api.Answer; import com.cloud.agent.api.Command; import com.cloud.agent.api.CronCommand; @@ -37,13 +34,11 @@ import com.cloud.exception.AgentUnavailableException; import com.cloud.host.Status; import com.cloud.host.Status.Event; import com.cloud.resource.ServerResource; -import com.cloud.utils.concurrency.NamedThreadFactory; public class DirectAgentAttache extends AgentAttache { private final static Logger s_logger = Logger.getLogger(DirectAgentAttache.class); ServerResource _resource; - static ScheduledExecutorService s_executor = new ScheduledThreadPoolExecutor(500, new NamedThreadFactory("DirectAgent")); List> _futures = new ArrayList>(); AgentManagerImpl _mgr; long _seq = 0; @@ -94,15 +89,15 @@ public class DirectAgentAttache extends AgentAttache { if (answers != null && answers[0] instanceof StartupAnswer) { StartupAnswer startup = (StartupAnswer)answers[0]; int interval = startup.getPingInterval(); - _futures.add(s_executor.scheduleAtFixedRate(new PingTask(), interval, interval, TimeUnit.SECONDS)); + _futures.add(_agentMgr.getDirectAgentPool().scheduleAtFixedRate(new PingTask(), interval, interval, TimeUnit.SECONDS)); } } else { Command[] cmds = req.getCommands(); if (cmds.length > 0 && !(cmds[0] instanceof CronCommand)) { - s_executor.execute(new Task(req)); + _agentMgr.getDirectAgentPool().execute(new Task(req)); } else { CronCommand cmd = (CronCommand)cmds[0]; - _futures.add(s_executor.scheduleAtFixedRate(new Task(req), cmd.getInterval(), cmd.getInterval(), TimeUnit.SECONDS)); + _futures.add(_agentMgr.getDirectAgentPool().scheduleAtFixedRate(new Task(req), cmd.getInterval(), cmd.getInterval(), TimeUnit.SECONDS)); } } } @@ -113,7 +108,7 @@ public class DirectAgentAttache extends AgentAttache { StartupAnswer startup = (StartupAnswer)answers[0]; int interval = startup.getPingInterval(); s_logger.info("StartupAnswer received " + startup.getHostId() + " Interval = " + interval ); - _futures.add(s_executor.scheduleAtFixedRate(new PingTask(), interval, interval, TimeUnit.SECONDS)); + _futures.add(_agentMgr.getDirectAgentPool().scheduleAtFixedRate(new PingTask(), interval, interval, TimeUnit.SECONDS)); } } diff --git a/server/src/com/cloud/api/ApiDBUtils.java b/server/src/com/cloud/api/ApiDBUtils.java index 5e8a044691d..dfdeb9c0957 100755 --- a/server/src/com/cloud/api/ApiDBUtils.java +++ b/server/src/com/cloud/api/ApiDBUtils.java @@ -111,6 +111,7 @@ import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkDomainVO; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkRuleConfigVO; import com.cloud.network.NetworkVO; @@ -255,6 +256,7 @@ public class ApiDBUtils { private static StorageManager _storageMgr; private static UserVmManager _userVmMgr; private static NetworkManager _networkMgr; + private static NetworkModel _networkModel; private static StatsCollector _statsCollector; private static AccountDao _accountDao; @@ -350,6 +352,7 @@ public class ApiDBUtils { _storageMgr = locator.getManager(StorageManager.class); _userVmMgr = locator.getManager(UserVmManager.class); _networkMgr = locator.getManager(NetworkManager.class); + _networkModel = locator.getManager(NetworkModel.class); _configMgr = locator.getManager(ConfigurationService.class); _accountDao = locator.getDao(AccountDao.class); @@ -477,7 +480,7 @@ public class ApiDBUtils { } public static Long getPodIdForVlan(long vlanDbId) { - return _networkMgr.getPodIdForVlan(vlanDbId); + return _networkModel.getPodIdForVlan(vlanDbId); } public static String getVersion() { @@ -844,11 +847,11 @@ public class ApiDBUtils { } public static Map> getNetworkCapabilities(long networkId, long zoneId) { - return _networkMgr.getNetworkCapabilities(networkId); + return _networkModel.getNetworkCapabilities(networkId); } public static long getPublicNetworkIdByZone(long zoneId) { - return _networkMgr.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId(); + return _networkModel.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId(); } public static Long getVlanNetworkId(long vlanId) { @@ -878,7 +881,7 @@ public class ApiDBUtils { } public static Long getDedicatedNetworkDomain(long networkId) { - return _networkMgr.getDedicatedNetworkDomain(networkId); + return _networkModel.getDedicatedNetworkDomain(networkId); } public static float getCpuOverprovisioningFactor() { @@ -931,25 +934,25 @@ public class ApiDBUtils { } public static Map> listNetworkOfferingServices(long networkOfferingId) { - return _networkMgr.getNetworkOfferingServiceProvidersMap(networkOfferingId); + return _networkModel.getNetworkOfferingServiceProvidersMap(networkOfferingId); } public static List getElementServices(Provider provider) { - return _networkMgr.getElementServices(provider); + return _networkModel.getElementServices(provider); } public static List getProvidersForService(Service service) { - return _networkMgr.listSupportedNetworkServiceProviders(service.getName()); + return _networkModel.listSupportedNetworkServiceProviders(service.getName()); } public static boolean canElementEnableIndividualServices(Provider serviceProvider) { - return _networkMgr.canElementEnableIndividualServices(serviceProvider); + return _networkModel.canElementEnableIndividualServices(serviceProvider); } public static Pair getDomainNetworkDetails(long networkId) { NetworkDomainVO map = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId); - boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : _networkMgr.getAllowSubdomainAccessGlobal(); + boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : _networkModel.getAllowSubdomainAccessGlobal(); return new Pair(map.getDomainId(), subdomainAccess); } @@ -976,11 +979,11 @@ public class ApiDBUtils { } public static List listVpcNetworks(long vpcId) { - return _networkMgr.listNetworksByVpc(vpcId); + return _networkModel.listNetworksByVpc(vpcId); } public static boolean canUseForDeploy(Network network) { - return _networkMgr.canUseForDeploy(network); + return _networkModel.canUseForDeploy(network); } public static String getUuid(String resourceId, TaggedResourceType resourceType) { diff --git a/server/src/com/cloud/api/ApiDispatcher.java b/server/src/com/cloud/api/ApiDispatcher.java index 04b46e5a579..129ef7d4a2e 100755 --- a/server/src/com/cloud/api/ApiDispatcher.java +++ b/server/src/com/cloud/api/ApiDispatcher.java @@ -349,7 +349,6 @@ public class ApiDispatcher { try { internalId = Long.parseLong(uuid); } catch(NumberFormatException e) { - // In case regex failed, and it's still uuid string internalId = null; } if (internalId != null) @@ -381,10 +380,8 @@ public class ApiDispatcher { if (s_logger.isDebugEnabled()) { s_logger.debug("Object entity with uuid=" + uuid + " does not exist in the database."); } - if (annotation.required()) { - throw new InvalidParameterValueException("Invalid parameter with uuid=" + uuid - + ". Entity not found, or an annotation bug."); - } + throw new InvalidParameterValueException("Invalid parameter value=" + uuid + + " due to incorrect long value, entity not found, or an annotation bug."); } return internalId; } diff --git a/server/src/com/cloud/api/ApiServer.java b/server/src/com/cloud/api/ApiServer.java index fc197b943e6..ac1ba0a651a 100755 --- a/server/src/com/cloud/api/ApiServer.java +++ b/server/src/com/cloud/api/ApiServer.java @@ -51,6 +51,7 @@ import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import com.cloud.utils.ReflectUtil; +import org.apache.cloudstack.acl.APILimitChecker; import org.apache.cloudstack.acl.APIChecker; import org.apache.cloudstack.acl.RoleType; import org.apache.cloudstack.api.*; @@ -118,6 +119,7 @@ import com.cloud.exception.CloudAuthenticationException; import com.cloud.exception.InsufficientCapacityException; import com.cloud.exception.InvalidParameterValueException; import com.cloud.exception.PermissionDeniedException; +import com.cloud.exception.RequestLimitException; import com.cloud.exception.ResourceAllocationException; import com.cloud.exception.ResourceUnavailableException; import com.cloud.server.ManagementServer; @@ -150,6 +152,8 @@ public class ApiServer implements HttpRequestHandler { @Inject private DomainManager _domainMgr = null; @Inject private AsyncJobManager _asyncMgr = null; + @Inject(adapter = APILimitChecker.class) + protected Adapters _apiLimitCheckers; @Inject(adapter = APIChecker.class) protected Adapters _apiAccessCheckers; @@ -256,7 +260,7 @@ public class ApiServer implements HttpRequestHandler { // (Immutable)Multimap paramMultiMap = HashMultimap.create(); // Map> parameterMap = paramMultiMap.asMap(); Map parameterMap = new HashMap(); - String responseType = BaseCmd.RESPONSE_TYPE_JSON; + String responseType = BaseCmd.RESPONSE_TYPE_XML; for (NameValuePair param : paramList) { if (param.getName().equalsIgnoreCase("response")) { responseType = param.getValue(); @@ -267,7 +271,7 @@ public class ApiServer implements HttpRequestHandler { // Check responseType, if not among valid types, fallback to JSON if (!(responseType.equals(BaseCmd.RESPONSE_TYPE_JSON) || responseType.equals(BaseCmd.RESPONSE_TYPE_XML))) - responseType = BaseCmd.RESPONSE_TYPE_JSON; + responseType = BaseCmd.RESPONSE_TYPE_XML; try { // always trust commands from API port, user context will always be UID_SYSTEM/ACCOUNT_ID_SYSTEM @@ -382,6 +386,7 @@ public class ApiServer implements HttpRequestHandler { if (UserContext.current().getCaller().getType() != Account.ACCOUNT_TYPE_ADMIN){ // hide internal details to non-admin user for security reason errorMsg = BaseCmd.USER_ERROR_MESSAGE; + } throw new ServerApiException(ApiErrorCode.INSUFFICIENT_CAPACITY_ERROR, errorMsg, ex); } @@ -585,6 +590,7 @@ public class ApiServer implements HttpRequestHandler { // if userId not null, that mean that user is logged in if (userId != null) { User user = ApiDBUtils.findUserById(userId); + try{ checkCommandAvailable(user, commandName); } @@ -592,6 +598,10 @@ public class ApiServer implements HttpRequestHandler { s_logger.debug("The given command:" + commandName + " does not exist or it is not available for user with id:" + userId); throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "The given command does not exist or it is not available for user"); } + catch (RequestLimitException ex){ + s_logger.debug(ex.getMessage()); + throw new ServerApiException(ApiErrorCode.API_LIMIT_EXCEED, ex.getMessage()); + } return true; } else { // check against every available command to see if the command exists or not @@ -821,6 +831,7 @@ public class ApiServer implements HttpRequestHandler { return true; } + private void checkCommandAvailable(User user, String commandName) throws PermissionDeniedException { if (user == null) { throw new PermissionDeniedException("User is null for role based API access check for command" + commandName); diff --git a/server/src/com/cloud/api/ApiServlet.java b/server/src/com/cloud/api/ApiServlet.java index 92d3137d30a..0f8924a080c 100755 --- a/server/src/com/cloud/api/ApiServlet.java +++ b/server/src/com/cloud/api/ApiServlet.java @@ -304,13 +304,11 @@ public class ApiServlet extends HttpServlet { * key mechanism updateUserContext(params, session != null ? session.getId() : null); */ - auditTrailSb.insert(0, - "(userId=" + UserContext.current().getCallerUserId() + " accountId=" + UserContext.current().getCaller().getId() + " sessionId=" + (session != null ? session.getId() : null) - + ")"); + auditTrailSb.insert(0, "(userId=" + UserContext.current().getCallerUserId() + " accountId=" + + UserContext.current().getCaller().getId() + " sessionId=" + (session != null ? session.getId() : null) + ")"); String response = _apiServer.handleRequest(params, false, responseType, auditTrailSb); writeResponse(resp, response != null ? response : "", HttpServletResponse.SC_OK, responseType); - } else { if (session != null) { try { diff --git a/server/src/com/cloud/async/AsyncJobExecutorContext.java b/server/src/com/cloud/async/AsyncJobExecutorContext.java index 109fb5383f0..390a4103351 100644 --- a/server/src/com/cloud/async/AsyncJobExecutorContext.java +++ b/server/src/com/cloud/async/AsyncJobExecutorContext.java @@ -19,7 +19,7 @@ package com.cloud.async; import com.cloud.agent.AgentManager; import com.cloud.async.dao.AsyncJobDao; import com.cloud.event.dao.EventDao; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.dao.IPAddressDao; import com.cloud.server.ManagementServer; import com.cloud.storage.StorageManager; @@ -37,7 +37,7 @@ import com.cloud.vm.dao.UserVmDao; public interface AsyncJobExecutorContext extends Manager { public ManagementServer getManagementServer(); public AgentManager getAgentMgr(); - public NetworkManager getNetworkMgr(); + public NetworkModel getNetworkMgr(); public UserVmManager getVmMgr(); public SnapshotManager getSnapshotMgr(); public AccountManager getAccountMgr(); diff --git a/server/src/com/cloud/async/AsyncJobExecutorContextImpl.java b/server/src/com/cloud/async/AsyncJobExecutorContextImpl.java index 5676b7c8aa2..dee1f58bd8c 100644 --- a/server/src/com/cloud/async/AsyncJobExecutorContextImpl.java +++ b/server/src/com/cloud/async/AsyncJobExecutorContextImpl.java @@ -25,6 +25,7 @@ import com.cloud.agent.AgentManager; import com.cloud.async.dao.AsyncJobDao; import com.cloud.event.dao.EventDao; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.dao.IPAddressDao; import com.cloud.server.ManagementServer; import com.cloud.storage.StorageManager; @@ -44,7 +45,7 @@ public class AsyncJobExecutorContextImpl implements AsyncJobExecutorContext { private String _name; private AgentManager _agentMgr; - private NetworkManager _networkMgr; + private NetworkModel _networkMgr; private UserVmManager _vmMgr; private SnapshotManager _snapMgr; private AccountManager _accountMgr; @@ -72,7 +73,7 @@ public class AsyncJobExecutorContextImpl implements AsyncJobExecutorContext { } @Override - public NetworkManager getNetworkMgr() { + public NetworkModel getNetworkMgr() { return _networkMgr; } @@ -159,9 +160,9 @@ public class AsyncJobExecutorContextImpl implements AsyncJobExecutorContext { throw new ConfigurationException("unable to get " + AgentManager.class.getName()); } - _networkMgr = locator.getManager(NetworkManager.class); + _networkMgr = locator.getManager(NetworkModel.class); if (_networkMgr == null) { - throw new ConfigurationException("unable to get " + NetworkManager.class.getName()); + throw new ConfigurationException("unable to get " + NetworkModel.class.getName()); } _vmMgr = locator.getManager(UserVmManager.class); diff --git a/server/src/com/cloud/baremetal/BareMetalVmManagerImpl.java b/server/src/com/cloud/baremetal/BareMetalVmManagerImpl.java index 2e325ec4f02..57cfb396d3e 100755 --- a/server/src/com/cloud/baremetal/BareMetalVmManagerImpl.java +++ b/server/src/com/cloud/baremetal/BareMetalVmManagerImpl.java @@ -307,7 +307,7 @@ public class BareMetalVmManagerImpl extends UserVmManagerImpl implements BareMet s_logger.warn("Bare Metal only supports basical network mode now, switch to baisc network automatically"); } - Network defaultNetwork = _networkMgr.getExclusiveGuestNetwork(dc.getId()); + Network defaultNetwork = _networkModel.getExclusiveGuestNetwork(dc.getId()); if (defaultNetwork == null) { throw new InvalidParameterValueException("Unable to find a default network to start a vm"); } diff --git a/server/src/com/cloud/baremetal/ExternalDhcpResourceBase.java b/server/src/com/cloud/baremetal/ExternalDhcpResourceBase.java index cbfcfd15f9a..69846ac4ec4 100644 --- a/server/src/com/cloud/baremetal/ExternalDhcpResourceBase.java +++ b/server/src/com/cloud/baremetal/ExternalDhcpResourceBase.java @@ -127,7 +127,7 @@ public class ExternalDhcpResourceBase implements ServerResource { cmd.setPod(_podId); cmd.setPrivateIpAddress(_ip); cmd.setStorageIpAddress(""); - cmd.setVersion(""); + cmd.setVersion(ExternalDhcpResourceBase.class.getPackage().getImplementationVersion()); cmd.setGuid(_guid); return new StartupCommand[]{cmd}; } diff --git a/server/src/com/cloud/baremetal/PxeServerResourceBase.java b/server/src/com/cloud/baremetal/PxeServerResourceBase.java index c307ccfc111..46982b1942a 100644 --- a/server/src/com/cloud/baremetal/PxeServerResourceBase.java +++ b/server/src/com/cloud/baremetal/PxeServerResourceBase.java @@ -114,7 +114,7 @@ public class PxeServerResourceBase implements ServerResource { cmd.setPod(_podId); cmd.setPrivateIpAddress(_ip); cmd.setStorageIpAddress(""); - cmd.setVersion(""); + cmd.setVersion(PxeServerResourceBase.class.getPackage().getImplementationVersion()); cmd.setGuid(_guid); return new StartupCommand[]{cmd}; } diff --git a/server/src/com/cloud/configuration/Config.java b/server/src/com/cloud/configuration/Config.java index b91fbdd69bf..4ae144e6ce1 100755 --- a/server/src/com/cloud/configuration/Config.java +++ b/server/src/com/cloud/configuration/Config.java @@ -296,8 +296,8 @@ public enum Config { VmOpCleanupWait("Advanced", ManagementServer.class, Long.class, "vm.op.cleanup.wait", "3600", "Time (in seconds) to wait before cleanuping up any vm work items", "Seconds"), VmOpCancelInterval("Advanced", ManagementServer.class, Long.class, "vm.op.cancel.interval", "3600", "Time (in seconds) to wait before cancelling a operation", "Seconds"), - DefaultPageSize("Advanced", ManagementServer.class, Long.class, "default.page.size", "500", "Default page size for API list* commands", null), + DirectAgentPoolSize("Advanced", ManagementServer.class, Integer.class, "direct.agent.pool.size", "500", "Default size for DirectAgentPool", null), TaskCleanupRetryInterval("Advanced", ManagementServer.class, Integer.class, "task.cleanup.retry.interval", "600", "Time (in seconds) to wait before retrying cleanup of tasks if the cleanup failed previously. 0 means to never retry.", "Seconds"), @@ -360,7 +360,6 @@ public enum Config { ConcurrentSnapshotsThresholdPerHost("Advanced", ManagementServer.class, Long.class, "concurrent.snapshots.threshold.perhost", null, "Limits number of snapshots that can be handled by the host concurrently; default is NULL - unlimited", null); - private final String _category; private final Class _componentClass; private final Class _type; diff --git a/server/src/com/cloud/configuration/ConfigurationManagerImpl.java b/server/src/com/cloud/configuration/ConfigurationManagerImpl.java index 95262797c0d..df6642af9ca 100755 --- a/server/src/com/cloud/configuration/ConfigurationManagerImpl.java +++ b/server/src/com/cloud/configuration/ConfigurationManagerImpl.java @@ -107,6 +107,8 @@ import com.cloud.network.Network.GuestType; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; +import com.cloud.network.NetworkService; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.BroadcastDomainType; import com.cloud.network.Networks.TrafficType; @@ -208,6 +210,10 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura @Inject NetworkManager _networkMgr; @Inject + NetworkService _networkSvc; + @Inject + NetworkModel _networkModel; + @Inject ClusterDao _clusterDao; @Inject AlertManager _alertMgr; @@ -753,7 +759,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura } // Delete vlans associated with the pod - List vlans = _networkMgr.listPodVlans(podId); + List vlans = _networkModel.listPodVlans(podId); if (vlans != null && !vlans.isEmpty()) { for (Vlan vlan : vlans) { _vlanDao.remove(vlan.getId()); @@ -1522,18 +1528,18 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura PhysicalNetwork mgmtPhyNetwork; if (NetworkType.Advanced == zone.getNetworkType()) { // zone should have a physical network with public and management traffiType - _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Public); - mgmtPhyNetwork = _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Management); + _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Public); + mgmtPhyNetwork = _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Management); } else { // zone should have a physical network with management traffiType - mgmtPhyNetwork = _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Management); + mgmtPhyNetwork = _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Management); } try { - _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Storage); + _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Storage); } catch (InvalidParameterValueException noStorage) { PhysicalNetworkTrafficTypeVO mgmtTraffic = _trafficTypeDao.findBy(mgmtPhyNetwork.getId(), TrafficType.Management); - _networkMgr.addTrafficTypeToPhysicalNetwork(mgmtPhyNetwork.getId(), TrafficType.Storage.toString(), mgmtTraffic.getXenNetworkLabel(), mgmtTraffic.getKvmNetworkLabel(), + _networkSvc.addTrafficTypeToPhysicalNetwork(mgmtPhyNetwork.getId(), TrafficType.Storage.toString(), mgmtTraffic.getXenNetworkLabel(), mgmtTraffic.getKvmNetworkLabel(), mgmtTraffic.getVmwareNetworkLabel(), mgmtTraffic.getSimulatorNetworkLabel(), mgmtTraffic.getVlan()); s_logger.info("No storage traffic type was specified by admin, create default storage traffic on physical network " + mgmtPhyNetwork.getId() + " with same configure of management traffic type"); } @@ -2134,14 +2140,14 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura } else { if (forVirtualNetwork) { // default physical network with public traffic in the zone - physicalNetworkId = _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId(); + physicalNetworkId = _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId(); } else { if (zone.getNetworkType() == DataCenter.NetworkType.Basic) { // default physical network with guest traffic in the zone - physicalNetworkId = _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Guest).getId(); + physicalNetworkId = _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Guest).getId(); } else if (zone.getNetworkType() == DataCenter.NetworkType.Advanced) { if (zone.isSecurityGroupEnabled()) { - physicalNetworkId = _networkMgr.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Guest).getId(); + physicalNetworkId = _networkModel.getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Guest).getId(); } else { throw new InvalidParameterValueException("Physical Network Id is null, please provide the Network id for Direct vlan creation "); } @@ -2165,18 +2171,18 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura if (forVirtualNetwork) { if (network == null) { // find default public network in the zone - networkId = _networkMgr.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId(); - network = _networkMgr.getNetwork(networkId); + networkId = _networkModel.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId(); + network = _networkModel.getNetwork(networkId); } else if (network.getGuestType() != null || network.getTrafficType() != TrafficType.Public) { throw new InvalidParameterValueException("Can't find Public network by id=" + networkId); } } else { if (network == null) { if (zone.getNetworkType() == DataCenter.NetworkType.Basic) { - networkId = _networkMgr.getExclusiveGuestNetwork(zoneId).getId(); - network = _networkMgr.getNetwork(networkId); + networkId = _networkModel.getExclusiveGuestNetwork(zoneId).getId(); + network = _networkModel.getNetwork(networkId); } else { - network = _networkMgr.getNetworkWithSecurityGroupEnabled(zoneId); + network = _networkModel.getNetworkWithSecurityGroupEnabled(zoneId); if (network == null) { throw new InvalidParameterValueException("Nework id is required for Direct vlan creation "); } @@ -2276,7 +2282,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura String vlanId, Account vlanOwner) { - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); //Validate the zone DataCenterVO zone = _zoneDao.findById(zoneId); @@ -2517,7 +2523,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura " as ip " + ip + " belonging to the range is used for static nat purposes. Cleanup the rules first"); } - if (ip.isSourceNat() && _networkMgr.getNetwork(ip.getAssociatedWithNetworkId()) != null) { + if (ip.isSourceNat() && _networkModel.getNetwork(ip.getAssociatedWithNetworkId()) != null) { throw new InvalidParameterValueException("Can't delete account specific vlan " + vlanDbId + " as ip " + ip + " belonging to the range is a source nat ip for the network id=" + ip.getSourceNetworkId() + ". IP range with the source nat ip address can be removed either as a part of Network, or account removal"); @@ -3061,7 +3067,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura } // validate providers combination here - _networkMgr.canProviderSupportServices(providerCombinationToVerify); + _networkModel.canProviderSupportServices(providerCombinationToVerify); // validate the LB service capabilities specified in the network offering Map lbServiceCapabilityMap = cmd.getServiceCapabilities(Service.Lb); @@ -3237,7 +3243,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura if ((lbServiceCapabilityMap != null) && (!lbServiceCapabilityMap.isEmpty())) { String isolationCapability = lbServiceCapabilityMap.get(Capability.SupportedLBIsolation); if (isolationCapability != null) { - _networkMgr.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.SupportedLBIsolation, isolationCapability); + _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.SupportedLBIsolation, isolationCapability); dedicatedLb = isolationCapability.contains("dedicated"); } else { dedicatedLb = true; @@ -3250,7 +3256,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura String inlineMode = lbServiceCapabilityMap.get(Capability.InlineMode); if (inlineMode != null) { - _networkMgr.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.InlineMode, inlineMode); + _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.InlineMode, inlineMode); inline = inlineMode.contains("true"); } else { inline = false; @@ -3261,14 +3267,14 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura if ((sourceNatServiceCapabilityMap != null) && (!sourceNatServiceCapabilityMap.isEmpty())) { String sourceNatType = sourceNatServiceCapabilityMap.get(Capability.SupportedSourceNatTypes); if (sourceNatType != null) { - _networkMgr.checkCapabilityForProvider(serviceProviderMap.get(Service.SourceNat), Service.SourceNat, + _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.SourceNat), Service.SourceNat, Capability.SupportedSourceNatTypes, sourceNatType); sharedSourceNat = sourceNatType.contains("perzone"); } String param = sourceNatServiceCapabilityMap.get(Capability.RedundantRouter); if (param != null) { - _networkMgr.checkCapabilityForProvider(serviceProviderMap.get(Service.SourceNat), Service.SourceNat, + _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.SourceNat), Service.SourceNat, Capability.RedundantRouter, param); redundantRouter = param.contains("true"); } @@ -3424,7 +3430,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura Network network = null; if (networkId != null) { // check if network exists and the caller can operate with it - network = _networkMgr.getNetwork(networkId); + network = _networkModel.getNetwork(networkId); if (network == null) { throw new InvalidParameterValueException("Unable to find the network by id=" + networkId); } @@ -3436,7 +3442,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura _accountMgr.checkAccess(caller, null, true, network); - List offeringIds = _networkMgr.listNetworkOfferingsForUpgrade(networkId); + List offeringIds = _networkModel.listNetworkOfferingsForUpgrade(networkId); if (!offeringIds.isEmpty()) { sc.addAnd("id", SearchCriteria.Op.IN, offeringIds.toArray()); @@ -3515,21 +3521,21 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura } if (listBySupportedServices) { - addOffering = addOffering && _networkMgr.areServicesSupportedByNetworkOffering(offering.getId(), supportedServices); + addOffering = addOffering && _networkModel.areServicesSupportedByNetworkOffering(offering.getId(), supportedServices); } if (checkIfProvidersAreEnabled) { if (supportedServices != null && supportedServices.length > 0) { checkForProviders = Arrays.asList(supportedServices); } else { - checkForProviders = _networkMgr.listNetworkOfferingServices(offering.getId()); + checkForProviders = _networkModel.listNetworkOfferingServices(offering.getId()); } - addOffering = addOffering && _networkMgr.areServicesEnabledInZone(zoneId, offering, checkForProviders); + addOffering = addOffering && _networkModel.areServicesEnabledInZone(zoneId, offering, checkForProviders); } if (sourceNatSupported != null) { - addOffering = addOffering && (_networkMgr.areServicesSupportedByNetworkOffering(offering.getId(), Network.Service.SourceNat) == sourceNatSupported); + addOffering = addOffering && (_networkModel.areServicesSupportedByNetworkOffering(offering.getId(), Network.Service.SourceNat) == sourceNatSupported); } if (forVpc != null) { @@ -3654,7 +3660,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura } else { if (availability == NetworkOffering.Availability.Required) { boolean canOffBeRequired = (offeringToUpdate.getGuestType() == GuestType.Isolated - && _networkMgr.areServicesSupportedByNetworkOffering(offeringToUpdate.getId(), Service.SourceNat)); + && _networkModel.areServicesSupportedByNetworkOffering(offeringToUpdate.getId(), Service.SourceNat)); if (!canOffBeRequired) { throw new InvalidParameterValueException("Availability can be " + NetworkOffering.Availability.Required + " only for networkOfferings of type " + GuestType.Isolated + " and with " @@ -3780,7 +3786,7 @@ public class ConfigurationManagerImpl implements ConfigurationManager, Configura Long networkId = vlan.getNetworkId(); if (networkId != null) { - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); if (network != null) { accountId = network.getAccountId(); } diff --git a/server/src/com/cloud/configuration/DefaultComponentLibrary.java b/server/src/com/cloud/configuration/DefaultComponentLibrary.java index 8c6d35f45e0..e98946b9aa7 100755 --- a/server/src/com/cloud/configuration/DefaultComponentLibrary.java +++ b/server/src/com/cloud/configuration/DefaultComponentLibrary.java @@ -89,6 +89,8 @@ import com.cloud.maint.UpgradeManagerImpl; import com.cloud.maint.dao.AgentUpgradeDaoImpl; import com.cloud.network.ExternalLoadBalancerUsageManagerImpl; import com.cloud.network.NetworkManagerImpl; +import com.cloud.network.NetworkModelImpl; +import com.cloud.network.NetworkServiceImpl; import com.cloud.network.StorageNetworkManagerImpl; import com.cloud.network.as.AutoScaleManagerImpl; import com.cloud.network.as.dao.AutoScalePolicyConditionMapDaoImpl; @@ -413,7 +415,9 @@ public class DefaultComponentLibrary extends ComponentLibraryBase implements Com addManager("account manager", AccountManagerImpl.class); addManager("domain manager", DomainManagerImpl.class); addManager("resource limit manager", ResourceLimitManagerImpl.class); + addManager("network service", NetworkServiceImpl.class); addManager("network manager", NetworkManagerImpl.class); + addManager("network model", NetworkModelImpl.class); addManager("download manager", DownloadMonitorImpl.class); addManager("upload manager", UploadMonitorImpl.class); addManager("keystore manager", KeystoreManagerImpl.class); diff --git a/server/src/com/cloud/consoleproxy/ConsoleProxyManagerImpl.java b/server/src/com/cloud/consoleproxy/ConsoleProxyManagerImpl.java index 5bc5d27ee08..6b2d8ad8e42 100755 --- a/server/src/com/cloud/consoleproxy/ConsoleProxyManagerImpl.java +++ b/server/src/com/cloud/consoleproxy/ConsoleProxyManagerImpl.java @@ -94,13 +94,14 @@ import com.cloud.keystore.KeystoreVO; import com.cloud.network.IPAddressVO; import com.cloud.network.Network; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; import com.cloud.network.dao.IPAddressDao; import com.cloud.network.dao.NetworkDao; import com.cloud.network.rules.RulesManager; +import com.cloud.offering.NetworkOffering; import com.cloud.offering.ServiceOffering; -import com.cloud.offerings.NetworkOfferingVO; import com.cloud.offerings.dao.NetworkOfferingDao; import com.cloud.resource.ResourceManager; import com.cloud.resource.ResourceStateAdapter; @@ -212,6 +213,8 @@ public class ConsoleProxyManagerImpl implements ConsoleProxyManager, ConsoleProx @Inject NetworkManager _networkMgr; @Inject + NetworkModel _networkModel; + @Inject AccountManager _accountMgr; @Inject ServiceOfferingDao _offeringDao; @@ -236,9 +239,9 @@ public class ConsoleProxyManagerImpl implements ConsoleProxyManager, ConsoleProx private ServiceOfferingVO _serviceOffering; - NetworkOfferingVO _publicNetworkOffering; - NetworkOfferingVO _managementNetworkOffering; - NetworkOfferingVO _linkLocalNetworkOffering; + NetworkOffering _publicNetworkOffering; + NetworkOffering _managementNetworkOffering; + NetworkOffering _linkLocalNetworkOffering; @Inject private VirtualMachineManager _itMgr; @@ -766,7 +769,7 @@ public class ConsoleProxyManagerImpl implements ConsoleProxyManager, ConsoleProx NetworkVO defaultNetwork = defaultNetworks.get(0); - List offerings = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemControlNetwork, NetworkOfferingVO.SystemManagementNetwork); + List offerings = _networkModel.getSystemAccountNetworkOfferings(NetworkOffering.SystemControlNetwork, NetworkOffering.SystemManagementNetwork); List> networks = new ArrayList>(offerings.size() + 1); NicProfile defaultNic = new NicProfile(); defaultNic.setDefaultNic(true); @@ -774,7 +777,7 @@ public class ConsoleProxyManagerImpl implements ConsoleProxyManager, ConsoleProx networks.add(new Pair(_networkMgr.setupNetwork(systemAcct, _networkOfferingDao.findById(defaultNetwork.getNetworkOfferingId()), plan, null, null, false).get(0), defaultNic)); - for (NetworkOfferingVO offering : offerings) { + for (NetworkOffering offering : offerings) { networks.add(new Pair(_networkMgr.setupNetwork(systemAcct, offering, plan, null, null, false).get(0), null)); } diff --git a/server/src/com/cloud/ha/ManagementIPSystemVMInvestigator.java b/server/src/com/cloud/ha/ManagementIPSystemVMInvestigator.java index 8a5b02af282..ea9620204cd 100644 --- a/server/src/com/cloud/ha/ManagementIPSystemVMInvestigator.java +++ b/server/src/com/cloud/ha/ManagementIPSystemVMInvestigator.java @@ -27,7 +27,7 @@ import org.apache.log4j.Logger; import com.cloud.host.HostVO; import com.cloud.host.Status; import com.cloud.host.dao.HostDao; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks.TrafficType; import com.cloud.utils.component.Inject; import com.cloud.vm.Nic; @@ -40,7 +40,7 @@ public class ManagementIPSystemVMInvestigator extends AbstractInvestigatorImpl { private String _name = null; @Inject private HostDao _hostDao = null; - @Inject private NetworkManager _networkMgr = null; + @Inject private NetworkModel _networkMgr = null; @Override diff --git a/server/src/com/cloud/ha/UserVmDomRInvestigator.java b/server/src/com/cloud/ha/UserVmDomRInvestigator.java index 5a3e55025e7..e058a6f4f47 100644 --- a/server/src/com/cloud/ha/UserVmDomRInvestigator.java +++ b/server/src/com/cloud/ha/UserVmDomRInvestigator.java @@ -31,7 +31,7 @@ import com.cloud.agent.api.PingTestCommand; import com.cloud.host.HostVO; import com.cloud.host.Status; import com.cloud.hypervisor.Hypervisor.HypervisorType; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks.TrafficType; import com.cloud.network.router.VirtualRouter; import com.cloud.network.router.VpcVirtualNetworkApplianceManager; @@ -49,7 +49,7 @@ public class UserVmDomRInvestigator extends AbstractInvestigatorImpl { private String _name = null; @Inject private final UserVmDao _userVmDao = null; @Inject private final AgentManager _agentMgr = null; - @Inject private final NetworkManager _networkMgr = null; + @Inject private final NetworkModel _networkMgr = null; @Inject private final VpcVirtualNetworkApplianceManager _vnaMgr = null; @Override diff --git a/server/src/com/cloud/hypervisor/kvm/discoverer/KvmServerDiscoverer.java b/server/src/com/cloud/hypervisor/kvm/discoverer/KvmServerDiscoverer.java index 8ce6b8ad8ee..60b6e7f5601 100644 --- a/server/src/com/cloud/hypervisor/kvm/discoverer/KvmServerDiscoverer.java +++ b/server/src/com/cloud/hypervisor/kvm/discoverer/KvmServerDiscoverer.java @@ -52,7 +52,7 @@ import com.cloud.host.dao.HostDao; import com.cloud.hypervisor.Hypervisor; import com.cloud.hypervisor.Hypervisor.HypervisorType; import com.cloud.hypervisor.kvm.discoverer.KvmDummyResourceBase; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.PhysicalNetworkSetupInfo; import com.cloud.resource.Discoverer; import com.cloud.resource.DiscovererBase; @@ -79,7 +79,7 @@ public class KvmServerDiscoverer extends DiscovererBase implements Discoverer, @Inject ClusterDao _clusterDao; @Inject ResourceManager _resourceMgr; @Inject AgentManager _agentMgr; - @Inject NetworkManager _networkMgr; + @Inject NetworkModel _networkMgr; @Override public boolean processAnswers(long agentId, long seq, Answer[] answers) { diff --git a/server/src/com/cloud/network/ExternalFirewallDeviceManagerImpl.java b/server/src/com/cloud/network/ExternalFirewallDeviceManagerImpl.java index 42cdc745605..582e86b30ec 100644 --- a/server/src/com/cloud/network/ExternalFirewallDeviceManagerImpl.java +++ b/server/src/com/cloud/network/ExternalFirewallDeviceManagerImpl.java @@ -109,7 +109,7 @@ public abstract class ExternalFirewallDeviceManagerImpl extends AdapterBase impl @Inject HostDao _hostDao; @Inject NetworkServiceMapDao _ntwkSrvcProviderDao; @Inject DataCenterDao _dcDao; - @Inject NetworkManager _networkMgr; + @Inject NetworkModel _networkMgr; @Inject InlineLoadBalancerNicMapDao _inlineLoadBalancerNicMapDao; @Inject NicDao _nicDao; @Inject AgentManager _agentMgr; @@ -420,8 +420,8 @@ public abstract class ExternalFirewallDeviceManagerImpl extends AdapterBase impl IPAddressVO sourceNatIp = null; if (!sharedSourceNat) { - // Get the source NAT IP address for this account - List sourceNatIps = _networkMgr.listPublicIpsAssignedToAccount(network.getAccountId(), + // Get the source NAT IP address for this account + List sourceNatIps = _networkMgr.listPublicIpsAssignedToAccount(network.getAccountId(), zoneId, true); if (sourceNatIps.size() != 1) { @@ -430,7 +430,7 @@ public abstract class ExternalFirewallDeviceManagerImpl extends AdapterBase impl s_logger.error(errorMsg); return true; } else { - sourceNatIp = sourceNatIps.get(0); + sourceNatIp = _ipAddressDao.findById(sourceNatIps.get(0).getId()); } } diff --git a/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java b/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java index 4f9404e5e78..275401cc58f 100644 --- a/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java +++ b/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java @@ -127,6 +127,8 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase @Inject DataCenterDao _dcDao; @Inject + NetworkModel _networkModel; + @Inject NetworkManager _networkMgr; @Inject InlineLoadBalancerNicMapDao _inlineLoadBalancerNicMapDao; @@ -743,7 +745,7 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase }; private MappingNic getLoadBalancingIpNic(DataCenterVO zone, Network network, long sourceIpId, boolean revoked, String existedGuestIp) throws ResourceUnavailableException { - String srcIp = _networkMgr.getIp(sourceIpId).getAddress().addr(); + String srcIp = _networkModel.getIp(sourceIpId).getAddress().addr(); InlineLoadBalancerNicMapVO mapping = _inlineLoadBalancerNicMapDao.findByPublicIpAddress(srcIp); NicVO loadBalancingIpNic = null; MappingNic nic = new MappingNic(); @@ -861,7 +863,7 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase String protocol = rule.getProtocol(); String algorithm = rule.getAlgorithm(); String uuid = rule.getUuid(); - String srcIp = _networkMgr.getIp(rule.getSourceIpAddressId()).getAddress().addr(); + String srcIp = _networkModel.getIp(rule.getSourceIpAddressId()).getAddress().addr(); int srcPort = rule.getSourcePortStart(); List destinations = rule.getDestinations(); @@ -970,7 +972,7 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase long guestVlanTag = Long.parseLong(guestConfig.getBroadcastUri().getHost()); String selfIp = null; String guestVlanNetmask = NetUtils.cidr2Netmask(guestConfig.getCidr()); - Integer networkRate = _networkMgr.getNetworkRate(guestConfig.getId(), null); + Integer networkRate = _networkModel.getNetworkRate(guestConfig.getId(), null); if (add) { // on restart network, network could have already been implemented. If already implemented then return @@ -1094,7 +1096,7 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase return null; } - NetworkElement element = _networkMgr.getElementImplementingProvider(providers.get(0).getName()); + NetworkElement element = _networkModel.getElementImplementingProvider(providers.get(0).getName()); if (!(element instanceof IpDeployer)) { s_logger.error("The firewall provider for network " + network.getName() + " don't have ability to deploy IP address!"); return null; diff --git a/server/src/com/cloud/network/ExternalLoadBalancerUsageManagerImpl.java b/server/src/com/cloud/network/ExternalLoadBalancerUsageManagerImpl.java index 67494965505..5a15a9be7db 100644 --- a/server/src/com/cloud/network/ExternalLoadBalancerUsageManagerImpl.java +++ b/server/src/com/cloud/network/ExternalLoadBalancerUsageManagerImpl.java @@ -88,7 +88,7 @@ public class ExternalLoadBalancerUsageManagerImpl implements ExternalLoadBalance @Inject DataCenterDao _dcDao; @Inject - NetworkManager _networkMgr; + NetworkModel _networkMgr; @Inject InlineLoadBalancerNicMapDao _inlineLoadBalancerNicMapDao; @Inject diff --git a/server/src/com/cloud/network/ExternalNetworkDeviceManagerImpl.java b/server/src/com/cloud/network/ExternalNetworkDeviceManagerImpl.java index 078b9e5d147..751777cc5ff 100755 --- a/server/src/com/cloud/network/ExternalNetworkDeviceManagerImpl.java +++ b/server/src/com/cloud/network/ExternalNetworkDeviceManagerImpl.java @@ -81,7 +81,7 @@ public class ExternalNetworkDeviceManagerImpl implements ExternalNetworkDeviceMa @Inject ExternalDhcpManager _dhcpMgr; @Inject PxeServerManager _pxeMgr; @Inject AgentManager _agentMgr; - @Inject NetworkManager _networkMgr; + @Inject NetworkModel _networkMgr; @Inject HostDao _hostDao; @Inject DataCenterDao _dcDao; @Inject AccountDao _accountDao; diff --git a/server/src/com/cloud/network/NetworkManager.java b/server/src/com/cloud/network/NetworkManager.java index 0ca28f889ba..546f1bf613c 100755 --- a/server/src/com/cloud/network/NetworkManager.java +++ b/server/src/com/cloud/network/NetworkManager.java @@ -16,14 +16,11 @@ // under the License. package com.cloud.network; -import java.util.ArrayList; import java.util.List; import java.util.Map; -import java.util.Set; import org.apache.cloudstack.acl.ControlledEntity.ACLType; import com.cloud.dc.DataCenter; -import com.cloud.dc.Vlan; import com.cloud.dc.Vlan.VlanType; import com.cloud.deploy.DataCenterDeployment; import com.cloud.deploy.DeployDestination; @@ -34,16 +31,10 @@ import com.cloud.exception.InsufficientCapacityException; import com.cloud.exception.InsufficientVirtualNetworkCapcityException; import com.cloud.exception.ResourceAllocationException; import com.cloud.exception.ResourceUnavailableException; -import com.cloud.hypervisor.Hypervisor.HypervisorType; -import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; -import com.cloud.network.Networks.TrafficType; import com.cloud.network.addr.PublicIp; import com.cloud.network.element.LoadBalancingServiceProvider; -import com.cloud.network.element.NetworkElement; -import com.cloud.network.element.RemoteAccessVPNServiceProvider; -import com.cloud.network.element.Site2SiteVpnServiceProvider; import com.cloud.network.element.StaticNatServiceProvider; import com.cloud.network.element.UserDataServiceProvider; import com.cloud.network.guru.NetworkGuru; @@ -52,6 +43,7 @@ import com.cloud.network.rules.StaticNat; import com.cloud.offering.NetworkOffering; import com.cloud.offerings.NetworkOfferingVO; import com.cloud.user.Account; +import com.cloud.user.User; import com.cloud.utils.Pair; import com.cloud.vm.Nic; import com.cloud.vm.NicProfile; @@ -65,7 +57,7 @@ import com.cloud.vm.VirtualMachineProfileImpl; * NetworkManager manages the network for the different end users. * */ -public interface NetworkManager extends NetworkService { +public interface NetworkManager { /** * Assigns a new public ip address. * @@ -98,27 +90,12 @@ public interface NetworkManager extends NetworkService { */ public boolean disassociatePublicIpAddress(long id, long userId, Account caller); - /** - * Lists IP addresses that belong to VirtualNetwork VLANs - * - * @param accountId - * - account that the IP address should belong to - * @param associatedNetworkId - * TODO - * @param sourceNat - * - (optional) true if the IP address should be a source NAT address - * @return - list of IP addresses - */ - List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat); - - List setupNetwork(Account owner, NetworkOfferingVO offering, DeploymentPlan plan, String name, String displayText, boolean isDefault) + List setupNetwork(Account owner, NetworkOffering offering, DeploymentPlan plan, String name, String displayText, boolean isDefault) throws ConcurrentOperationException; - List setupNetwork(Account owner, NetworkOfferingVO offering, Network predefined, DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, + List setupNetwork(Account owner, NetworkOffering offering, Network predefined, DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, ACLType aclType, Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException; - List getSystemAccountNetworkOfferings(String... offeringNames); - void allocate(VirtualMachineProfile vm, List> networks) throws InsufficientCapacityException, ConcurrentOperationException; void prepare(VirtualMachineProfile profile, DeployDestination dest, ReservationContext context) throws InsufficientCapacityException, ConcurrentOperationException, @@ -131,29 +108,13 @@ public interface NetworkManager extends NetworkService { void expungeNics(VirtualMachineProfile vm); - List getNics(long vmId); - List getNicProfiles(VirtualMachine vm); - String getNextAvailableMacAddressInNetwork(long networkConfigurationId) throws InsufficientAddressCapacityException; - - boolean applyRules(List rules, boolean continueOnError) throws ResourceUnavailableException; - - public boolean validateRule(FirewallRule rule); - - List getRemoteAccessVpnElements(); - - List getSite2SiteVpnElements(); - - PublicIpAddress getPublicIpAddress(long ipAddressId); - - List listPodVlans(long podId); + boolean applyRules(List rules, FirewallRule.Purpose purpose, NetworkRuleApplier applier, boolean continueOnError) throws ResourceUnavailableException; Pair implementNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException; - List listNetworksUsedByVm(long vmId, boolean isSystem); - void prepareNicForMigration(VirtualMachineProfile vm, DeployDestination dest); boolean shutdownNetwork(long networkId, ReservationContext context, boolean cleanupElements); @@ -181,133 +142,35 @@ public interface NetworkManager extends NetworkService { boolean associateIpAddressListToAccount(long userId, long accountId, long zoneId, Long vlanId, Network guestNetwork) throws InsufficientCapacityException, ConcurrentOperationException, ResourceUnavailableException, ResourceAllocationException; - Nic getNicInNetwork(long vmId, long networkId); - - List getNicsForTraffic(long vmId, TrafficType type); - - Network getDefaultNetworkForVm(long vmId); - - Nic getDefaultNic(long vmId); - UserDataServiceProvider getPasswordResetProvider(Network network); - UserDataServiceProvider getUserDataUpdateProvider(Network network); - - boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId); - - Map getNetworkServiceCapabilities(long networkId, Service service); - boolean applyIpAssociations(Network network, boolean continueOnError) throws ResourceUnavailableException; - - boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services); - - NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId); + + boolean applyIpAssociations(Network network, boolean rulesRevoked, boolean continueOnError, List publicIps) throws ResourceUnavailableException; boolean startNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException; - String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId); - - List listNetworksForAccount(long accountId, long zoneId, Network.GuestType type); - - List listAllNetworksInAllZonesByType(Network.GuestType type); - IPAddressVO markIpAsUnavailable(long addrId); public String acquireGuestIpAddress(Network network, String requestedIp); - String getGlobalGuestDomainSuffix(); - - String getStartIpAddress(long networkId); - boolean applyStaticNats(List staticNats, boolean continueOnError) throws ResourceUnavailableException; - String getIpInNetwork(long vmId, long networkId); - - String getIpInNetworkIncludingRemoved(long vmId, long networkId); - - Long getPodIdForVlan(long vlanDbId); - - List listNetworkOfferingsForUpgrade(long networkId); - - boolean isSecurityGroupSupportedInNetwork(Network network); - - boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider); - - boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName); - - String getNetworkTag(HypervisorType hType, Network network); - - List getElementServices(Provider provider); - - boolean canElementEnableIndividualServices(Provider provider); - - boolean areServicesSupportedInNetwork(long networkId, Service... services); - - boolean isNetworkSystem(Network network); - boolean reallocate(VirtualMachineProfile vm, DataCenterDeployment dest) throws InsufficientCapacityException, ConcurrentOperationException; - Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service); - - Long getPhysicalNetworkId(Network network); - - boolean getAllowSubdomainAccessGlobal(); - - boolean isProviderForNetwork(Provider provider, long networkId); - - boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId); - - void canProviderSupportServices(Map> providersMap); - - List getPhysicalNetworkInfo(long dcId, - HypervisorType hypervisorType); - - boolean canAddDefaultSecurityGroup(); - - List listNetworkOfferingServices(long networkOfferingId); - - boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services); - - public Map> getIpToServices(List publicIps, boolean rulesRevoked, boolean includingFirewall); - - public Map> getProviderToIpList(Network network, Map> ipToServices); - - public boolean checkIpForService(IPAddressVO ip, Service service, Long networkId); - - void checkCapabilityForProvider(Set providers, Service service, - Capability cap, String capValue); - - Provider getDefaultUniqueProviderForService(String serviceName); - IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) throws InsufficientAddressCapacityException; boolean handleSystemIpRelease(IpAddress ip); - void checkNetworkPermissions(Account owner, Network network); - void allocateDirectIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, Network network, String requestedIp) throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException; - String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType); - - String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType); - - String getDefaultPublicTrafficLabel(long dcId, HypervisorType vmware); - - String getDefaultGuestTrafficLabel(long dcId, HypervisorType vmware); - - /** - * @param providerName - * @return - */ - NetworkElement getElementImplementingProvider(String providerName); - /** * @param owner * @param guestNetwork @@ -318,27 +181,6 @@ public interface NetworkManager extends NetworkService { PublicIp assignSourceNatIpAddressToGuestNetwork(Account owner, Network guestNetwork) throws InsufficientAddressCapacityException, ConcurrentOperationException; - /** - * @param accountId - * @param zoneId - * @return - */ - String getAccountNetworkDomain(long accountId, long zoneId); - - - /** - * @return - */ - String getDefaultNetworkDomain(); - - - /** - * @param ntwkOffId - * @return - */ - List getNtwkOffDistinctProviders(long ntwkOffId); - - /** * @param requested * @param network @@ -380,15 +222,6 @@ public interface NetworkManager extends NetworkService { void removeNic(VirtualMachineProfile vm, Nic nic); - /** - * @param accountId - * @param dcId - * @param sourceNat - * @return - */ - List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat); - - /** * @param ipAddrId * @param networkId @@ -398,15 +231,6 @@ public interface NetworkManager extends NetworkService { InsufficientAddressCapacityException, ConcurrentOperationException; - /** - * @param vm - * @param networkId - * @param broadcastUri TODO - * @return - */ - NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri); - - /** * @param network * @param provider @@ -425,21 +249,6 @@ public interface NetworkManager extends NetworkService { throws ConcurrentOperationException, ResourceUnavailableException; - /** - * @param zoneId - * @param trafficType - * @return - */ - List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType); - - - /** - * @param guestNic - * @return - */ - boolean isPrivateGateway(Nic guestNic); - - /** * @param network * @param requested @@ -478,12 +287,38 @@ public interface NetworkManager extends NetworkService { */ PublicIp assignDedicateIpAddress(Account owner, Long guestNtwkId, Long vpcId, long dcId, boolean isSourceNat) throws ConcurrentOperationException, InsufficientAddressCapacityException; + NetworkProfile convertNetworkToNetworkProfile(long networkId); /** * @return */ int getNetworkLockTimeout(); + + boolean cleanupIpResources(long addrId, long userId, Account caller); + + + boolean restartNetwork(Long networkId, Account callerAccount, + User callerUser, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException; + + + boolean shutdownNetworkElementsAndResources(ReservationContext context, + boolean b, NetworkVO network); + + + void implementNetworkElementsAndResources(DeployDestination dest, + ReservationContext context, NetworkVO network, + NetworkOfferingVO findById) throws ConcurrentOperationException, InsufficientAddressCapacityException, ResourceUnavailableException, InsufficientCapacityException; + + + IpAddress allocateIp(Account ipOwner, boolean isSystem, Account caller, long callerId, + DataCenter zone) throws ConcurrentOperationException, ResourceAllocationException, InsufficientAddressCapacityException; + + + Map finalizeServicesAndProvidersForNetwork(NetworkOffering offering, + Long physicalNetworkId); + + List getProvidersForServiceInNetwork(Network network, Service service); StaticNatServiceProvider getStaticNatProviderForNetwork(Network network); diff --git a/server/src/com/cloud/network/NetworkManagerImpl.java b/server/src/com/cloud/network/NetworkManagerImpl.java index fbb019a56f6..bb60dcfcdc8 100755 --- a/server/src/com/cloud/network/NetworkManagerImpl.java +++ b/server/src/com/cloud/network/NetworkManagerImpl.java @@ -16,9 +16,39 @@ // under the License. package com.cloud.network; +import java.net.URI; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.Set; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.acl.ControlledEntity.ACLType; +import org.apache.cloudstack.acl.SecurityChecker.AccessType; +import org.apache.log4j.Logger; + import com.cloud.agent.AgentManager; import com.cloud.agent.Listener; -import com.cloud.agent.api.*; +import com.cloud.agent.api.AgentControlAnswer; +import com.cloud.agent.api.AgentControlCommand; +import com.cloud.agent.api.Answer; +import com.cloud.agent.api.CheckNetworkAnswer; +import com.cloud.agent.api.CheckNetworkCommand; +import com.cloud.agent.api.Command; +import com.cloud.agent.api.StartupCommand; +import com.cloud.agent.api.StartupRoutingCommand; import com.cloud.agent.api.to.NicTO; import com.cloud.alert.AlertManager; import com.cloud.api.ApiDBUtils; @@ -26,9 +56,15 @@ import com.cloud.configuration.Config; import com.cloud.configuration.ConfigurationManager; import com.cloud.configuration.Resource.ResourceType; import com.cloud.configuration.dao.ConfigurationDao; -import com.cloud.dc.*; +import com.cloud.dc.AccountVlanMapVO; +import com.cloud.dc.DataCenter; import com.cloud.dc.DataCenter.NetworkType; +import com.cloud.dc.DataCenterVO; +import com.cloud.dc.Pod; +import com.cloud.dc.PodVlanMapVO; +import com.cloud.dc.Vlan; import com.cloud.dc.Vlan.VlanType; +import com.cloud.dc.VlanVO; import com.cloud.dc.dao.AccountVlanMapDao; import com.cloud.dc.dao.DataCenterDao; import com.cloud.dc.dao.PodVlanMapDao; @@ -37,14 +73,21 @@ import com.cloud.deploy.DataCenterDeployment; import com.cloud.deploy.DeployDestination; import com.cloud.deploy.DeploymentPlan; import com.cloud.domain.Domain; -import com.cloud.domain.DomainVO; import com.cloud.domain.dao.DomainDao; -import com.cloud.event.ActionEvent; import com.cloud.event.EventTypes; import com.cloud.event.UsageEventVO; -import com.cloud.event.dao.EventDao; import com.cloud.event.dao.UsageEventDao; -import com.cloud.exception.*; +import com.cloud.exception.AccountLimitException; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.ConnectionException; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.InsufficientVirtualNetworkCapcityException; +import com.cloud.exception.InvalidParameterValueException; +import com.cloud.exception.PermissionDeniedException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.exception.UnsupportedServiceException; import com.cloud.host.Host; import com.cloud.host.HostVO; import com.cloud.host.Status; @@ -59,21 +102,38 @@ import com.cloud.network.Networks.AddressFormat; import com.cloud.network.Networks.BroadcastDomainType; import com.cloud.network.Networks.IsolationType; import com.cloud.network.Networks.TrafficType; -import com.cloud.network.PhysicalNetwork.BroadcastDomainRange; -import com.cloud.network.VirtualRouterProvider.VirtualRouterProviderType; import com.cloud.network.addr.PublicIp; -import com.cloud.network.dao.*; -import com.cloud.network.element.*; +import com.cloud.network.dao.FirewallRulesDao; +import com.cloud.network.dao.IPAddressDao; +import com.cloud.network.dao.LoadBalancerDao; +import com.cloud.network.dao.NetworkDao; +import com.cloud.network.dao.NetworkServiceMapDao; +import com.cloud.network.dao.PhysicalNetworkDao; +import com.cloud.network.dao.PhysicalNetworkServiceProviderDao; +import com.cloud.network.dao.PhysicalNetworkTrafficTypeDao; +import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO; +import com.cloud.network.element.DhcpServiceProvider; +import com.cloud.network.element.IpDeployer; +import com.cloud.network.element.LoadBalancingServiceProvider; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.StaticNatServiceProvider; +import com.cloud.network.element.UserDataServiceProvider; import com.cloud.network.guru.NetworkGuru; import com.cloud.network.lb.LoadBalancingRule; import com.cloud.network.lb.LoadBalancingRule.LbDestination; import com.cloud.network.lb.LoadBalancingRule.LbStickinessPolicy; import com.cloud.network.lb.LoadBalancingRulesManager; -import com.cloud.network.rules.*; +import com.cloud.network.rules.FirewallManager; +import com.cloud.network.rules.FirewallRule; import com.cloud.network.rules.FirewallRule.Purpose; +import com.cloud.network.rules.FirewallRuleVO; +import com.cloud.network.rules.PortForwardingRuleVO; +import com.cloud.network.rules.RulesManager; +import com.cloud.network.rules.StaticNat; +import com.cloud.network.rules.StaticNatRule; +import com.cloud.network.rules.StaticNatRuleImpl; import com.cloud.network.rules.dao.PortForwardingRulesDao; import com.cloud.network.vpc.NetworkACLManager; -import com.cloud.network.vpc.PrivateIpVO; import com.cloud.network.vpc.VpcManager; import com.cloud.network.vpc.dao.PrivateIpDao; import com.cloud.network.vpn.RemoteAccessVpnService; @@ -84,60 +144,49 @@ import com.cloud.offerings.NetworkOfferingVO; import com.cloud.offerings.dao.NetworkOfferingDao; import com.cloud.offerings.dao.NetworkOfferingServiceMapDao; import com.cloud.org.Grouping; -import com.cloud.projects.Project; -import com.cloud.projects.ProjectManager; -import com.cloud.server.ResourceTag.TaggedResourceType; -import com.cloud.tags.ResourceTagVO; -import com.cloud.tags.dao.ResourceTagDao; -import com.cloud.user.*; +import com.cloud.user.Account; +import com.cloud.user.AccountManager; +import com.cloud.user.ResourceLimitService; +import com.cloud.user.User; +import com.cloud.user.UserContext; import com.cloud.user.dao.AccountDao; -import com.cloud.user.dao.UserStatisticsDao; -import com.cloud.utils.AnnotationHelper; import com.cloud.utils.NumbersUtil; import com.cloud.utils.Pair; import com.cloud.utils.component.Adapters; import com.cloud.utils.component.Inject; import com.cloud.utils.component.Manager; import com.cloud.utils.concurrency.NamedThreadFactory; -import com.cloud.utils.db.*; +import com.cloud.utils.db.DB; +import com.cloud.utils.db.Filter; import com.cloud.utils.db.JoinBuilder.JoinType; +import com.cloud.utils.db.SearchBuilder; +import com.cloud.utils.db.SearchCriteria; import com.cloud.utils.db.SearchCriteria.Op; +import com.cloud.utils.db.Transaction; import com.cloud.utils.exception.CloudRuntimeException; import com.cloud.utils.net.Ip; import com.cloud.utils.net.NetUtils; -import com.cloud.vm.*; +import com.cloud.vm.Nic; +import com.cloud.vm.NicProfile; +import com.cloud.vm.NicVO; +import com.cloud.vm.ReservationContext; +import com.cloud.vm.ReservationContextImpl; +import com.cloud.vm.UserVmVO; +import com.cloud.vm.VMInstanceVO; +import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachine.Type; -import com.cloud.vm.dao.DomainRouterDao; +import com.cloud.vm.VirtualMachineProfile; +import com.cloud.vm.VirtualMachineProfileImpl; import com.cloud.vm.dao.NicDao; import com.cloud.vm.dao.UserVmDao; import com.cloud.vm.dao.VMInstanceDao; -import edu.emory.mathcs.backport.java.util.Collections; -import org.apache.cloudstack.acl.ControlledEntity.ACLType; -import org.apache.cloudstack.acl.SecurityChecker.AccessType; -import org.apache.cloudstack.api.command.admin.usage.ListTrafficTypeImplementorsCmd; -import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd; -import org.apache.cloudstack.api.command.user.network.ListNetworksCmd; -import org.apache.cloudstack.api.command.user.network.RestartNetworkCmd; -import org.apache.log4j.Logger; - -import javax.ejb.Local; -import javax.naming.ConfigurationException; -import java.net.URI; -import java.security.InvalidParameterException; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.*; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; /** * NetworkManagerImpl implements NetworkManager. */ -@Local(value = { NetworkManager.class, NetworkService.class }) -public class NetworkManagerImpl implements NetworkManager, NetworkService, Manager, Listener { - private static final Logger s_logger = Logger.getLogger(NetworkManagerImpl.class); +@Local(value = { NetworkManager.class}) +public class NetworkManagerImpl implements NetworkManager, Manager, Listener { + static final Logger s_logger = Logger.getLogger(NetworkManagerImpl.class); String _name; @Inject @@ -151,10 +200,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag @Inject DomainDao _domainDao = null; @Inject - UserStatisticsDao _userStatsDao = null; - @Inject - EventDao _eventDao = null; - @Inject ConfigurationDao _configDao; @Inject UserVmDao _userVmDao = null; @@ -186,8 +231,11 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag Adapters _networkGurus; @Inject(adapter = NetworkElement.class) Adapters _networkElements; - @Inject - NetworkDomainDao _networkDomainDao; + @Inject(adapter = IpDeployer.class) + Adapters _ipDeployers; + @Inject(adapter = DhcpServiceProvider.class) + Adapters _dhcpProviders; + @Inject VMInstanceDao _vmDao; @Inject @@ -195,15 +243,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag @Inject FirewallRulesDao _firewallDao; @Inject - PortForwardingRulesDao _portForwardingDao; - @Inject ResourceLimitService _resourceLimitMgr; - @Inject - DomainRouterDao _routerDao; - @Inject - DomainManager _domainMgr; - @Inject - ProjectManager _projectMgr; + @Inject NetworkOfferingServiceMapDao _ntwkOfferingSrvcDao; @Inject @@ -231,57 +272,22 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag @Inject NetworkACLManager _networkACLMgr; @Inject - ResourceTagDao _resourceTagDao; - - private final HashMap _systemNetworks = new HashMap(5); - private static Long _privateOfferingId = null; + NetworkModel _networkModel; ScheduledExecutorService _executor; - SearchBuilder AccountsUsingNetworkSearch; SearchBuilder AssignIpAddressSearch; SearchBuilder AssignIpAddressFromPodVlanSearch; - SearchBuilder IpAddressSearch; - SearchBuilder NicForTrafficTypeSearch; int _networkGcWait; int _networkGcInterval; String _networkDomain; - int _cidrLimit; - boolean _allowSubdomainNetworkAccess; int _networkLockTimeout; private Map _configs; HashMap _lastNetworkIdsToFree = new HashMap(); - private static HashMap> s_serviceToImplementedProvidersMap = new HashMap>(); - private static HashMap s_providerToNetworkElementMap = new HashMap(); - - @Override - public NetworkElement getElementImplementingProvider(String providerName) { - String elementName = s_providerToNetworkElementMap.get(providerName); - NetworkElement element = _networkElements.get(elementName); - return element; - } - - @Override - public List getElementServices(Provider provider) { - NetworkElement element = getElementImplementingProvider(provider.getName()); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'"); - } - return new ArrayList(element.getCapabilities().keySet()); - } - - @Override - public boolean canElementEnableIndividualServices(Provider provider) { - NetworkElement element = getElementImplementingProvider(provider.getName()); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'"); - } - return element.canEnableIndividualServices(); - } @Override public PublicIp assignPublicIpAddress(long dcId, Long podId, Account owner, VlanType type, Long networkId, String requestedIp, boolean isSystem) throws InsufficientAddressCapacityException { @@ -503,45 +509,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - /** - * Returns the target account for an api command - * - * @param accountName - * - non-null if the account name was passed in in the command - * @param domainId - * - non-null if the domainId was passed in in the command. - * @return - */ - protected Account getAccountForApiCommand(String accountName, Long domainId) { - Account account = UserContext.current().getCaller(); - - if (_accountMgr.isAdmin(account.getType())) { - // The admin is making the call, determine if it is for someone else or for himself - if (domainId != null) { - if ((account != null) && !_domainDao.isChildDomain(account.getDomainId(), domainId)) { - // TBD: Check if call to addProxyObject() needs correction. - PermissionDeniedException ex = new PermissionDeniedException("Invalid domain id given, permission denied"); - ex.addProxyObject("domain", domainId, "domainId"); - throw ex; - } - if (accountName != null) { - Account userAccount = _accountMgr.getActiveAccountByName(accountName, domainId); - if (userAccount != null) { - account = userAccount; - } else { - // TBD: Check if call to addProxyObject() needs correction. - PermissionDeniedException ex = new PermissionDeniedException("Unable to find account " + accountName + " in specified domain, permission denied"); - ex.addProxyObject("domain", domainId, "domainId"); - throw ex; - } - } - } else { - // the admin is calling the api on his own behalf - return account; - } - } - return account; - } + @Override public boolean applyIpAssociations(Network network, boolean continueOnError) throws ResourceUnavailableException { @@ -578,315 +546,31 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - private Map> getProviderServicesMap(long networkId) { - Map> map = new HashMap>(); - List nsms = _ntwkSrvcDao.getServicesInNetwork(networkId); - for (NetworkServiceMapVO nsm : nsms) { - Set services = map.get(Provider.getProvider(nsm.getProvider())); - if (services == null) { - services = new HashSet(); - } - services.add(Service.getService(nsm.getService())); - map.put(Provider.getProvider(nsm.getProvider()), services); - } - return map; - } + - private Map> getServiceProvidersMap(long networkId) { - Map> map = new HashMap>(); - List nsms = _ntwkSrvcDao.getServicesInNetwork(networkId); - for (NetworkServiceMapVO nsm : nsms) { - Set providers = map.get(Service.getService(nsm.getService())); - if (providers == null) { - providers = new HashSet(); - } - providers.add(Provider.getProvider(nsm.getProvider())); - map.put(Service.getService(nsm.getService()), providers); - } - return map; - } - - /* Get a list of IPs, classify them by service */ @Override - public Map> getIpToServices(List publicIps, boolean rulesRevoked, boolean includingFirewall) { - Map> ipToServices = new HashMap>(); - - if (publicIps != null && !publicIps.isEmpty()) { - Set networkSNAT = new HashSet(); - for (PublicIp ip : publicIps) { - Set services = ipToServices.get(ip); - if (services == null) { - services = new HashSet(); - } - if (ip.isSourceNat()) { - if (!networkSNAT.contains(ip.getAssociatedWithNetworkId())) { - services.add(Service.SourceNat); - networkSNAT.add(ip.getAssociatedWithNetworkId()); - } else { - CloudRuntimeException ex = new CloudRuntimeException("Multiple generic soure NAT IPs provided for network"); - // see the IPAddressVO.java class. - ex.addProxyObject("user_ip_address", ip.getAssociatedWithNetworkId(), "networkId"); - throw ex; - } - } - ipToServices.put(ip, services); - - // if IP in allocating state then it will not have any rules attached so skip IPAssoc to network service - // provider - if (ip.getState() == State.Allocating) { - continue; - } - - // check if any active rules are applied on the public IP - Set purposes = getPublicIpPurposeInRules(ip, false, includingFirewall); - // Firewall rules didn't cover static NAT - if (ip.isOneToOneNat() && ip.getAssociatedWithVmId() != null) { - if (purposes == null) { - purposes = new HashSet(); - } - purposes.add(Purpose.StaticNat); - } - if (purposes == null || purposes.isEmpty()) { - // since no active rules are there check if any rules are applied on the public IP but are in -// revoking state - - purposes = getPublicIpPurposeInRules(ip, true, includingFirewall); - if (ip.isOneToOneNat()) { - if (purposes == null) { - purposes = new HashSet(); - } - purposes.add(Purpose.StaticNat); - } - if (purposes == null || purposes.isEmpty()) { - // IP is not being used for any purpose so skip IPAssoc to network service provider - continue; - } else { - if (rulesRevoked) { - // no active rules/revoked rules are associated with this public IP, so remove the -// association with the provider - ip.setState(State.Releasing); - } else { - if (ip.getState() == State.Releasing) { - // rules are not revoked yet, so don't let the network service provider revoke the IP -// association - // mark IP is allocated so that IP association will not be removed from the provider - ip.setState(State.Allocated); - } - } - } - } - if (purposes.contains(Purpose.StaticNat)) { - services.add(Service.StaticNat); - } - if (purposes.contains(Purpose.LoadBalancing)) { - services.add(Service.Lb); - } - if (purposes.contains(Purpose.PortForwarding)) { - services.add(Service.PortForwarding); - } - if (purposes.contains(Purpose.Vpn)) { - services.add(Service.Vpn); - } - if (purposes.contains(Purpose.Firewall)) { - services.add(Service.Firewall); - } - if (services.isEmpty()) { - continue; - } - ipToServices.put(ip, services); - } - } - return ipToServices; - } - - public boolean canIpUsedForNonConserveService(PublicIp ip, Service service) { - // If it's non-conserve mode, then the new ip should not be used by any other services - List ipList = new ArrayList(); - ipList.add(ip); - Map> ipToServices = getIpToServices(ipList, false, false); - Set services = ipToServices.get(ip); - // Not used currently, safe - if (services == null || services.isEmpty()) { - return true; - } - // Since it's non-conserve mode, only one service should used for IP - if (services.size() != 1) { - throw new InvalidParameterException("There are multiple services used ip " + ip.getAddress() + "."); - } - if (service != null && !((Service) services.toArray()[0] == service || service.equals(Service.Firewall))) { - throw new InvalidParameterException("The IP " + ip.getAddress() + " is already used as " + ((Service) services.toArray()[0]).getName() + " rather than " + service.getName()); - } - return true; - } - - protected boolean canIpsUsedForNonConserve(List publicIps) { - boolean result = true; - for (PublicIp ip : publicIps) { - result = canIpUsedForNonConserveService(ip, null); - if (!result) { - break; - } - } - return result; - } - - public boolean canIpsUseOffering(List publicIps, long offeringId) { - Map> ipToServices = getIpToServices(publicIps, false, true); - Map> serviceToProviders = getNetworkOfferingServiceProvidersMap(offeringId); - NetworkOfferingVO offering = _networkOfferingDao.findById(offeringId); - //For inline mode checking, using firewall provider for LB instead, because public ip would apply on firewall provider - if (offering.isInline()) { - Provider firewallProvider = null; - if (serviceToProviders.containsKey(Service.Firewall)) { - firewallProvider = (Provider)serviceToProviders.get(Service.Firewall).toArray()[0]; - } - Set p = new HashSet(); - p.add(firewallProvider); - serviceToProviders.remove(Service.Lb); - serviceToProviders.put(Service.Lb, p); - } - for (PublicIp ip : ipToServices.keySet()) { - Set services = ipToServices.get(ip); - Provider provider = null; - for (Service service : services) { - Set curProviders = serviceToProviders.get(service); - if (curProviders == null || curProviders.isEmpty()) { - continue; - } - Provider curProvider = (Provider) curProviders.toArray()[0]; - if (provider == null) { - provider = curProvider; - continue; - } - // We don't support multiple providers for one service now - if (!provider.equals(curProvider)) { - throw new InvalidParameterException("There would be multiple providers for IP " + ip.getAddress() + " with the new network offering!"); - } - } - } - return true; - } - - public boolean canIpUsedForService(PublicIp publicIp, Service service, Long networkId) { - List ipList = new ArrayList(); - ipList.add(publicIp); - Map> ipToServices = getIpToServices(ipList, false, true); - Set services = ipToServices.get(publicIp); - if (services == null || services.isEmpty()) { - return true; - } - - if (networkId == null) { - networkId = publicIp.getAssociatedWithNetworkId(); - } - - // We only support one provider for one service now - Map> serviceToProviders = getServiceProvidersMap(networkId); - Set oldProviders = serviceToProviders.get(services.toArray()[0]); - Provider oldProvider = (Provider) oldProviders.toArray()[0]; - // Since IP already has service to bind with, the oldProvider can't be null - Set newProviders = serviceToProviders.get(service); - if (newProviders == null || newProviders.isEmpty()) { - throw new InvalidParameterException("There is no new provider for IP " + publicIp.getAddress() + " of service " + service.getName() + "!"); - } - Provider newProvider = (Provider) newProviders.toArray()[0]; - Network network = _networksDao.findById(networkId); - NetworkElement oldElement = getElementImplementingProvider(oldProvider.getName()); - NetworkElement newElement = getElementImplementingProvider(newProvider.getName()); - if (oldElement instanceof IpDeployingRequester && newElement instanceof IpDeployingRequester) { - IpDeployer oldIpDeployer = ((IpDeployingRequester)oldElement).getIpDeployer(network); - IpDeployer newIpDeployer = ((IpDeployingRequester)newElement).getIpDeployer(network); - if (!oldIpDeployer.getProvider().getName().equals(newIpDeployer.getProvider().getName())) { - throw new InvalidParameterException("There would be multiple providers for IP " + publicIp.getAddress() + "!"); - } - } else { - throw new InvalidParameterException("Ip cannot be applied for new provider!"); - } - return true; - } - - /* Return a mapping between provider in the network and the IP they should applied */ - @Override - public Map> getProviderToIpList(Network network, Map> ipToServices) { - NetworkOffering offering = _networkOfferingDao.findById(network.getNetworkOfferingId()); - if (!offering.isConserveMode()) { - for (PublicIp ip : ipToServices.keySet()) { - Set services = new HashSet() ; - services.addAll(ipToServices.get(ip)); - if (services != null && services.contains(Service.Firewall)) { - services.remove(Service.Firewall); - } - if (services != null && services.size() > 1) { - throw new CloudRuntimeException("Ip " + ip.getAddress() + " is used by multiple services!"); - } - } - } - Map> serviceToIps = new HashMap>(); - for (PublicIp ip : ipToServices.keySet()) { - for (Service service : ipToServices.get(ip)) { - Set ips = serviceToIps.get(service); - if (ips == null) { - ips = new HashSet(); - } - ips.add(ip); - serviceToIps.put(service, ips); - } - } - // TODO Check different provider for same IP - Map> providerToServices = getProviderServicesMap(network.getId()); - Map> providerToIpList = new HashMap>(); - for (Provider provider : providerToServices.keySet()) { - Set services = providerToServices.get(provider); - ArrayList ipList = new ArrayList(); - Set ipSet = new HashSet(); - for (Service service : services) { - Set serviceIps = serviceToIps.get(service); - if (serviceIps == null || serviceIps.isEmpty()) { - continue; - } - ipSet.addAll(serviceIps); - } - Set sourceNatIps = serviceToIps.get(Service.SourceNat); - if (sourceNatIps != null && !sourceNatIps.isEmpty()) { - ipList.addAll(0, sourceNatIps); - ipSet.removeAll(sourceNatIps); - } - ipList.addAll(ipSet); - providerToIpList.put(provider, ipList); - } - return providerToIpList; - } - - protected boolean applyIpAssociations(Network network, boolean rulesRevoked, boolean continueOnError, - List publicIps) throws ResourceUnavailableException { + public boolean applyIpAssociations(Network network, boolean rulesRevoked, boolean continueOnError, + List publicIps) throws ResourceUnavailableException { boolean success = true; - Map> ipToServices = getIpToServices(publicIps, rulesRevoked, true); - Map> providerToIpList = getProviderToIpList(network, ipToServices); + Map> ipToServices = _networkModel.getIpToServices(publicIps, rulesRevoked, true); + Map> providerToIpList = _networkModel.getProviderToIpList(network, ipToServices); for (Provider provider : providerToIpList.keySet()) { try { - ArrayList ips = providerToIpList.get(provider); + ArrayList ips = providerToIpList.get(provider); if (ips == null || ips.isEmpty()) { continue; } IpDeployer deployer = null; - NetworkElement element = getElementImplementingProvider(provider.getName()); - if (element instanceof ConnectivityProvider) { - // Nothing to do - s_logger.debug("ConnectivityProvider " + element.getClass().getSimpleName() + " has no ip associations"); - continue; - } - - if (!(element instanceof IpDeployingRequester)) { - throw new CloudRuntimeException("Element " + element + " is not a IpDeployingRequester!"); - } - deployer = ((IpDeployingRequester)element).getIpDeployer(network); - if (deployer == null) { + NetworkElement element = _networkModel.getElementImplementingProvider(provider.getName()); + if (element instanceof IpDeployer) { + deployer = (IpDeployer) element; + } else { throw new CloudRuntimeException("Fail to get ip deployer for element: " + element); } Set services = new HashSet(); - for (PublicIp ip : ips) { + for (PublicIpAddress ip : ips) { if (!ipToServices.containsKey(ip)) { continue; } @@ -906,43 +590,17 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - Set getPublicIpPurposeInRules(PublicIp ip, boolean includeRevoked, boolean includingFirewall) { - Set result = new HashSet(); - List rules = null; - if (includeRevoked) { - rules = _firewallDao.listByIp(ip.getId()); - } else { - rules = _firewallDao.listByIpAndNotRevoked(ip.getId()); - } - if (rules == null || rules.isEmpty()) { - return null; - } - - for (FirewallRuleVO rule : rules) { - if (rule.getPurpose() != Purpose.Firewall || includingFirewall) { - result.add(rule.getPurpose()); - } - } - - return result; - } - - @Override - public List getIsolatedNetworksOwnedByAccountInZone(long zoneId, Account owner) { - - return _networksDao.listByZoneAndGuestType(owner.getId(), zoneId, Network.GuestType.Isolated, false); - } - - @Override - public List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { + + + protected List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { return _networksDao.listSourceNATEnabledNetworks(owner.getId(), zoneId, Network.GuestType.Isolated); } - @Override - @ActionEvent(eventType = EventTypes.EVENT_NET_IP_ASSIGN, eventDescription = "allocating Ip", create = true) - public IpAddress allocateIP(Account ipOwner, boolean isSystem, long zoneId) + + + private IpAddress allocateIP(Account ipOwner, boolean isSystem, long zoneId) throws ResourceAllocationException, InsufficientAddressCapacityException, ConcurrentOperationException { Account caller = UserContext.current().getCaller(); long callerUserId = UserContext.current().getCallerUserId(); @@ -955,6 +613,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } @DB + @Override public IpAddress allocateIp(Account ipOwner, boolean isSystem, Account caller, long callerUserId, DataCenter zone) throws ConcurrentOperationException, ResourceAllocationException, InsufficientAddressCapacityException { @@ -1022,30 +681,29 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return ip; } - protected IPAddressVO getExistingSourceNatInNetwork(long ownerId, Long networkId) { - - List addrs = listPublicIpsAssignedToGuestNtwk(ownerId, networkId, true); - + + List addrs = _networkModel.listPublicIpsAssignedToGuestNtwk(ownerId, networkId, true); + IPAddressVO sourceNatIp = null; if (addrs.isEmpty()) { return null; } else { // Account already has ip addresses - for (IPAddressVO addr : addrs) { + for (IpAddress addr : addrs) { if (addr.isSourceNat()) { - sourceNatIp = addr; + sourceNatIp = _ipAddressDao.findById(addr.getId()); return sourceNatIp; } } - + assert (sourceNatIp != null) : "How do we get a bunch of ip addresses but none of them are source nat? " + "account=" + ownerId + "; networkId=" + networkId; } return sourceNatIp; } - + @DB @Override public IPAddressVO associateIPToGuestNetwork(long ipId, long networkId, boolean releaseOnFailure) @@ -1091,7 +749,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag // In Advance zone only allow to do IP assoc for Isolated networks with source nat service enabled if (zone.getNetworkType() == NetworkType.Advanced && - !(network.getGuestType() == GuestType.Isolated && areServicesSupportedInNetwork(network.getId(), + !(network.getGuestType() == GuestType.Isolated && _networkModel.areServicesSupportedInNetwork(network.getId(), Service.SourceNat))) { throw new InvalidParameterValueException("In zone of type " + NetworkType.Advanced + " ip address can be associated only to the network of guest type " + GuestType.Isolated + " with the " @@ -1203,26 +861,9 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag _configs = _configDao.getConfiguration("Network", params); _networkDomain = _configs.get(Config.GuestDomainSuffix.key()); - _cidrLimit = NumbersUtil.parseInt(_configs.get(Config.NetworkGuestCidrLimit.key()), 22); _networkLockTimeout = NumbersUtil.parseInt(_configs.get(Config.NetworkLockTimeout.key()), 600); - NetworkOfferingVO publicNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemPublicNetwork, TrafficType.Public, true); - publicNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(publicNetworkOffering); - _systemNetworks.put(NetworkOfferingVO.SystemPublicNetwork, publicNetworkOffering); - NetworkOfferingVO managementNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemManagementNetwork, TrafficType.Management, false); - managementNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(managementNetworkOffering); - _systemNetworks.put(NetworkOfferingVO.SystemManagementNetwork, managementNetworkOffering); - NetworkOfferingVO controlNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemControlNetwork, TrafficType.Control, false); - controlNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(controlNetworkOffering); - _systemNetworks.put(NetworkOfferingVO.SystemControlNetwork, controlNetworkOffering); - NetworkOfferingVO storageNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemStorageNetwork, TrafficType.Storage, true); - storageNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(storageNetworkOffering); - _systemNetworks.put(NetworkOfferingVO.SystemStorageNetwork, storageNetworkOffering); - NetworkOfferingVO privateGatewayNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemPrivateGatewayNetworkOffering, - GuestType.Isolated); - privateGatewayNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(privateGatewayNetworkOffering); - _systemNetworks.put(NetworkOfferingVO.SystemPrivateGatewayNetworkOffering, privateGatewayNetworkOffering); - _privateOfferingId = privateGatewayNetworkOffering.getId(); + // populate providers @@ -1378,13 +1019,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag txn.commit(); - AccountsUsingNetworkSearch = _accountDao.createSearchBuilder(); - SearchBuilder networkAccountSearch = _networksDao.createSearchBuilderForAccount(); - AccountsUsingNetworkSearch.join("nc", networkAccountSearch, AccountsUsingNetworkSearch.entity().getId(), networkAccountSearch.entity().getAccountId(), JoinType.INNER); - networkAccountSearch.and("config", networkAccountSearch.entity().getNetworkId(), SearchCriteria.Op.EQ); - networkAccountSearch.and("owner", networkAccountSearch.entity().isOwner(), SearchCriteria.Op.EQ); - AccountsUsingNetworkSearch.done(); - + AssignIpAddressSearch = _ipAddressDao.createSearchBuilder(); AssignIpAddressSearch.and("dc", AssignIpAddressSearch.entity().getDataCenterId(), Op.EQ); AssignIpAddressSearch.and("allocated", AssignIpAddressSearch.entity().getAllocatedTime(), Op.NULL); @@ -1407,27 +1042,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag AssignIpAddressFromPodVlanSearch.join("vlan", podVlanSearch, podVlanSearch.entity().getId(), AssignIpAddressFromPodVlanSearch.entity().getVlanId(), JoinType.INNER); AssignIpAddressFromPodVlanSearch.done(); - IpAddressSearch = _ipAddressDao.createSearchBuilder(); - IpAddressSearch.and("accountId", IpAddressSearch.entity().getAllocatedToAccountId(), Op.EQ); - IpAddressSearch.and("dataCenterId", IpAddressSearch.entity().getDataCenterId(), Op.EQ); - IpAddressSearch.and("vpcId", IpAddressSearch.entity().getVpcId(), Op.EQ); - IpAddressSearch.and("associatedWithNetworkId", IpAddressSearch.entity().getAssociatedWithNetworkId(), Op.EQ); - SearchBuilder virtualNetworkVlanSB = _vlanDao.createSearchBuilder(); - virtualNetworkVlanSB.and("vlanType", virtualNetworkVlanSB.entity().getVlanType(), Op.EQ); - IpAddressSearch.join("virtualNetworkVlanSB", virtualNetworkVlanSB, IpAddressSearch.entity().getVlanId(), virtualNetworkVlanSB.entity().getId(), JoinBuilder.JoinType.INNER); - IpAddressSearch.done(); - - NicForTrafficTypeSearch = _nicDao.createSearchBuilder(); - SearchBuilder networkSearch = _networksDao.createSearchBuilder(); - NicForTrafficTypeSearch.join("network", networkSearch, networkSearch.entity().getId(), NicForTrafficTypeSearch.entity().getNetworkId(), JoinType.INNER); - NicForTrafficTypeSearch.and("instance", NicForTrafficTypeSearch.entity().getInstanceId(), Op.EQ); - networkSearch.and("traffictype", networkSearch.entity().getTrafficType(), Op.EQ); - NicForTrafficTypeSearch.done(); - _executor = Executors.newScheduledThreadPool(1, new NamedThreadFactory("Network-Scavenger")); - _allowSubdomainNetworkAccess = Boolean.valueOf(_configs.get(Config.SubDomainNetworkAccess.key())); - _agentMgr.registerForHostEvents(this, true, false, true); s_logger.info("Network Manager is configured."); @@ -1443,33 +1059,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag @Override public boolean start() { - // populate s_serviceToImplementedProvidersMap & s_providerToNetworkElementMap with current _networkElements - // Need to do this in start() since _networkElements are not completely configured until then. - for (NetworkElement element : _networkElements) { - Map> capabilities = element.getCapabilities(); - Provider implementedProvider = element.getProvider(); - if (implementedProvider != null) { - if (s_providerToNetworkElementMap.containsKey(implementedProvider.getName())) { - s_logger.error("Cannot start NetworkManager: Provider <-> NetworkElement must be a one-to-one map, " + - "multiple NetworkElements found for Provider: " + implementedProvider.getName()); - return false; - } - s_providerToNetworkElementMap.put(implementedProvider.getName(), element.getName()); - } - if (capabilities != null && implementedProvider != null) { - for (Service service : capabilities.keySet()) { - if (s_serviceToImplementedProvidersMap.containsKey(service)) { - List providers = s_serviceToImplementedProvidersMap.get(service); - providers.add(implementedProvider); - } else { - List providers = new ArrayList(); - providers.add(implementedProvider); - s_serviceToImplementedProvidersMap.put(service, providers); - } - } - } - } - _executor.scheduleWithFixedDelay(new NetworkGarbageCollector(), _networkGcInterval, _networkGcInterval, TimeUnit.SECONDS); return true; } @@ -1483,36 +1072,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } @Override - public List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat) { - SearchCriteria sc = IpAddressSearch.create(); - sc.setParameters("accountId", accountId); - sc.setParameters("associatedWithNetworkId", associatedNetworkId); - - if (sourceNat != null) { - sc.addAnd("sourceNat", SearchCriteria.Op.EQ, sourceNat); - } - sc.setJoinParameters("virtualNetworkVlanSB", "vlanType", VlanType.VirtualNetwork); - - return _ipAddressDao.search(sc, null); - } - - @Override - public List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat) { - SearchCriteria sc = IpAddressSearch.create(); - sc.setParameters("accountId", accountId); - sc.setParameters("dataCenterId", dcId); - - if (sourceNat != null) { - sc.addAnd("sourceNat", SearchCriteria.Op.EQ, sourceNat); - } - sc.setJoinParameters("virtualNetworkVlanSB", "vlanType", VlanType.VirtualNetwork); - - return _ipAddressDao.search(sc, null); - } - - - @Override - public List setupNetwork(Account owner, NetworkOfferingVO offering, DeploymentPlan plan, String name, + public List setupNetwork(Account owner, NetworkOffering offering, DeploymentPlan plan, String name, String displayText, boolean isDefault) throws ConcurrentOperationException { return setupNetwork(owner, offering, null, plan, name, displayText, false, null, null, null, null); @@ -1520,7 +1080,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag @Override @DB - public List setupNetwork(Account owner, NetworkOfferingVO offering, Network predefined, DeploymentPlan + public List setupNetwork(Account owner, NetworkOffering offering, Network predefined, DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, ACLType aclType, Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException { @@ -1621,18 +1181,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - @Override - public List getSystemAccountNetworkOfferings(String... offeringNames) { - List offerings = new ArrayList(offeringNames.length); - for (String offeringName : offeringNames) { - NetworkOfferingVO network = _systemNetworks.get(offeringName); - if (network == null) { - throw new CloudRuntimeException("Unable to find system network profile for " + offeringName); - } - offerings.add(network); - } - return offerings; - } + @Override @DB @@ -1741,10 +1290,10 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag deviceId = applyProfileToNic(vo, profile, deviceId); vo = _nicDao.persist(vo); - - Integer networkRate = getNetworkRate(network.getId(), vm.getId()); - NicProfile vmNic = new NicProfile(vo, network, vo.getBroadcastUri(), vo.getIsolationUri(), networkRate, - isSecurityGroupSupportedInNetwork(network), getNetworkTag(vm.getHypervisorType(), + + Integer networkRate = _networkModel.getNetworkRate(network.getId(), vm.getId()); + NicProfile vmNic = new NicProfile(vo, network, vo.getBroadcastUri(), vo.getIsolationUri(), networkRate, + _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vm.getHypervisorType(), network)); return new Pair(vmNic, Integer.valueOf(deviceId)); @@ -1832,7 +1381,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag to.setDns2(profile.getDns2()); } - Integer networkRate = getNetworkRate(config.getId(), null); + Integer networkRate = _networkModel.getNetworkRate(config.getId(), null); to.setNetworkRateMbps(networkRate); to.setUuid(config.getUuid()); @@ -1912,7 +1461,13 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - private void implementNetworkElementsAndResources(DeployDestination dest, ReservationContext context, + @Override + public boolean equals(Object o) { + return super.equals(o); //To change body of overridden methods use File | Settings | File Templates. + } + + @Override + public void implementNetworkElementsAndResources(DeployDestination dest, ReservationContext context, NetworkVO network, NetworkOfferingVO offering) throws ConcurrentOperationException, InsufficientAddressCapacityException, ResourceUnavailableException, InsufficientCapacityException { @@ -1923,8 +1478,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag boolean sharedSourceNat = offering.getSharedSourceNat(); DataCenter zone = _dcDao.findById(network.getDataCenterId()); if (network.getGuestType() == Network.GuestType.Isolated - && areServicesSupportedInNetwork(network.getId(), Service.SourceNat) - && !sharedSourceNat) { + && _networkModel.areServicesSupportedInNetwork(network.getId(), Service.SourceNat) + && !sharedSourceNat) { List ips = null; if (network.getVpcId() != null) { @@ -1947,7 +1502,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag List providersToImplement = getNetworkProviders(network.getId()); for (NetworkElement element : _networkElements) { if (providersToImplement.contains(element.getProvider())) { - if (!isProviderEnabledInPhysicalNetwork(getPhysicalNetworkId(network), element.getProvider().getName())) { + if (!_networkModel.isProviderEnabledInPhysicalNetwork(_networkModel.getPhysicalNetworkId(network), element.getProvider().getName())) { // The physicalNetworkId will not get translated into a uuid by the reponse serializer, // because the serializer would look up the NetworkVO class's table and retrieve the // network id instead of the physical network id. @@ -1985,14 +1540,14 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag ConcurrentOperationException, ResourceUnavailableException { element.prepare(network, profile, vmProfile, dest, context); if (vmProfile.getType() == Type.User && vmProfile.getHypervisorType() != HypervisorType.BareMetal && element.getProvider() != null) { - if (areServicesSupportedInNetwork(network.getId(), Service.Dhcp) && - isProviderSupportServiceInNetwork(network.getId(), Service.Dhcp, element.getProvider()) && + if (_networkModel.areServicesSupportedInNetwork(network.getId(), Service.Dhcp) && + _networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.Dhcp, element.getProvider()) && (element instanceof DhcpServiceProvider)) { DhcpServiceProvider sp = (DhcpServiceProvider) element; sp.addDhcpEntry(network, profile, vmProfile, dest, context); } - if (areServicesSupportedInNetwork(network.getId(), Service.UserData) && - isProviderSupportServiceInNetwork(network.getId(), Service.UserData, element.getProvider()) && + if (_networkModel.areServicesSupportedInNetwork(network.getId(), Service.UserData) && + _networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.UserData, element.getProvider()) && (element instanceof UserDataServiceProvider)) { UserDataServiceProvider sp = (UserDataServiceProvider) element; sp.addPasswordAndUserdata(network, profile, vmProfile, dest, context); @@ -2011,7 +1566,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag _networksDao.changeActiveNicsBy(networkId, count); } - if (nic.getVmType() == VirtualMachine.Type.User || (nic.getVmType() == VirtualMachine.Type.DomainRouter && getNetwork(networkId).getTrafficType() == TrafficType.Guest)) { + if (nic.getVmType() == VirtualMachine.Type.User || (nic.getVmType() == VirtualMachine.Type.DomainRouter && _networksDao.findById(networkId).getTrafficType() == TrafficType.Guest)) { _networksDao.setCheckForGc(networkId); } @@ -2051,8 +1606,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag dest, ReservationContext context, long nicId, NetworkVO network) throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { - - Integer networkRate = getNetworkRate(network.getId(), vmProfile.getId()); + + Integer networkRate = _networkModel.getNetworkRate(network.getId(), vmProfile.getId()); NetworkGuru guru = _networkGurus.get(network.getGuruName()); NicVO nic = _nicDao.findById(nicId); @@ -2070,7 +1625,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag profile = new NicProfile(nic, network, broadcastUri, isolationUri, - networkRate, isSecurityGroupSupportedInNetwork(network), getNetworkTag(vmProfile.getHypervisorType(), network)); + networkRate, _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vmProfile.getHypervisorType(), network)); guru.reserve(profile, network, vmProfile, dest, context); nic.setIp4Address(profile.getIp4Address()); nic.setAddressFormat(profile.getFormat()); @@ -2089,8 +1644,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag updateNic(nic, network.getId(), 1); } else { - profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), - networkRate, isSecurityGroupSupportedInNetwork(network), getNetworkTag(vmProfile.getHypervisorType(), network)); + profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), + networkRate, _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vmProfile.getHypervisorType(), network)); guru.updateNicProfile(profile, network); nic.setState(Nic.State.Reserved); updateNic(nic, network.getId(), 1); @@ -2103,7 +1658,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag prepareElement(element, network, profile, vmProfile, dest, context); } - profile.setSecurityGroupEnabled(isSecurityGroupSupportedInNetwork(network)); + profile.setSecurityGroupEnabled(_networkModel.isSecurityGroupSupportedInNetwork(network)); guru.updateNicProfile(profile, network); return profile; } @@ -2113,11 +1668,11 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag List nics = _nicDao.listByVmId(vm.getId()); for (NicVO nic : nics) { NetworkVO network = _networksDao.findById(nic.getNetworkId()); - Integer networkRate = getNetworkRate(network.getId(), vm.getId()); + Integer networkRate = _networkModel.getNetworkRate(network.getId(), vm.getId()); NetworkGuru guru = _networkGurus.get(network.getGuruName()); - NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), networkRate, - isSecurityGroupSupportedInNetwork(network), getNetworkTag(vm.getHypervisorType(), network)); + NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), networkRate, + _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vm.getHypervisorType(), network)); guru.updateNicProfile(profile, network); vm.addNic(profile); } @@ -2163,7 +1718,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag nic.setState(Nic.State.Releasing); _nicDao.update(nic.getId(), nic); NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), null, - isSecurityGroupSupportedInNetwork(network), getNetworkTag(vmProfile.getHypervisorType(), network)); + _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vmProfile.getHypervisorType(), network)); if (guru.release(profile, vmProfile, nic.getReservationId())) { applyProfileToNicForRelease(nic, profile); nic.setState(Nic.State.Allocated); @@ -2194,183 +1749,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - @Override - public List getNics(long vmId) { - return _nicDao.listByVmId(vmId); - } - - @Override - public List getNicProfiles(VirtualMachine vm) { - List nics = _nicDao.listByVmId(vm.getId()); - List profiles = new ArrayList(); - - if (nics != null) { - for (Nic nic : nics) { - NetworkVO network = _networksDao.findById(nic.getNetworkId()); - Integer networkRate = getNetworkRate(network.getId(), vm.getId()); - - NetworkGuru guru = _networkGurus.get(network.getGuruName()); - NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), - networkRate, isSecurityGroupSupportedInNetwork(network), getNetworkTag(vm.getHypervisorType(), network)); - guru.updateNicProfile(profile, network); - profiles.add(profile); - } - } - return profiles; - } - - @Override - public NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri) { - NicVO nic = null; - if (broadcastUri != null) { - nic = _nicDao.findByNetworkIdInstanceIdAndBroadcastUri(networkId, vm.getId(), broadcastUri); - } else { - nic = _nicDao.findByInstanceIdAndNetworkId(networkId, vm.getId()); - } - if (nic == null) { - return null; - } - NetworkVO network = _networksDao.findById(networkId); - Integer networkRate = getNetworkRate(network.getId(), vm.getId()); - - NetworkGuru guru = _networkGurus.get(network.getGuruName()); - NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), - networkRate, isSecurityGroupSupportedInNetwork(network), getNetworkTag(vm.getHypervisorType(), network)); - guru.updateNicProfile(profile, network); - - return profile; - } - - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_NET_IP_RELEASE, eventDescription = "disassociating Ip", async = true) - public boolean releaseIpAddress(long ipAddressId) throws InsufficientAddressCapacityException { - Long userId = UserContext.current().getCallerUserId(); - Account caller = UserContext.current().getCaller(); - - // 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."); - } - - // Check for account wide pool. It will have an entry for account_vlan_map. - if (_accountVlanMapDao.findAccountVlanMap(ipVO.getAllocatedToAccountId(), ipVO.getVlanId()) != null) { - //see IPaddressVO.java - InvalidParameterValueException ex = new InvalidParameterValueException("Sepcified IP address uuid belongs to" + - " Account wide IP pool and cannot be disassociated"); - ex.addProxyObject("user_ip_address", ipAddressId, "ipAddressId"); - throw ex; - } - - // don't allow releasing system ip address - if (ipVO.getSystem()) { - InvalidParameterValueException ex = new InvalidParameterValueException("Can't release system IP address with specified id"); - ex.addProxyObject(ipVO, ipVO.getId(), "systemIpAddrId"); - throw ex; - } - - boolean success = disassociatePublicIpAddress(ipAddressId, userId, caller); - - if (success) { - Long networkId = ipVO.getAssociatedWithNetworkId(); - if (networkId != null) { - Network guestNetwork = getNetwork(networkId); - NetworkOffering offering = _configMgr.getNetworkOffering(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; - } - - @Deprecated - // No one is using this method. - public AccountVO getNetworkOwner(long networkId) { - SearchCriteria sc = AccountsUsingNetworkSearch.create(); - sc.setJoinParameters("nc", "config", networkId); - sc.setJoinParameters("nc", "owner", true); - List accounts = _accountDao.search(sc, null); - return accounts.size() != 0 ? accounts.get(0) : null; - } - - @Deprecated - // No one is using this method. - public List getNetworksforOffering(long offeringId, long dataCenterId, long accountId) { - return _networksDao.getNetworksForOffering(offeringId, dataCenterId, accountId); - } - - @Override - public String getNextAvailableMacAddressInNetwork(long networkId) throws InsufficientAddressCapacityException { - String mac = _networksDao.getNextAvailableMacAddress(networkId); - if (mac == null) { - throw new InsufficientAddressCapacityException("Unable to create another mac address", Network.class, networkId); - } - return mac; - } - - @Override - @DB - public Network getNetwork(long id) { - return _networksDao.findById(id); - } - - @Override - @DB - public Network getNetwork(String uuid) { - return _networksDao.findByUuid(uuid); - } - - @Override - public List getRemoteAccessVpnElements() { - List elements = new ArrayList(); - for (NetworkElement element : _networkElements) { - if (element instanceof RemoteAccessVPNServiceProvider) { - RemoteAccessVPNServiceProvider e = (RemoteAccessVPNServiceProvider) element; - elements.add(e); - } - } - - return elements; - } - - @Override - public List getSite2SiteVpnElements() { - List elements = new ArrayList(); - for (NetworkElement element : _networkElements) { - if (element instanceof Site2SiteVpnServiceProvider) { - Site2SiteVpnServiceProvider e = (Site2SiteVpnServiceProvider) element; - elements.add(e); - } - } - - return elements; - } - @Override public void cleanupNics(VirtualMachineProfile vm) { if (s_logger.isDebugEnabled()) { @@ -2393,7 +1771,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag _nicDao.update(nic.getId(), nic); NetworkVO network = _networksDao.findById(nic.getNetworkId()); NicProfile profile = new NicProfile(nic, network, null, null, null, - isSecurityGroupSupportedInNetwork(network), getNetworkTag(vm.getHypervisorType(), network)); + _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vm.getHypervisorType(), network)); NetworkGuru guru = _networkGurus.get(network.getGuruName()); guru.deallocate(network, profile, vm); _nicDao.remove(nic.getId()); @@ -2408,273 +1786,11 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_NETWORK_CREATE, eventDescription = "creating network") - public Network createGuestNetwork(CreateNetworkCmd cmd) throws InsufficientCapacityException, ConcurrentOperationException, ResourceAllocationException { - Long networkOfferingId = cmd.getNetworkOfferingId(); - String gateway = cmd.getGateway(); - String startIP = cmd.getStartIp(); - String endIP = cmd.getEndIp(); - String netmask = cmd.getNetmask(); - String networkDomain = cmd.getNetworkDomain(); - String vlanId = cmd.getVlan(); - String name = cmd.getNetworkName(); - String displayText = cmd.getDisplayText(); - Account caller = UserContext.current().getCaller(); - Long physicalNetworkId = cmd.getPhysicalNetworkId(); - Long zoneId = cmd.getZoneId(); - String aclTypeStr = cmd.getAclType(); - Long domainId = cmd.getDomainId(); - boolean isDomainSpecific = false; - Boolean subdomainAccess = cmd.getSubdomainAccess(); - Long vpcId = cmd.getVpcId(); - - // Validate network offering - NetworkOfferingVO ntwkOff = _networkOfferingDao.findById(networkOfferingId); - if (ntwkOff == null || ntwkOff.isSystemOnly()) { - InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find network offering by specified id"); - if (ntwkOff != null) { - ex.addProxyObject(ntwkOff, networkOfferingId, "networkOfferingId"); - // Get the VO object's table name. - String tablename = AnnotationHelper.getTableName(ntwkOff); - if (tablename != null) { - ex.addProxyObject(tablename, networkOfferingId, "networkOfferingId"); - } else { - s_logger.info("\nCould not retrieve table name (annotation) from " + tablename + " VO proxy object\n"); - } - throw ex; - } - throw ex; - } - // validate physical network and zone - // Check if physical network exists - PhysicalNetwork pNtwk = null; - if (physicalNetworkId != null) { - pNtwk = _physicalNetworkDao.findById(physicalNetworkId); - if (pNtwk == null) { - throw new InvalidParameterValueException("Unable to find a physical network having the specified physical network id"); - } - } - - if (zoneId == null) { - zoneId = pNtwk.getDataCenterId(); - } - - DataCenter zone = _dcDao.findById(zoneId); - if (zone == null) { - throw new InvalidParameterValueException("Specified zone id was not found"); - } - - if (Grouping.AllocationState.Disabled == zone.getAllocationState() && !_accountMgr.isRootAdmin(caller.getType())) { - // See DataCenterVO.java - PermissionDeniedException ex = new PermissionDeniedException("Cannot perform this operation since specified Zone is currently disabled"); - ex.addProxyObject(zone, zoneId, "zoneId"); - throw ex; - } - - // Only domain and account ACL types are supported in Acton. - ACLType aclType = null; - if (aclTypeStr != null) { - if (aclTypeStr.equalsIgnoreCase(ACLType.Account.toString())) { - aclType = ACLType.Account; - } else if (aclTypeStr.equalsIgnoreCase(ACLType.Domain.toString())) { - aclType = ACLType.Domain; - } else { - throw new InvalidParameterValueException("Incorrect aclType specified. Check the API documentation for supported types"); - } - // In 3.0 all Shared networks should have aclType == Domain, all Isolated networks aclType==Account - if (ntwkOff.getGuestType() == GuestType.Isolated) { - if (aclType != ACLType.Account) { - throw new InvalidParameterValueException("AclType should be " + ACLType.Account + " for network of type " + Network.GuestType.Isolated); - } - } else if (ntwkOff.getGuestType() == GuestType.Shared) { - if (!(aclType == ACLType.Domain || aclType == ACLType.Account)) { - throw new InvalidParameterValueException("AclType should be " + ACLType.Domain + " or " + - ACLType.Account + " for network of type " + Network.GuestType.Shared); - } - } - } else { - if (ntwkOff.getGuestType() == GuestType.Isolated) { - aclType = ACLType.Account; - } else if (ntwkOff.getGuestType() == GuestType.Shared) { - aclType = ACLType.Domain; - } - } - - // Only Admin can create Shared networks - if (ntwkOff.getGuestType() == GuestType.Shared && !_accountMgr.isAdmin(caller.getType())) { - throw new InvalidParameterValueException("Only Admins can create network with guest type " + GuestType.Shared); - } - - // Check if the network is domain specific - if (aclType == ACLType.Domain) { - // only Admin can create domain with aclType=Domain - if (!_accountMgr.isAdmin(caller.getType())) { - throw new PermissionDeniedException("Only admin can create networks with aclType=Domain"); - } - - // only shared networks can be Domain specific - if (ntwkOff.getGuestType() != GuestType.Shared) { - throw new InvalidParameterValueException("Only " + GuestType.Shared + " networks can have aclType=" + ACLType.Domain); - } - - if (domainId != null) { - if (ntwkOff.getTrafficType() != TrafficType.Guest || ntwkOff.getGuestType() != Network.GuestType.Shared) { - throw new InvalidParameterValueException("Domain level networks are supported just for traffic type " - + TrafficType.Guest + " and guest type " + Network.GuestType.Shared); - } - - DomainVO domain = _domainDao.findById(domainId); - if (domain == null) { - throw new InvalidParameterValueException("Unable to find domain by specified id"); - } - _accountMgr.checkAccess(caller, domain); - } - isDomainSpecific = true; - - } else if (subdomainAccess != null) { - throw new InvalidParameterValueException("Parameter subDomainAccess can be specified only with aclType=Domain"); - } - Account owner = null; - if ((cmd.getAccountName() != null && domainId != null) || cmd.getProjectId() != null) { - owner = _accountMgr.finalizeOwner(caller, cmd.getAccountName(), domainId, cmd.getProjectId()); - } else { - owner = caller; - } - - UserContext.current().setAccountId(owner.getAccountId()); - - // VALIDATE IP INFO - // if end ip is not specified, default it to startIp - if (startIP != null) { - if (!NetUtils.isValidIp(startIP)) { - throw new InvalidParameterValueException("Invalid format for the startIp parameter"); - } - if (endIP == null) { - endIP = startIP; - } else if (!NetUtils.isValidIp(endIP)) { - throw new InvalidParameterValueException("Invalid format for the endIp parameter"); - } - } - - if (startIP != null && endIP != null) { - if (!(gateway != null && netmask != null)) { - throw new InvalidParameterValueException("gateway and netmask should be defined when startIP/endIP are passed in"); - } - } - - String cidr = null; - if (gateway != null && netmask != null) { - if (!NetUtils.isValidIp(gateway)) { - throw new InvalidParameterValueException("Invalid gateway"); - } - if (!NetUtils.isValidNetmask(netmask)) { - throw new InvalidParameterValueException("Invalid netmask"); - } - - cidr = NetUtils.ipAndNetMaskToCidr(gateway, netmask); - } - - // Regular user can create Guest Isolated Source Nat enabled network only - if (caller.getType() == Account.ACCOUNT_TYPE_NORMAL - && (ntwkOff.getTrafficType() != TrafficType.Guest || ntwkOff.getGuestType() != Network.GuestType.Isolated - && areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat))) { - throw new InvalidParameterValueException("Regular user can create a network only from the network" + - " offering having traffic type " + TrafficType.Guest + " and network type " - + Network.GuestType.Isolated + " with a service " + Service.SourceNat.getName() + " enabled"); - } - - // Don't allow to specify vlan if the caller is a regular user - if (caller.getType() == Account.ACCOUNT_TYPE_NORMAL && (ntwkOff.getSpecifyVlan() || vlanId != null)) { - throw new InvalidParameterValueException("Regular user is not allowed to specify vlanId"); - } - - // For non-root admins check cidr limit - if it's allowed by global config value - if (caller.getType() != Account.ACCOUNT_TYPE_ADMIN && cidr != null) { - - String[] cidrPair = cidr.split("\\/"); - int cidrSize = Integer.valueOf(cidrPair[1]); - - if (cidrSize < _cidrLimit) { - throw new InvalidParameterValueException("Cidr size can't be less than " + _cidrLimit); - } - } - - Collection ntwkProviders = finalizeServicesAndProvidersForNetwork(ntwkOff, physicalNetworkId).values(); - if (cidr != null && providersConfiguredForExternalNetworking(ntwkProviders)) { - throw new InvalidParameterValueException("Cannot specify CIDR when using network offering with external devices!"); - } - - // Vlan is created in 2 cases - works in Advance zone only: - // 1) GuestType is Shared - // 2) GuestType is Isolated, but SourceNat service is disabled - boolean createVlan = (startIP != null && endIP != null && zone.getNetworkType() == NetworkType.Advanced - && ((ntwkOff.getGuestType() == Network.GuestType.Shared) - || (ntwkOff.getGuestType() == GuestType.Isolated && - !areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat)))); - - // Can add vlan range only to the network which allows it - if (createVlan && !ntwkOff.getSpecifyIpRanges()) { - InvalidParameterValueException ex = new InvalidParameterValueException("Network offering with specified id doesn't support adding multiple ip ranges"); - ex.addProxyObject(ntwkOff, ntwkOff.getId(), "networkOfferingId"); - String tablename = AnnotationHelper.getTableName(ntwkOff); - if (tablename != null) { - ex.addProxyObject(tablename, ntwkOff.getId(), "networkOfferingId"); - } else { - s_logger.info("\nCould not retrieve table name (annotation) from " + tablename + " VO proxy object\n"); - } - throw ex; - } - - Transaction txn = Transaction.currentTxn(); - txn.start(); - - Long sharedDomainId = null; - if (isDomainSpecific) { - if (domainId != null) { - sharedDomainId = domainId; - } else { - sharedDomainId = _domainMgr.getDomain(Domain.ROOT_DOMAIN).getId(); - subdomainAccess = true; - } - } - - // default owner to system if network has aclType=Domain - if (aclType == ACLType.Domain) { - owner = _accountMgr.getAccount(Account.ACCOUNT_ID_SYSTEM); - } - - //Create guest network - Network network = null; - if (vpcId != null) { - if (!_configMgr.isOfferingForVpc(ntwkOff)){ - throw new InvalidParameterValueException("Network offering can't be used for VPC networks"); - } - network = _vpcMgr.createVpcGuestNetwork(networkOfferingId, name, displayText, gateway, cidr, vlanId, - networkDomain, owner, sharedDomainId, pNtwk, zoneId, aclType, subdomainAccess, vpcId, caller); - } else { - if (_configMgr.isOfferingForVpc(ntwkOff)){ - throw new InvalidParameterValueException("Network offering can be used for VPC networks only"); - } - network = createGuestNetwork(networkOfferingId, name, displayText, gateway, cidr, vlanId, - networkDomain, owner, sharedDomainId, pNtwk, zoneId, aclType, subdomainAccess, vpcId); - } - - if (caller.getType() == Account.ACCOUNT_TYPE_ADMIN && createVlan) { - // Create vlan ip range - _configMgr.createVlanAndPublicIpRange(pNtwk.getDataCenterId(), network.getId(), physicalNetworkId, - false, null, startIP, endIP, gateway, netmask, vlanId, null); - } - - txn.commit(); - - return network; - } + @Override @DB - public Network createGuestNetwork(long networkOfferingId, String name, String displayText, String gateway, + public Network createGuestNetwork(long networkOfferingId, String name, String displayText, String gateway, String cidr, String vlanId, String networkDomain, Account owner, Long domainId, PhysicalNetwork pNtwk, long zoneId, ACLType aclType, Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException, InsufficientCapacityException, ResourceAllocationException { @@ -2725,8 +1841,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } // if zone is basic, only Shared network offerings w/o source nat service are allowed - if (!(ntwkOff.getGuestType() == GuestType.Shared && - !areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat))) { + if (!(ntwkOff.getGuestType() == GuestType.Shared && + !_networkModel.areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat))) { throw new InvalidParameterValueException("For zone of type " + NetworkType.Basic + " only offerings of " + "guestType " + GuestType.Shared + " with disabled " + Service.SourceNat.getName() + " service are allowed"); @@ -2756,8 +1872,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag if (zone.isSecurityGroupEnabled()) { // Only Account specific Isolated network with sourceNat service disabled are allowed in security group // enabled zone - boolean allowCreation = (ntwkOff.getGuestType() == GuestType.Isolated - && !areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat)); + boolean allowCreation = (ntwkOff.getGuestType() == GuestType.Isolated + && !_networkModel.areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat)); if (!allowCreation) { throw new InvalidParameterValueException("Only Account specific Isolated network with sourceNat " + "service disabled are allowed in security group enabled zone"); @@ -2797,8 +1913,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } // If networkDomain is not specified, take it from the global configuration - if (areServicesSupportedByNetworkOffering(networkOfferingId, Service.Dns)) { - Map dnsCapabilities = getNetworkOfferingServiceCapabilities + if (_networkModel.areServicesSupportedByNetworkOffering(networkOfferingId, Service.Dns)) { + Map dnsCapabilities = _networkModel.getNetworkOfferingServiceCapabilities (_configMgr.getNetworkOffering(networkOfferingId), Service.Dns); String isUpdateDnsSupported = dnsCapabilities.get(Capability.AllowDnsSuffixModification); if (isUpdateDnsSupported == null || !Boolean.valueOf(isUpdateDnsSupported)) { @@ -2811,9 +1927,9 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag if (networkDomain == null) { // 1) Get networkDomain from the corresponding account/domain/zone if (aclType == ACLType.Domain) { - networkDomain = getDomainNetworkDomain(domainId, zoneId); + networkDomain = _networkModel.getDomainNetworkDomain(domainId, zoneId); } else if (aclType == ACLType.Account) { - networkDomain = getAccountNetworkDomain(owner.getId(), zoneId); + networkDomain = _networkModel.getAccountNetworkDomain(owner.getId(), zoneId); } // 2) If null, generate networkDomain using domain suffix from the global config variables @@ -2837,8 +1953,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag // limitation, remove after we introduce support for multiple ip ranges // with different Cidrs for the same Shared network boolean cidrRequired = zone.getNetworkType() == NetworkType.Advanced && ntwkOff.getTrafficType() == TrafficType.Guest - && (ntwkOff.getGuestType() == GuestType.Shared || (ntwkOff.getGuestType() == GuestType.Isolated - && !areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat))); + && (ntwkOff.getGuestType() == GuestType.Shared || (ntwkOff.getGuestType() == GuestType.Isolated + && !_networkModel.areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat))); if (cidr == null && cidrRequired) { throw new InvalidParameterValueException("StartIp/endIp/gateway/netmask are required when create network of" + " type " + Network.GuestType.Shared + " and network of type " + GuestType.Isolated + " with service " @@ -2913,439 +2029,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return network; } - @Override - public List searchForNetworks(ListNetworksCmd cmd) { - Long id = cmd.getId(); - String keyword = cmd.getKeyword(); - Long zoneId = cmd.getZoneId(); - Account caller = UserContext.current().getCaller(); - Long domainId = cmd.getDomainId(); - String accountName = cmd.getAccountName(); - String guestIpType = cmd.getGuestIpType(); - String trafficType = cmd.getTrafficType(); - Boolean isSystem = cmd.getIsSystem(); - String aclType = cmd.getAclType(); - Long projectId = cmd.getProjectId(); - List permittedAccounts = new ArrayList(); - String path = null; - Long physicalNetworkId = cmd.getPhysicalNetworkId(); - List supportedServicesStr = cmd.getSupportedServices(); - Boolean restartRequired = cmd.getRestartRequired(); - boolean listAll = cmd.listAll(); - boolean isRecursive = cmd.isRecursive(); - Boolean specifyIpRanges = cmd.getSpecifyIpRanges(); - Long vpcId = cmd.getVpcId(); - Boolean canUseForDeploy = cmd.canUseForDeploy(); - Map tags = cmd.getTags(); - Boolean forVpc = cmd.getForVpc(); - - // 1) default is system to false if not specified - // 2) reset parameter to false if it's specified by the regular user - if ((isSystem == null || caller.getType() == Account.ACCOUNT_TYPE_NORMAL) && id == null) { - isSystem = false; - } - - // Account/domainId parameters and isSystem are mutually exclusive - if (isSystem != null && isSystem && (accountName != null || domainId != null)) { - throw new InvalidParameterValueException("System network belongs to system, account and domainId parameters can't be specified"); - } - - if (domainId != null) { - DomainVO domain = _domainDao.findById(domainId); - if (domain == null) { - // see DomainVO.java - throw new InvalidParameterValueException("Specified domain id doesn't exist in the system"); - } - - _accountMgr.checkAccess(caller, domain); - if (accountName != null) { - Account owner = _accountMgr.getActiveAccountByName(accountName, domainId); - if (owner == null) { - // see DomainVO.java - throw new InvalidParameterValueException("Unable to find account " + accountName + " in specified domain"); - } - - _accountMgr.checkAccess(caller, null, true, owner); - permittedAccounts.add(owner.getId()); - } - } - - if (!_accountMgr.isAdmin(caller.getType()) || (!listAll && (projectId != null && projectId.longValue() != -1 && domainId == null))) { - permittedAccounts.add(caller.getId()); - domainId = caller.getDomainId(); - } - - // set project information - boolean skipProjectNetworks = true; - if (projectId != null) { - if (projectId.longValue() == -1) { - if (!_accountMgr.isAdmin(caller.getType())) { - permittedAccounts.addAll(_projectMgr.listPermittedProjectAccounts(caller.getId())); - } - } else { - permittedAccounts.clear(); - Project project = _projectMgr.getProject(projectId); - if (project == null) { - throw new InvalidParameterValueException("Unable to find project by specified id"); - } - if (!_projectMgr.canAccessProjectAccount(caller, project.getProjectAccountId())) { - // getProject() returns type ProjectVO. - InvalidParameterValueException ex = new InvalidParameterValueException("Account " + caller + " cannot access specified project id"); - ex.addProxyObject(project, projectId, "projectId"); - throw ex; - } - permittedAccounts.add(project.getProjectAccountId()); - } - skipProjectNetworks = false; - } - - if (domainId != null) { - path = _domainDao.findById(domainId).getPath(); - } else { - path = _domainDao.findById(caller.getDomainId()).getPath(); - } - - if (listAll && domainId == null) { - isRecursive = true; - } - - Filter searchFilter = new Filter(NetworkVO.class, "id", false, cmd.getStartIndex(), cmd.getPageSizeVal()); - SearchBuilder sb = _networksDao.createSearchBuilder(); - - if (forVpc != null) { - if (forVpc) { - sb.and("vpc", sb.entity().getVpcId(), Op.NNULL); - } else { - sb.and("vpc", sb.entity().getVpcId(), Op.NULL); - } - } - - // Don't display networks created of system network offerings - SearchBuilder networkOfferingSearch = _networkOfferingDao.createSearchBuilder(); - networkOfferingSearch.and("systemOnly", networkOfferingSearch.entity().isSystemOnly(), SearchCriteria.Op.EQ); - if (isSystem != null && isSystem) { - networkOfferingSearch.and("trafficType", networkOfferingSearch.entity().getTrafficType(), SearchCriteria.Op.EQ); - } - sb.join("networkOfferingSearch", networkOfferingSearch, sb.entity().getNetworkOfferingId(), networkOfferingSearch.entity().getId(), JoinBuilder.JoinType.INNER); - - SearchBuilder zoneSearch = _dcDao.createSearchBuilder(); - zoneSearch.and("networkType", zoneSearch.entity().getNetworkType(), SearchCriteria.Op.EQ); - sb.join("zoneSearch", zoneSearch, sb.entity().getDataCenterId(), zoneSearch.entity().getId(), JoinBuilder.JoinType.INNER); - sb.and("removed", sb.entity().getRemoved(), Op.NULL); - - if (tags != null && !tags.isEmpty()) { - SearchBuilder tagSearch = _resourceTagDao.createSearchBuilder(); - for (int count=0; count < tags.size(); count++) { - tagSearch.or().op("key" + String.valueOf(count), tagSearch.entity().getKey(), SearchCriteria.Op.EQ); - tagSearch.and("value" + String.valueOf(count), tagSearch.entity().getValue(), SearchCriteria.Op.EQ); - tagSearch.cp(); - } - tagSearch.and("resourceType", tagSearch.entity().getResourceType(), SearchCriteria.Op.EQ); - sb.groupBy(sb.entity().getId()); - sb.join("tagSearch", tagSearch, sb.entity().getId(), tagSearch.entity().getResourceId(), JoinBuilder.JoinType.INNER); - } - - if (permittedAccounts.isEmpty()) { - SearchBuilder domainSearch = _domainDao.createSearchBuilder(); - domainSearch.and("path", domainSearch.entity().getPath(), SearchCriteria.Op.LIKE); - sb.join("domainSearch", domainSearch, sb.entity().getDomainId(), domainSearch.entity().getId(), JoinBuilder.JoinType.INNER); - } - - - SearchBuilder accountSearch = _accountDao.createSearchBuilder(); - accountSearch.and("typeNEQ", accountSearch.entity().getType(), SearchCriteria.Op.NEQ); - accountSearch.and("typeEQ", accountSearch.entity().getType(), SearchCriteria.Op.EQ); - - - sb.join("accountSearch", accountSearch, sb.entity().getAccountId(), accountSearch.entity().getId(), JoinBuilder.JoinType.INNER); - - List networksToReturn = new ArrayList(); - - if (isSystem == null || !isSystem) { - if (!permittedAccounts.isEmpty()) { - //get account level networks - networksToReturn.addAll(listAccountSpecificNetworks( - buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, - physicalNetworkId, aclType, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, - permittedAccounts)); - //get domain level networks - if (domainId != null) { - networksToReturn - .addAll(listDomainLevelNetworks( - buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, - physicalNetworkId, aclType, true, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, - domainId, false)); - } - } else { - //add account specific networks - networksToReturn.addAll(listAccountSpecificNetworksByDomainPath( - buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, - physicalNetworkId, aclType, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, path, - isRecursive)); - //add domain specific networks of domain + parent domains - networksToReturn.addAll(listDomainSpecificNetworksByDomainPath( - buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, - physicalNetworkId, aclType, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, path, - isRecursive)); - //add networks of subdomains - if (domainId == null) { - networksToReturn - .addAll(listDomainLevelNetworks( - buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, - physicalNetworkId, aclType, true, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, - caller.getDomainId(), true)); - } - } - } else { - networksToReturn = _networksDao.search(buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, - guestIpType, trafficType, physicalNetworkId, null, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), - searchFilter); - } - - if (supportedServicesStr != null && !supportedServicesStr.isEmpty() && !networksToReturn.isEmpty()) { - List supportedNetworks = new ArrayList(); - Service[] suppportedServices = new Service[supportedServicesStr.size()]; - int i = 0; - for (String supportedServiceStr : supportedServicesStr) { - Service service = Service.getService(supportedServiceStr); - if (service == null) { - throw new InvalidParameterValueException("Invalid service specified " + supportedServiceStr); - } else { - suppportedServices[i] = service; - } - i++; - } - - for (NetworkVO network : networksToReturn) { - if (areServicesSupportedInNetwork(network.getId(), suppportedServices)) { - supportedNetworks.add(network); - } - } - - networksToReturn=supportedNetworks; - } - - if (canUseForDeploy != null) { - List networksForDeploy = new ArrayList(); - for (NetworkVO network : networksToReturn) { - if (canUseForDeploy(network) == canUseForDeploy) { - networksForDeploy.add(network); - } - } - - networksToReturn=networksForDeploy; - } - - return networksToReturn; - } - - @Override - public boolean canUseForDeploy(Network network) { - if (network.getTrafficType() != TrafficType.Guest) { - return false; - } - boolean hasFreeIps = true; - if (network.getGuestType() == GuestType.Shared) { - hasFreeIps = _ipAddressDao.countFreeIPsInNetwork(network.getId()) > 0; - } else { - hasFreeIps = (getAvailableIps(network, null)).size() > 0; - } - - return hasFreeIps; - } - - private SearchCriteria buildNetworkSearchCriteria(SearchBuilder sb, String keyword, Long id, - Boolean isSystem, Long zoneId, String guestIpType, String trafficType, Long physicalNetworkId, - String aclType, boolean skipProjectNetworks, Boolean restartRequired, Boolean specifyIpRanges, Long vpcId, Map tags) { - - SearchCriteria sc = sb.create(); - - if (isSystem != null) { - sc.setJoinParameters("networkOfferingSearch", "systemOnly", isSystem); - } - - if (keyword != null) { - SearchCriteria ssc = _networksDao.createSearchCriteria(); - ssc.addOr("name", SearchCriteria.Op.LIKE, "%" + keyword + "%"); - sc.addAnd("name", SearchCriteria.Op.SC, ssc); - } - - if (id != null) { - sc.addAnd("id", SearchCriteria.Op.EQ, id); - } - - if (zoneId != null) { - sc.addAnd("dataCenterId", SearchCriteria.Op.EQ, zoneId); - } - - if (guestIpType != null) { - sc.addAnd("guestType", SearchCriteria.Op.EQ, guestIpType); - } - - if (trafficType != null) { - sc.addAnd("trafficType", SearchCriteria.Op.EQ, trafficType); - } - - if (aclType != null) { - sc.addAnd("aclType", SearchCriteria.Op.EQ, aclType.toString()); - } - - if (physicalNetworkId != null) { - sc.addAnd("physicalNetworkId", SearchCriteria.Op.EQ, physicalNetworkId); - } - - if (skipProjectNetworks) { - sc.setJoinParameters("accountSearch", "typeNEQ", Account.ACCOUNT_TYPE_PROJECT); - } else { - sc.setJoinParameters("accountSearch", "typeEQ", Account.ACCOUNT_TYPE_PROJECT); - } - - if (restartRequired != null) { - sc.addAnd("restartRequired", SearchCriteria.Op.EQ, restartRequired); - } - - if (specifyIpRanges != null) { - sc.addAnd("specifyIpRanges", SearchCriteria.Op.EQ, specifyIpRanges); - } - - if (vpcId != null) { - sc.addAnd("vpcId", SearchCriteria.Op.EQ, vpcId); - } - - if (tags != null && !tags.isEmpty()) { - int count = 0; - sc.setJoinParameters("tagSearch", "resourceType", TaggedResourceType.Network.toString()); - for (String key : tags.keySet()) { - sc.setJoinParameters("tagSearch", "key" + String.valueOf(count), key); - sc.setJoinParameters("tagSearch", "value" + String.valueOf(count), tags.get(key)); - count++; - } - } - - return sc; - } - - private List listDomainLevelNetworks(SearchCriteria sc, Filter searchFilter, long domainId, boolean parentDomainsOnly) { - List networkIds = new ArrayList(); - Set allowedDomains = _domainMgr.getDomainParentIds(domainId); - List maps = _networkDomainDao.listDomainNetworkMapByDomain(allowedDomains.toArray()); - - for (NetworkDomainVO map : maps) { - if (map.getDomainId() == domainId && parentDomainsOnly) { - continue; - } - boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : getAllowSubdomainAccessGlobal(); - if (map.getDomainId() == domainId || subdomainAccess) { - networkIds.add(map.getNetworkId()); - } - } - - if (!networkIds.isEmpty()) { - SearchCriteria domainSC = _networksDao.createSearchCriteria(); - domainSC.addAnd("id", SearchCriteria.Op.IN, networkIds.toArray()); - domainSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Domain.toString()); - - sc.addAnd("id", SearchCriteria.Op.SC, domainSC); - return _networksDao.search(sc, searchFilter); - } else { - return new ArrayList(); - } - } - - private List listAccountSpecificNetworks(SearchCriteria sc, Filter searchFilter, List permittedAccounts) { - SearchCriteria accountSC = _networksDao.createSearchCriteria(); - if (!permittedAccounts.isEmpty()) { - accountSC.addAnd("accountId", SearchCriteria.Op.IN, permittedAccounts.toArray()); - } - - accountSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Account.toString()); - - sc.addAnd("id", SearchCriteria.Op.SC, accountSC); - return _networksDao.search(sc, searchFilter); - } - - private List listAccountSpecificNetworksByDomainPath(SearchCriteria sc, Filter searchFilter, String path, boolean isRecursive) { - SearchCriteria accountSC = _networksDao.createSearchCriteria(); - accountSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Account.toString()); - - if (path != null) { - if (isRecursive) { - sc.setJoinParameters("domainSearch", "path", path + "%"); - } else { - sc.setJoinParameters("domainSearch", "path", path); - } - } - - sc.addAnd("id", SearchCriteria.Op.SC, accountSC); - return _networksDao.search(sc, searchFilter); - } - - private List listDomainSpecificNetworksByDomainPath(SearchCriteria sc, Filter searchFilter, - String path, boolean isRecursive) { - - Set allowedDomains = new HashSet(); - if (path != null) { - if (isRecursive) { - allowedDomains = _domainMgr.getDomainChildrenIds(path); - } else { - Domain domain = _domainDao.findDomainByPath(path); - allowedDomains.add(domain.getId()); - } - } - - List networkIds = new ArrayList(); - - List maps = _networkDomainDao.listDomainNetworkMapByDomain(allowedDomains.toArray()); - - for (NetworkDomainVO map : maps) { - networkIds.add(map.getNetworkId()); - } - - if (!networkIds.isEmpty()) { - SearchCriteria domainSC = _networksDao.createSearchCriteria(); - domainSC.addAnd("id", SearchCriteria.Op.IN, networkIds.toArray()); - domainSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Domain.toString()); - - sc.addAnd("id", SearchCriteria.Op.SC, domainSC); - return _networksDao.search(sc, searchFilter); - } else { - return new ArrayList(); - } - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_NETWORK_DELETE, eventDescription = "deleting network", async = true) - public boolean deleteNetwork(long networkId) { - - Account caller = UserContext.current().getCaller(); - - // Verify network id - NetworkVO network = _networksDao.findById(networkId); - if (network == null) { - // see NetworkVO.java - - InvalidParameterValueException ex = new InvalidParameterValueException("unable to find network with specified id"); - ex.addProxyObject(network, networkId, "networkId"); - throw ex; - } - - // don't allow to delete system network - if (isNetworkSystem(network)) { - InvalidParameterValueException ex = new InvalidParameterValueException("Network with specified id is system and can't be removed"); - ex.addProxyObject(network, network.getId(), "networkId"); - throw ex; - } - - Account owner = _accountMgr.getAccount(network.getAccountId()); - - // Perform permission check - _accountMgr.checkAccess(caller, null, true, network); - - User callerUser = _accountMgr.getActiveUser(UserContext.current().getCallerUserId()); - ReservationContext context = new ReservationContextImpl(null, null, callerUser, owner); - - return destroyNetwork(networkId, context); - } + @Override @DB @@ -3393,7 +2077,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return result; } - private boolean shutdownNetworkElementsAndResources(ReservationContext context, boolean cleanupElements, NetworkVO network) { + @Override + public boolean shutdownNetworkElementsAndResources(ReservationContext context, boolean cleanupElements, NetworkVO network) { // 1) Cleanup all the rules for the network. If it fails, just log the failure and proceed with shutting down // the elements boolean cleanupResult = true; @@ -3415,9 +2100,9 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag for (NetworkElement element : _networkElements) { if (providersToShutdown.contains(element.getProvider())) { try { - if (!isProviderEnabledInPhysicalNetwork(getPhysicalNetworkId(network), element.getProvider().getName())) { + if (!_networkModel.isProviderEnabledInPhysicalNetwork(_networkModel.getPhysicalNetworkId(network), element.getProvider().getName())) { s_logger.warn("Unable to complete shutdown of the network elements due to element: " + element.getName() + " either doesn't exist or not enabled in the physical network " - + getPhysicalNetworkId(network)); + + _networkModel.getPhysicalNetworkId(network)); success = false; } if (s_logger.isDebugEnabled()) { @@ -3502,9 +2187,9 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag for (NetworkElement element : _networkElements) { if (providersToDestroy.contains(element.getProvider())) { try { - if (!isProviderEnabledInPhysicalNetwork(getPhysicalNetworkId(network), element.getProvider().getName())) { + if (!_networkModel.isProviderEnabledInPhysicalNetwork(_networkModel.getPhysicalNetworkId(network), element.getProvider().getName())) { s_logger.warn("Unable to complete destroy of the network elements due to element: " + element.getName() + " either doesn't exist or not enabled in the physical network " - + getPhysicalNetworkId(network)); + + _networkModel.getPhysicalNetworkId(network)); success = false; } @@ -3591,125 +2276,49 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } @Override - public boolean validateRule(FirewallRule rule) { - Network network = _networksDao.findById(rule.getNetworkId()); - Purpose purpose = rule.getPurpose(); - switch (purpose) { - case LoadBalancing: - LoadBalancingServiceProvider ne = getLoadBalancingProviderForNetwork(network); - if (!ne.validateLBRule(network, (LoadBalancingRule) rule)) { - return false; - } - break; - default: - s_logger.debug("Unable to validate network rules for purpose: " + purpose.toString()); - } - return true; - } + public boolean applyRules(List rules, FirewallRule.Purpose purpose, + NetworkRuleApplier applier, boolean continueOnError) throws ResourceUnavailableException { + if (rules == null || rules.size() == 0) { + s_logger.debug("There are no rules to forward to the network elements"); + return true; + } - protected boolean applyLbRules(Network network, List rules, LoadBalancingServiceProvider element) throws ResourceUnavailableException { - return element.applyLBRules(network, rules); + boolean success = true; + Network network = _networksDao.findById(rules.get(0).getNetworkId()); + + // get the list of public ip's owned by the network + List userIps = _ipAddressDao.listByAssociatedNetwork(network.getId(), null); + List publicIps = new ArrayList(); + if (userIps != null && !userIps.isEmpty()) { + for (IPAddressVO userIp : userIps) { + PublicIp publicIp = new PublicIp(userIp, _vlanDao.findById(userIp.getVlanId()), NetUtils.createSequenceBasedMacAddress(userIp.getMacAddress())); + publicIps.add(publicIp); + } + } + + // rules can not programmed unless IP is associated with network service provider, so run IP assoication for + // the network so as to ensure IP is associated before applying rules (in add state) + applyIpAssociations(network, false, continueOnError, publicIps); + + try { + applier.applyRules(network, purpose, rules); + } catch (ResourceUnavailableException e) { + if (!continueOnError) { + throw e; + } + s_logger.warn("Problems with applying " + purpose + " rules but pushing on", e); + success = false; + } + + // if all the rules configured on public IP are revoked then dis-associate IP with network service provider + applyIpAssociations(network, true, continueOnError, publicIps); + + return success; } + - @Override - /* The rules here is only the same kind of rule, e.g. all load balancing rules or all port forwarding rules */ - public boolean applyRules(List rules, boolean continueOnError) throws ResourceUnavailableException { - if (rules == null || rules.size() == 0) { - s_logger.debug("There are no rules to forward to the network elements"); - return true; - } - boolean success = true; - Network network = _networksDao.findById(rules.get(0).getNetworkId()); - Purpose purpose = rules.get(0).getPurpose(); - - // get the list of public ip's owned by the network - List userIps = _ipAddressDao.listByAssociatedNetwork(network.getId(), null); - List publicIps = new ArrayList(); - if (userIps != null && !userIps.isEmpty()) { - for (IPAddressVO userIp : userIps) { - PublicIp publicIp = new PublicIp(userIp, _vlanDao.findById(userIp.getVlanId()), NetUtils.createSequenceBasedMacAddress(userIp.getMacAddress())); - publicIps.add(publicIp); - } - } - - // rules can not programmed unless IP is associated with network service provider, so run IP assoication for - // the network so as to ensure IP is associated before applying rules (in add state) - applyIpAssociations(network, false, continueOnError, publicIps); - - Service service = null; - switch (purpose) { - case LoadBalancing: - service = Service.Lb; - break; - case PortForwarding: - service = Service.PortForwarding; - break; - case StaticNat: - case Firewall: - service = Service.Firewall; - break; - case NetworkACL: - service = Service.NetworkACL; - break; - default: - break; - } - - if (service != null) { - List providers = getProvidersForServiceInNetwork(network, service); - if (providers == null || providers.size() != 1) { - // FIXME: If there is a service not made available by network offering, then rule should not get created - // in first place. For now error out during the apply rules. - String msg = "Cannot find the " + service.getName() + " provider for network " + network.getId(); - s_logger.error(msg); - throw new CloudRuntimeException(msg); - } - NetworkElement ne = getElementImplementingProvider(providers.get(0).getName()); - try { - boolean handled; - switch (purpose) { - case LoadBalancing: - assert ne instanceof LoadBalancingServiceProvider; - handled = applyLbRules(network, (List)rules, (LoadBalancingServiceProvider) ne); - break; - case PortForwarding: - assert ne instanceof PortForwardingServiceProvider; - handled = ((PortForwardingServiceProvider) ne).applyPFRules(network, (List) rules); - break; - case StaticNat: - /* It's firewall rule for static nat, not static nat rule */ - /* Fall through */ - case Firewall: - assert ne instanceof FirewallServiceProvider; - handled = ((FirewallServiceProvider) ne).applyFWRules(network, rules); - break; - case NetworkACL: - assert ne instanceof NetworkACLServiceProvider; - handled = ((NetworkACLServiceProvider) ne).applyNetworkACLs(network, rules); - break; - default: - s_logger.debug("Unable to handle network rules for purpose: " + purpose.toString()); - handled = false; - } - s_logger.debug("Network Rules for network " + network.getId() + " were " + (handled ? "" : " not") + " handled by " + ne.getName()); - } catch (ResourceUnavailableException e) { - if (!continueOnError) { - throw e; - } - s_logger.warn("Problems with " + ne.getName() + " but pushing on", e); - success = false; - } - } else { - s_logger.debug("Unable to handle network rules for purpose: " + purpose.toString()); - success = false; - } - - // if all the rules configured on public IP are revoked then dis-associate IP with network service provider - applyIpAssociations(network, true, continueOnError, publicIps); - - return success; - } + public class NetworkGarbageCollector implements Runnable { @@ -3743,14 +2352,14 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag for (Long networkId : shutdownList) { // If network is removed, unset gc flag for it - if (getNetwork(networkId) == null) { + if (_networksDao.findById(networkId) == null) { s_logger.debug("Network id=" + networkId + " is removed, so clearing up corresponding gc check"); _networksDao.clearCheckForGc(networkId); } else { try { User caller = _accountMgr.getSystemUser(); - Account owner = _accountMgr.getAccount(getNetwork(networkId).getAccountId()); + Account owner = _accountMgr.getAccount(_networksDao.findById(networkId).getAccountId()); ReservationContext context = new ReservationContextImpl(null, null, caller, owner); @@ -3766,49 +2375,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - @Override - @ActionEvent(eventType = EventTypes.EVENT_NETWORK_RESTART, eventDescription = "restarting network", async = true) - public boolean restartNetwork(RestartNetworkCmd cmd, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { - // This method restarts all network elements belonging to the network and re-applies all the rules - Long networkId = cmd.getNetworkId(); - - User callerUser = _accountMgr.getActiveUser(UserContext.current().getCallerUserId()); - Account callerAccount = _accountMgr.getActiveAccountById(callerUser.getAccountId()); - - // Check if network exists - NetworkVO network = _networksDao.findById(networkId); - if (network == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Network with specified id doesn't exist"); - ex.addProxyObject("networks", networkId, "networkId"); - throw ex; - } - - // Don't allow to restart network if it's not in Implemented/Setup state - if (!(network.getState() == Network.State.Implemented || network.getState() == Network.State.Setup)) { - throw new InvalidParameterValueException("Network is not in the right state to be restarted. Correct states are: " + Network.State.Implemented + ", " + Network.State.Setup); - } - - if (network.getBroadcastDomainType() == BroadcastDomainType.Lswitch ) { - /** - * Unable to restart these networks now. - * TODO Restarting a SDN based network requires updating the nics and the configuration - * in the controller. This requires a non-trivial rewrite of the restart procedure. - */ - throw new InvalidParameterException("Unable to restart a running SDN network."); - } - - _accountMgr.checkAccess(callerAccount, null, true, network); - - boolean success = restartNetwork(networkId, callerAccount, callerUser, cleanup); - - if (success) { - s_logger.debug("Network id=" + networkId + " is restarted successfully."); - } else { - s_logger.warn("Network id=" + networkId + " failed to restart."); - } - - return success; - } + @Override public boolean startNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { @@ -3832,7 +2399,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } } - private boolean restartNetwork(long networkId, Account callerAccount, User callerUser, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { + @Override + public boolean restartNetwork(Long networkId, Account callerAccount, User callerUser, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { NetworkVO network = _networksDao.findById(networkId); @@ -3937,195 +2505,12 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - @Override - public int getActiveNicsInNetwork(long networkId) { + + protected int getActiveNicsInNetwork(long networkId) { return _networksDao.getActiveNicsIn(networkId); } - @Override - public Map> getNetworkCapabilities(long networkId) { - - Map> networkCapabilities = new HashMap>(); - - // list all services of this networkOffering - List servicesMap = _ntwkSrvcDao.getServicesInNetwork(networkId); - for (NetworkServiceMapVO instance : servicesMap) { - Service service = Service.getService(instance.getService()); - NetworkElement element = getElementImplementingProvider(instance.getProvider()); - if (element != null) { - Map> elementCapabilities = element.getCapabilities(); - ; - if (elementCapabilities != null) { - networkCapabilities.put(service, elementCapabilities.get(service)); - } - } - } - - return networkCapabilities; - } - - @Override - public Map getNetworkServiceCapabilities(long networkId, Service service) { - - if (!areServicesSupportedInNetwork(networkId, service)) { - // TBD: networkId to uuid. No VO object being passed. So we will need to call - // addProxyObject with hardcoded tablename. Or we should probably look up the correct dao proxy object. - throw new UnsupportedServiceException("Service " + service.getName() + " is not supported in the network id=" + networkId); - } - - Map serviceCapabilities = new HashMap(); - - // get the Provider for this Service for this offering - String provider = _ntwkSrvcDao.getProviderForServiceInNetwork(networkId, service); - - NetworkElement element = getElementImplementingProvider(provider); - if (element != null) { - Map> elementCapabilities = element.getCapabilities(); - ; - - if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { - throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider); - } - serviceCapabilities = elementCapabilities.get(service); - } - - return serviceCapabilities; - } - - @Override - public Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) { - - if (!areServicesSupportedByNetworkOffering(offering.getId(), service)) { - // TBD: We should be sending networkOfferingId and not the offering object itself. - throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the network offering " + offering); - } - - Map serviceCapabilities = new HashMap(); - - // get the Provider for this Service for this offering - List providers = _ntwkOfferingSrvcDao.listProvidersForServiceForNetworkOffering(offering.getId(), service); - if (providers.isEmpty()) { - // TBD: We should be sending networkOfferingId and not the offering object itself. - throw new InvalidParameterValueException("Service " + service.getName() + " is not supported by the network offering " + offering); - } - - // FIXME - in post 3.0 we are going to support multiple providers for the same service per network offering, so - // we have to calculate capabilities for all of them - String provider = providers.get(0); - - // FIXME we return the capabilities of the first provider of the service - what if we have multiple providers - // for same Service? - NetworkElement element = getElementImplementingProvider(provider); - if (element != null) { - Map> elementCapabilities = element.getCapabilities(); - ; - - if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { - // TBD: We should be sending providerId and not the offering object itself. - throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider); - } - serviceCapabilities = elementCapabilities.get(service); - } - - return serviceCapabilities; - } - - @Override - public NetworkVO getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - // find system public network offering - Long networkOfferingId = null; - List offerings = _networkOfferingDao.listSystemNetworkOfferings(); - for (NetworkOfferingVO offering : offerings) { - if (offering.getTrafficType() == trafficType) { - networkOfferingId = offering.getId(); - break; - } - } - - if (networkOfferingId == null) { - throw new InvalidParameterValueException("Unable to find system network offering with traffic type " + trafficType); - } - - List networks = _networksDao.listBy(Account.ACCOUNT_ID_SYSTEM, networkOfferingId, zoneId); - if (networks == null || networks.isEmpty()) { - // TBD: send uuid instead of zoneId. Hardcode tablename in call to addProxyObject(). - throw new InvalidParameterValueException("Unable to find network with traffic type " + trafficType + " in zone " + zoneId); - } - return networks.get(0); - } - - @Override - public NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId) { - List networks = _networksDao.listByZoneSecurityGroup(zoneId); - if (networks == null || networks.isEmpty()) { - return null; - } - - if (networks.size() > 1) { - s_logger.debug("There are multiple network with security group enabled? select one of them..."); - } - return networks.get(0); - } - - @Override - public PublicIpAddress getPublicIpAddress(long ipAddressId) { - IPAddressVO addr = _ipAddressDao.findById(ipAddressId); - if (addr == null) { - return null; - } - - return new PublicIp(addr, _vlanDao.findById(addr.getVlanId()), NetUtils.createSequenceBasedMacAddress(addr.getMacAddress())); - } - - @Override - public List listPodVlans(long podId) { - List vlans = _vlanDao.listVlansForPodByType(podId, VlanType.DirectAttached); - return vlans; - } - - @Override - public List listNetworksUsedByVm(long vmId, boolean isSystem) { - List networks = new ArrayList(); - - List nics = _nicDao.listByVmId(vmId); - if (nics != null) { - for (Nic nic : nics) { - NetworkVO network = _networksDao.findByIdIncludingRemoved(nic.getNetworkId()); - - if (isNetworkSystem(network) == isSystem) { - networks.add(network); - } - } - } - - return networks; - } - - @Override - public Nic getNicInNetwork(long vmId, long networkId) { - return _nicDao.findByInstanceIdAndNetworkId(networkId, vmId); - } - - @Override - public String getIpInNetwork(long vmId, long networkId) { - Nic guestNic = getNicInNetwork(vmId, networkId); - assert (guestNic != null && guestNic.getIp4Address() != null) : "Vm doesn't belong to network associated with " + - "ipAddress or ip4 address is null"; - return guestNic.getIp4Address(); - } - - @Override - public String getIpInNetworkIncludingRemoved(long vmId, long networkId) { - Nic guestNic = getNicInNetworkIncludingRemoved(vmId, networkId); - assert (guestNic != null && guestNic.getIp4Address() != null) : "Vm doesn't belong to network associated with " + - "ipAddress or ip4 address is null"; - return guestNic.getIp4Address(); - } - - private Nic getNicInNetworkIncludingRemoved(long vmId, long networkId) { - return _nicDao.findByInstanceIdAndNetworkIdIncludingRemoved(networkId, vmId); - } - + @Override @DB public boolean associateIpAddressListToAccount(long userId, long accountId, long zoneId, Long vlanId, Network guestNetwork) @@ -4161,8 +2546,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag Availability.Required + " to automatically create the network as part of createVlanIpRange"); } if (requiredOfferings.get(0).getState() == NetworkOffering.State.Enabled) { - - long physicalNetworkId = findPhysicalNetworkId(zoneId, requiredOfferings.get(0).getTags(), requiredOfferings.get(0).getTrafficType()); + + long physicalNetworkId = _networkModel.findPhysicalNetworkId(zoneId, requiredOfferings.get(0).getTags(), requiredOfferings.get(0).getTrafficType()); // Validate physical network PhysicalNetwork physicalNetwork = _physicalNetworkDao.findById(physicalNetworkId); if (physicalNetwork == null) { @@ -4219,20 +2604,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return true; } - @Override - public List getNicsForTraffic(long vmId, TrafficType type) { - SearchCriteria sc = NicForTrafficTypeSearch.create(); - sc.setParameters("instance", vmId); - sc.setJoinParameters("network", "traffictype", type); - - return _nicDao.search(sc, null); - } - - @Override - public IpAddress getIp(long ipAddressId) { - return _ipAddressDao.findById(ipAddressId); - } - @Override public NetworkProfile convertNetworkToNetworkProfile(long networkId) { NetworkVO network = _networksDao.findById(networkId); @@ -4243,41 +2614,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return profile; } - @Override - public Network getDefaultNetworkForVm(long vmId) { - Nic defaultNic = getDefaultNic(vmId); - if (defaultNic == null) { - return null; - } else { - return _networksDao.findById(defaultNic.getNetworkId()); - } - } - - @Override - public Nic getDefaultNic(long vmId) { - List nics = _nicDao.listByVmId(vmId); - Nic defaultNic = null; - if (nics != null) { - for (Nic nic : nics) { - if (nic.isDefaultNic()) { - defaultNic = nic; - break; - } - } - } else { - s_logger.debug("Unable to find default network for the vm; vm doesn't have any nics"); - return null; - } - - if (defaultNic == null) { - s_logger.debug("Unable to find default network for the vm; vm doesn't have default nic"); - } - - return defaultNic; - - } - - @Override public UserDataServiceProvider getPasswordResetProvider(Network network) { String passwordProvider = _ntwkSrvcDao.getProviderForServiceInNetwork(network.getId(), Service.UserData); @@ -4286,56 +2622,25 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag s_logger.debug("Network " + network + " doesn't support service " + Service.UserData.getName()); return null; } - - return (UserDataServiceProvider)getElementImplementingProvider(passwordProvider); + + return (UserDataServiceProvider)_networkModel.getElementImplementingProvider(passwordProvider); } - @Override - public UserDataServiceProvider getUserDataUpdateProvider(Network network) { - String userDataProvider = _ntwkSrvcDao.getProviderForServiceInNetwork(network.getId(), Service.UserData); - - if (userDataProvider == null) { - s_logger.debug("Network " + network + " doesn't support service " + Service.UserData.getName()); - return null; - } - - return (UserDataServiceProvider)getElementImplementingProvider(userDataProvider); - } - - @Override - public boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId) { - boolean netscalerInNetwork = isProviderForNetwork(Network.Provider.Netscaler, networkId); - boolean juniperInNetwork = isProviderForNetwork(Network.Provider.JuniperSRX, networkId); - boolean f5InNetwork = isProviderForNetwork(Network.Provider.F5BigIp, networkId); - - if (netscalerInNetwork || juniperInNetwork || f5InNetwork) { + protected boolean isSharedNetworkOfferingWithServices(long networkOfferingId) { + NetworkOfferingVO networkOffering = _networkOfferingDao.findById(networkOfferingId); + if ( (networkOffering.getGuestType() == Network.GuestType.Shared) && ( + _networkModel.areServicesSupportedByNetworkOffering(networkOfferingId, Service.SourceNat) || + _networkModel.areServicesSupportedByNetworkOffering(networkOfferingId, Service.StaticNat) || + _networkModel.areServicesSupportedByNetworkOffering(networkOfferingId, Service.Firewall) || + _networkModel.areServicesSupportedByNetworkOffering(networkOfferingId, Service.PortForwarding) || + _networkModel.areServicesSupportedByNetworkOffering(networkOfferingId, Service.Lb))) { return true; - } else { - return false; - } - } - - public boolean providersConfiguredForExternalNetworking(Collection providers) { - for(String providerStr : providers){ - Provider provider = Network.Provider.getProvider(providerStr); - if(provider.isExternal()){ - return true; - } } return false; } @Override - public boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) { - return (_ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(networkOfferingId, services)); - } - - @Override - public boolean areServicesSupportedInNetwork(long networkId, Service... services) { - return (_ntwkSrvcDao.areServicesSupportedInNetwork(networkId, services)); - } - - private boolean cleanupIpResources(long ipId, long userId, Account caller) { + public boolean cleanupIpResources(long ipId, long userId, Account caller) { boolean success = true; // Revoke all firewall rules for the ip @@ -4383,45 +2688,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - @Override - public String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId) { - - List virtualNetworks = _networksDao.listByZoneAndGuestType(accountId, dataCenterId, Network.GuestType.Isolated, false); - - if (virtualNetworks.isEmpty()) { - s_logger.trace("Unable to find default Virtual network account id=" + accountId); - return null; - } - - NetworkVO virtualNetwork = virtualNetworks.get(0); - - NicVO networkElementNic = _nicDao.findByNetworkIdAndType(virtualNetwork.getId(), Type.DomainRouter); - - if (networkElementNic != null) { - return networkElementNic.getIp4Address(); - } else { - s_logger.warn("Unable to set find network element for the network id=" + virtualNetwork.getId()); - return null; - } - } - - @Override - public List listNetworksForAccount(long accountId, long zoneId, Network.GuestType type) { - List accountNetworks = _networksDao.listNetworksByAccount(accountId, zoneId, type, false); - return accountNetworks; - } - - @Override - public List listAllNetworksInAllZonesByType(Network.GuestType type) { - List networks = new ArrayList(); - for (NetworkVO network: _networksDao.listAll()) { - if (!isNetworkSystem(network)) { - networks.add(network); - } - } - return networks; - } - @DB @Override public IPAddressVO markIpAsUnavailable(long addrId) { @@ -4462,313 +2728,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return ip; } - @Override - public boolean isNetworkAvailableInDomain(long networkId, long domainId) { - Long networkDomainId = null; - Network network = getNetwork(networkId); - if (network.getGuestType() != Network.GuestType.Shared) { - s_logger.trace("Network id=" + networkId + " is not shared"); - return false; - } - - NetworkDomainVO networkDomainMap = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId); - if (networkDomainMap == null) { - s_logger.trace("Network id=" + networkId + " is shared, but not domain specific"); - return true; - } else { - networkDomainId = networkDomainMap.getDomainId(); - } - - if (domainId == networkDomainId.longValue()) { - return true; - } - - if (networkDomainMap.subdomainAccess) { - Set parentDomains = _domainMgr.getDomainParentIds(domainId); - - if (parentDomains.contains(domainId)) { - return true; - } - } - - return false; - } - - @Override - public Long getDedicatedNetworkDomain(long networkId) { - NetworkDomainVO networkMaps = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId); - if (networkMaps != null) { - return networkMaps.getDomainId(); - } else { - return null; - } - } - - private boolean checkForNonStoppedVmInNetwork(long networkId) { - List vms = _userVmDao.listByNetworkIdAndStates(networkId, VirtualMachine.State.Starting, - VirtualMachine.State.Running, VirtualMachine.State.Migrating, VirtualMachine.State.Stopping); - return vms.isEmpty(); - } - - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_NETWORK_UPDATE, eventDescription = "updating network", async = true) - public Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, - User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr) { - boolean restartNetwork = false; - - // verify input parameters - NetworkVO network = _networksDao.findById(networkId); - if (network == null) { - // see NetworkVO.java - InvalidParameterValueException ex = new InvalidParameterValueException("Specified network id doesn't exist in the system"); - ex.addProxyObject("networks", networkId, "networkId"); - throw ex; - } - - // don't allow to update network in Destroy state - if (network.getState() == Network.State.Destroy) { - throw new InvalidParameterValueException("Don't allow to update network in state " + Network.State.Destroy); - } - - // Don't allow to update system network - NetworkOffering offering = _networkOfferingDao.findByIdIncludingRemoved(network.getNetworkOfferingId()); - if (offering.isSystemOnly()) { - throw new InvalidParameterValueException("Can't update system networks"); - } - - // allow to upgrade only Guest networks - if (network.getTrafficType() != Networks.TrafficType.Guest) { - throw new InvalidParameterValueException("Can't allow networks which traffic type is not " + TrafficType.Guest); - } - - _accountMgr.checkAccess(callerAccount, null, true, network); - - if (name != null) { - network.setName(name); - } - - if (displayText != null) { - network.setDisplayText(displayText); - } - - // network offering and domain suffix can be updated for Isolated networks only in 3.0 - if ((networkOfferingId != null || domainSuffix != null) && network.getGuestType() != GuestType.Isolated) { - throw new InvalidParameterValueException("NetworkOffering and domain suffix upgrade can be perfomed for Isolated networks only"); - } - - boolean networkOfferingChanged = false; - - long oldNetworkOfferingId = network.getNetworkOfferingId(); - if (networkOfferingId != null) { - - NetworkOfferingVO networkOffering = _networkOfferingDao.findById(networkOfferingId); - if (networkOffering == null || networkOffering.isSystemOnly()) { - InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find network offering with specified id"); - ex.addProxyObject(networkOffering, networkOfferingId, "networkOfferingId"); - throw ex; - } - - // network offering should be in Enabled state - if (networkOffering.getState() != NetworkOffering.State.Enabled) { - InvalidParameterValueException ex = new InvalidParameterValueException("Network offering with specified id is not in " + NetworkOffering.State.Enabled + " state, can't upgrade to it"); - ex.addProxyObject(networkOffering, networkOfferingId, "networkOfferingId"); - throw ex; - } - - - //can't update from vpc to non-vpc network offering - boolean forVpcNew = _configMgr.isOfferingForVpc(networkOffering); - boolean vorVpcOriginal = _configMgr.isOfferingForVpc(_configMgr.getNetworkOffering(oldNetworkOfferingId)); - if (forVpcNew != vorVpcOriginal) { - String errMsg = forVpcNew ? "a vpc offering " : "not a vpc offering"; - throw new InvalidParameterValueException("Can't update as the new offering is " + errMsg); - } - - if (networkOfferingId != oldNetworkOfferingId) { - NetworkOffering oldNtwkOff = _networkOfferingDao.findByIdIncludingRemoved(oldNetworkOfferingId); - Collection newProviders = finalizeServicesAndProvidersForNetwork(networkOffering, network.getPhysicalNetworkId()).values(); - Collection oldProviders = finalizeServicesAndProvidersForNetwork(oldNtwkOff, network.getPhysicalNetworkId()).values(); - - if (providersConfiguredForExternalNetworking(newProviders) != providersConfiguredForExternalNetworking(oldProviders) - && !changeCidr) { - throw new InvalidParameterValueException("Updating network failed since guest CIDR needs to be changed!"); - } - if (changeCidr) { - if (!checkForNonStoppedVmInNetwork(network.getId())) { - InvalidParameterValueException ex = new InvalidParameterValueException("All user vm of network of specified id should be stopped before changing CIDR!"); - ex.addProxyObject(network, networkId, "networkId"); - throw ex; - } - } - // check if the network is upgradable - if (!canUpgrade(network, oldNetworkOfferingId, networkOfferingId)) { - throw new InvalidParameterValueException("Can't upgrade from network offering " + oldNetworkOfferingId + " to " + networkOfferingId + "; check logs for more information"); - } - restartNetwork = true; - networkOfferingChanged = true; - } - } - Map newSvcProviders = new HashMap(); - if (networkOfferingChanged) { - newSvcProviders = finalizeServicesAndProvidersForNetwork(_configMgr.getNetworkOffering(networkOfferingId), network.getPhysicalNetworkId()); - } - - // don't allow to modify network domain if the service is not supported - if (domainSuffix != null) { - // validate network domain - if (!NetUtils.verifyDomainName(domainSuffix)) { - throw new InvalidParameterValueException( - "Invalid network domain. Total length shouldn't exceed 190 chars. Each domain label must be between 1 and 63 characters long, can contain ASCII letters 'a' through 'z', the digits '0' through '9', " - + "and the hyphen ('-'); can't start or end with \"-\""); - } - - long offeringId = oldNetworkOfferingId; - if (networkOfferingId != null) { - offeringId = networkOfferingId; - } - - Map dnsCapabilities = getNetworkOfferingServiceCapabilities(_configMgr.getNetworkOffering(offeringId), Service.Dns); - String isUpdateDnsSupported = dnsCapabilities.get(Capability.AllowDnsSuffixModification); - if (isUpdateDnsSupported == null || !Boolean.valueOf(isUpdateDnsSupported)) { - // TBD: use uuid instead of networkOfferingId. May need to hardcode tablename in call to addProxyObject(). - throw new InvalidParameterValueException("Domain name change is not supported by the network offering id=" + networkOfferingId); - } - - network.setNetworkDomain(domainSuffix); - // have to restart the network - restartNetwork = true; - } - - ReservationContext context = new ReservationContextImpl(null, null, callerUser, callerAccount); - // 1) Shutdown all the elements and cleanup all the rules. Don't allow to shutdown network in intermediate - // states - Shutdown and Implementing - boolean validStateToShutdown = (network.getState() == Network.State.Implemented || network.getState() == Network.State.Setup || network.getState() == Network.State.Allocated); - if (restartNetwork) { - if (validStateToShutdown) { - if (!changeCidr) { - s_logger.debug("Shutting down elements and resources for network id=" + networkId + " as a part of network update"); - - if (!shutdownNetworkElementsAndResources(context, true, network)) { - s_logger.warn("Failed to shutdown the network elements and resources as a part of network restart: " + network); - CloudRuntimeException ex = new CloudRuntimeException("Failed to shutdown the network elements and resources as a part of update to network of specified id"); - ex.addProxyObject(network, networkId, "networkId"); - throw ex; - } - } else { - // We need to shutdown the network, since we want to re-implement the network. - s_logger.debug("Shutting down network id=" + networkId + " as a part of network update"); - - if (!shutdownNetwork(network.getId(), context, true)) { - s_logger.warn("Failed to shutdown the network as a part of update to network with specified id"); - CloudRuntimeException ex = new CloudRuntimeException("Failed to shutdown the network as a part of update of specified network id"); - ex.addProxyObject(network, networkId, "networkId"); - throw ex; - } - } - } else { - CloudRuntimeException ex = new CloudRuntimeException("Failed to shutdown the network elements and resources as a part of update to network with specified id; network is in wrong state: " + network.getState()); - ex.addProxyObject(network, networkId, "networkId"); - throw ex; - } - } - - // 2) Only after all the elements and rules are shutdown properly, update the network VO - // get updated network - Network.State networkState = _networksDao.findById(networkId).getState(); - boolean validStateToImplement = (networkState == Network.State.Implemented || networkState == Network.State.Setup || networkState == Network.State.Allocated); - if (restartNetwork && !validStateToImplement) { - CloudRuntimeException ex = new CloudRuntimeException("Failed to implement the network elements and resources as a part of update to network with specified id; network is in wrong state: " + networkState); - ex.addProxyObject(network, networkId, "networkId"); - throw ex; - } - - if (networkOfferingId != null) { - if (networkOfferingChanged) { - Transaction txn = Transaction.currentTxn(); - txn.start(); - network.setNetworkOfferingId(networkOfferingId); - _networksDao.update(networkId, network, newSvcProviders); - // get all nics using this network - // log remove usage events for old offering - // log assign usage events for new offering - List nics = _nicDao.listByNetworkId(networkId); - for (NicVO nic : nics) { - if (nic.getReservationStrategy() == Nic.ReservationStrategy.PlaceHolder) { - continue; - } - long vmId = nic.getInstanceId(); - VMInstanceVO vm = _vmDao.findById(vmId); - if (vm == null) { - s_logger.error("Vm for nic " + nic.getId() + " not found with Vm Id:" + vmId); - continue; - } - long isDefault = (nic.isDefaultNic()) ? 1 : 0; - UsageEventVO usageEvent = new UsageEventVO(EventTypes.EVENT_NETWORK_OFFERING_REMOVE, vm.getAccountId(), vm.getDataCenterIdToDeployIn(), vm.getId(), null, oldNetworkOfferingId, null, 0L); - _usageEventDao.persist(usageEvent); - usageEvent = new UsageEventVO(EventTypes.EVENT_NETWORK_OFFERING_ASSIGN, vm.getAccountId(), vm.getDataCenterIdToDeployIn(), vm.getId(), vm.getHostName(), networkOfferingId, null, isDefault); - _usageEventDao.persist(usageEvent); - } - txn.commit(); - } else { - network.setNetworkOfferingId(networkOfferingId); - _networksDao.update(networkId, network, finalizeServicesAndProvidersForNetwork(_configMgr.getNetworkOffering(networkOfferingId), network.getPhysicalNetworkId())); - } - } else { - _networksDao.update(networkId, network); - } - - // 3) Implement the elements and rules again - if (restartNetwork) { - if (network.getState() != Network.State.Allocated) { - DeployDestination dest = new DeployDestination(_dcDao.findById(network.getDataCenterId()), null, null, null); - s_logger.debug("Implementing the network " + network + " elements and resources as a part of network update"); - try { - if (!changeCidr) { - implementNetworkElementsAndResources(dest, context, network, _networkOfferingDao.findById(network.getNetworkOfferingId())); - } else { - implementNetwork(network.getId(), dest, context); - } - } catch (Exception ex) { - s_logger.warn("Failed to implement network " + network + " elements and resources as a part of network update due to ", ex); - CloudRuntimeException e = new CloudRuntimeException("Failed to implement network (with specified id) elements and resources as a part of network update"); - e.addProxyObject(network, networkId, "networkId"); - throw e; - } - } - } - - return getNetwork(network.getId()); - } - - @Override - public Integer getNetworkRate(long networkId, Long vmId) { - VMInstanceVO vm = null; - if (vmId != null) { - vm = _vmDao.findById(vmId); - } - Network network = getNetwork(networkId); - NetworkOffering ntwkOff = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); - - // For default userVm Default network and domR guest/public network, get rate information from the service - // offering; for other situations get information - // from the network offering - boolean isUserVmsDefaultNetwork = false; - boolean isDomRGuestOrPublicNetwork = false; - if (vm != null) { - Nic nic = _nicDao.findByInstanceIdAndNetworkId(networkId, vmId); - if (vm.getType() == Type.User && nic != null && nic.isDefaultNic()) { - isUserVmsDefaultNetwork = true; - } else if (vm.getType() == Type.DomainRouter && ntwkOff != null && (ntwkOff.getTrafficType() == TrafficType.Public || ntwkOff.getTrafficType() == TrafficType.Guest)) { - isDomRGuestOrPublicNetwork = true; - } - } - if (isUserVmsDefaultNetwork || isDomRGuestOrPublicNetwork) { - return _configMgr.getServiceOfferingNetworkRate(vm.getServiceOfferingId()); - } else { - return _configMgr.getNetworkOfferingNetworkRate(ntwkOff.getId()); - } - } + Random _rand = new Random(System.currentTimeMillis()); @@ -4780,7 +2740,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return null; } - Set availableIps = getAvailableIps(network, requestedIp); + Set availableIps = _networkModel.getAvailableIps(network, requestedIp); if (availableIps.isEmpty()) { return null; @@ -4807,87 +2767,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return result; } - protected Set getAvailableIps(Network network, String requestedIp) { - String[] cidr = network.getCidr().split("/"); - List ips = _nicDao.listIpAddressInNetwork(network.getId()); - Set allPossibleIps = NetUtils.getAllIpsFromCidr(cidr[0], Integer.parseInt(cidr[1])); - Set usedIps = new TreeSet(); - - for (String ip : ips) { - if (requestedIp != null && requestedIp.equals(ip)) { - s_logger.warn("Requested ip address " + requestedIp + " is already in use in network" + network); - return null; - } - - usedIps.add(NetUtils.ip2Long(ip)); - } - if (usedIps.size() != 0) { - allPossibleIps.removeAll(usedIps); - } - return allPossibleIps; - } - - - private String getZoneNetworkDomain(long zoneId) { - return _dcDao.findById(zoneId).getDomain(); - } - - private String getDomainNetworkDomain(long domainId, long zoneId) { - String networkDomain = null; - Long searchDomainId = domainId; - while(searchDomainId != null){ - DomainVO domain = _domainDao.findById(searchDomainId); - if(domain.getNetworkDomain() != null){ - networkDomain = domain.getNetworkDomain(); - break; - } - searchDomainId = domain.getParent(); - } - if (networkDomain == null) { - return getZoneNetworkDomain(zoneId); - } - return networkDomain; - } - - @Override - public String getAccountNetworkDomain(long accountId, long zoneId) { - String networkDomain = _accountDao.findById(accountId).getNetworkDomain(); - - if (networkDomain == null) { - // get domain level network domain - return getDomainNetworkDomain(_accountDao.findById(accountId).getDomainId(), zoneId); - } - - return networkDomain; - } - - @Override - public String getGlobalGuestDomainSuffix() { - return _networkDomain; - } - - @Override - public String getStartIpAddress(long networkId) { - List vlans = _vlanDao.listVlansByNetworkId(networkId); - if (vlans.isEmpty()) { - return null; - } - - String startIP = vlans.get(0).getIpRange().split("-")[0]; - - for (VlanVO vlan : vlans) { - String startIP1 = vlan.getIpRange().split("-")[0]; - long startIPLong = NetUtils.ip2Long(startIP); - long startIPLong1 = NetUtils.ip2Long(startIP1); - - if (startIPLong1 < startIPLong) { - startIP = startIP1; - } - } - - return startIP; - } - + @Override public boolean applyStaticNats(List staticNats, boolean continueOnError) throws ResourceUnavailableException { Network network = _networksDao.findById(staticNats.get(0).getNetworkId()); @@ -4947,16 +2827,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - @Override - public Long getPodIdForVlan(long vlanDbId) { - PodVlanMapVO podVlanMaps = _podVlanMapDao.listPodVlanMapsByVlan(vlanDbId); - if (podVlanMaps == null) { - return null; - } else { - return podVlanMaps.getPodId(); - } - } - @DB @Override public boolean reallocate(VirtualMachineProfile vm, DataCenterDeployment dest) throws InsufficientCapacityException, ConcurrentOperationException { @@ -4982,943 +2852,9 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return true; } - @Override - public Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId) { - Map> serviceProviderMap = new HashMap>(); - List map = _ntwkOfferingSrvcDao.listByNetworkOfferingId(networkOfferingId); - - for (NetworkOfferingServiceMapVO instance : map) { - String service = instance.getService(); - Set providers; - providers = serviceProviderMap.get(service); - if (providers == null) { - providers = new HashSet(); - } - providers.add(Provider.getProvider(instance.getProvider())); - serviceProviderMap.put(Service.getService(service), providers); - } - - return serviceProviderMap; - } - - @Override - public boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider) { - return _ntwkSrvcDao.canProviderSupportServiceInNetwork(networkId, service, provider); - } - - protected boolean canUpgrade(Network network, long oldNetworkOfferingId, long newNetworkOfferingId) { - NetworkOffering oldNetworkOffering = _networkOfferingDao.findByIdIncludingRemoved(oldNetworkOfferingId); - NetworkOffering newNetworkOffering = _networkOfferingDao.findById(newNetworkOfferingId); - - // can upgrade only Isolated networks - if (oldNetworkOffering.getGuestType() != GuestType.Isolated) { - throw new InvalidParameterValueException("NetworkOfferingId can be upgraded only for the network of type " + GuestType.Isolated); - } - - // security group service should be the same - if (areServicesSupportedByNetworkOffering(oldNetworkOfferingId, Service.SecurityGroup) != areServicesSupportedByNetworkOffering(newNetworkOfferingId, Service.SecurityGroup)) { - s_logger.debug("Offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different securityGroupProperty, can't upgrade"); - return false; - } - - // Type of the network should be the same - if (oldNetworkOffering.getGuestType() != newNetworkOffering.getGuestType()) { - s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " are of different types, can't upgrade"); - return false; - } - - // tags should be the same - if (newNetworkOffering.getTags() != null) { - if (oldNetworkOffering.getTags() == null) { - s_logger.debug("New network offering id=" + newNetworkOfferingId + " has tags and old network offering id=" + oldNetworkOfferingId + " doesn't, can't upgrade"); - return false; - } - if (!oldNetworkOffering.getTags().equalsIgnoreCase(newNetworkOffering.getTags())) { - s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different tags, can't upgrade"); - return false; - } - } - - // Traffic types should be the same - if (oldNetworkOffering.getTrafficType() != newNetworkOffering.getTrafficType()) { - s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different traffic types, can't upgrade"); - return false; - } - - // specify vlan should be the same - if (oldNetworkOffering.getSpecifyVlan() != newNetworkOffering.getSpecifyVlan()) { - s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different values for specifyVlan, can't upgrade"); - return false; - } - - // specify ipRanges should be the same - if (oldNetworkOffering.getSpecifyIpRanges() != newNetworkOffering.getSpecifyIpRanges()) { - s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different values for specifyIpRangess, can't upgrade"); - return false; - } - - // Check all ips - List userIps = _ipAddressDao.listByAssociatedNetwork(network.getId(), null); - List publicIps = new ArrayList(); - if (userIps != null && !userIps.isEmpty()) { - for (IPAddressVO userIp : userIps) { - PublicIp publicIp = new PublicIp(userIp, _vlanDao.findById(userIp.getVlanId()), NetUtils.createSequenceBasedMacAddress(userIp.getMacAddress())); - publicIps.add(publicIp); - } - } - if (oldNetworkOffering.isConserveMode() && !newNetworkOffering.isConserveMode()) { - if (!canIpsUsedForNonConserve(publicIps)) { - return false; - } - } - - return canIpsUseOffering(publicIps, newNetworkOfferingId); - } - - protected boolean canUpgradeProviders(long oldNetworkOfferingId, long newNetworkOfferingId) { - // list of services and providers should be the same - Map> newServices = getNetworkOfferingServiceProvidersMap(newNetworkOfferingId); - Map> oldServices = getNetworkOfferingServiceProvidersMap(oldNetworkOfferingId); - - if (newServices.size() < oldServices.size()) { - s_logger.debug("Network offering downgrade is not allowed: number of supported services for the new offering " + newNetworkOfferingId + " is less than the old offering " + oldNetworkOfferingId); - return false; - } - - for (Service service : oldServices.keySet()) { - - // 1)check that all old services are present in the new network offering - if (!newServices.containsKey(service)) { - s_logger.debug("New service offering doesn't have " + service + " service present in the old service offering, downgrade is not allowed"); - return false; - } - - Set newProviders = newServices.get(service); - Set oldProviders = oldServices.get(service); - - // 2) Can upgrade only from internal provider to external provider. Any other combinations are not allowed - for (Provider oldProvider : oldProviders) { - if (newProviders.contains(oldProvider)) { - s_logger.trace("New list of providers contains provider " + oldProvider); - continue; - } - // iterate through new providers and check that the old provider can upgrade - for (Provider newProvider : newProviders) { - if (!(!oldProvider.isExternal() && newProvider.isExternal())) { - s_logger.debug("Can't downgrade from network offering " + oldNetworkOfferingId + " to the new networkOffering " + newNetworkOfferingId); - return false; - } - } - } - } - return true; - } - - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_CREATE, eventDescription = "Creating Physical Network", create = true) - public PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, List - isolationMethods, String broadcastDomainRangeStr, Long domainId, List tags, String name) { - - // Check if zone exists - if (zoneId == null) { - throw new InvalidParameterValueException("Please specify a valid zone."); - } - - DataCenterVO zone = _dcDao.findById(zoneId); - if (zone == null) { - throw new InvalidParameterValueException("Please specify a valid zone."); - } - - if (Grouping.AllocationState.Enabled == zone.getAllocationState()) { - // TBD: Send uuid instead of zoneId; may have to hardcode tablename in call to addProxyObject(). - throw new PermissionDeniedException("Cannot create PhysicalNetwork since the Zone is currently enabled, zone Id: " + zoneId); - } - - NetworkType zoneType = zone.getNetworkType(); - - if (zoneType == NetworkType.Basic) { - if (!_physicalNetworkDao.listByZone(zoneId).isEmpty()) { - // TBD: Send uuid instead of zoneId; may have to hardcode tablename in call to addProxyObject(). - throw new CloudRuntimeException("Cannot add the physical network to basic zone id: " + zoneId + ", there is a physical network already existing in this basic Zone"); - } - } - if (tags != null && tags.size() > 1) { - throw new InvalidParameterException("Only one tag can be specified for a physical network at this time"); - } - - if (isolationMethods != null && isolationMethods.size() > 1) { - throw new InvalidParameterException("Only one isolationMethod can be specified for a physical network at this time"); - } - - int vnetStart = 0; - int vnetEnd = 0; - if (vnetRange != null) { - // Verify zone type - if (zoneType == NetworkType.Basic - || (zoneType == NetworkType.Advanced && zone.isSecurityGroupEnabled())) { - throw new InvalidParameterValueException("Can't add vnet range to the physical network in the zone that supports " + zoneType + " network, Security Group enabled: " + zone.isSecurityGroupEnabled()); - } - - String[] tokens = vnetRange.split("-"); - try { - vnetStart = Integer.parseInt(tokens[0]); - if (tokens.length == 1) { - vnetEnd = vnetStart; - } else { - vnetEnd = Integer.parseInt(tokens[1]); - } - } catch (NumberFormatException e) { - throw new InvalidParameterValueException("Please specify valid integers for the vlan range."); - } - - //check for vnet conflicts with other physical network(s) in the zone - checkGuestVnetsConflicts(zoneId, vnetStart, vnetEnd, null); - - if ((vnetStart > vnetEnd) || (vnetStart < 0) || (vnetEnd > 4096)) { - s_logger.warn("Invalid vnet range: start range:" + vnetStart + " end range:" + vnetEnd); - throw new InvalidParameterValueException("Vnet range should be between 0-4096 and start range should be lesser than or equal to end range"); - } - } - - BroadcastDomainRange broadcastDomainRange = null; - if (broadcastDomainRangeStr != null && !broadcastDomainRangeStr.isEmpty()) { - try { - broadcastDomainRange = PhysicalNetwork.BroadcastDomainRange.valueOf(broadcastDomainRangeStr.toUpperCase()); - } catch (IllegalArgumentException ex) { - throw new InvalidParameterValueException("Unable to resolve broadcastDomainRange '" + broadcastDomainRangeStr + "' to a supported value {Pod or Zone}"); - } - - // in Acton release you can specify only Zone broadcastdomain type in Advance zone, and Pod in Basic - if (zoneType == NetworkType.Basic && broadcastDomainRange != null && broadcastDomainRange != BroadcastDomainRange.POD) { - throw new InvalidParameterValueException("Basic zone can have broadcast domain type of value " + BroadcastDomainRange.POD + " only"); - } else if (zoneType == NetworkType.Advanced && broadcastDomainRange != null && broadcastDomainRange != BroadcastDomainRange.ZONE) { - throw new InvalidParameterValueException("Advance zone can have broadcast domain type of value " + BroadcastDomainRange.ZONE + " only"); - } - } - - if (broadcastDomainRange == null) { - if (zoneType == NetworkType.Basic) { - broadcastDomainRange = PhysicalNetwork.BroadcastDomainRange.POD; - } else { - broadcastDomainRange = PhysicalNetwork.BroadcastDomainRange.ZONE; - } - } - - Transaction txn = Transaction.currentTxn(); - try { - txn.start(); - // Create the new physical network in the database - long id = _physicalNetworkDao.getNextInSequence(Long.class, "id"); - PhysicalNetworkVO pNetwork = new PhysicalNetworkVO(id, zoneId, vnetRange, networkSpeed, domainId, broadcastDomainRange, name); - pNetwork.setTags(tags); - pNetwork.setIsolationMethods(isolationMethods); - - pNetwork = _physicalNetworkDao.persist(pNetwork); - - // Add vnet entries for the new zone if zone type is Advanced - if (vnetRange != null) { - _dcDao.addVnet(zone.getId(), pNetwork.getId(), vnetStart, vnetEnd); - } - - // add VirtualRouter as the default network service provider - addDefaultVirtualRouterToPhysicalNetwork(pNetwork.getId()); - - // add security group provider to the physical network - addDefaultSecurityGroupProviderToPhysicalNetwork(pNetwork.getId()); - - // add VPCVirtualRouter as the defualt network service provider - addDefaultVpcVirtualRouterToPhysicalNetwork(pNetwork.getId()); - - txn.commit(); - return pNetwork; - } catch (Exception ex) { - s_logger.warn("Exception: ", ex); - throw new CloudRuntimeException("Fail to create a physical network"); - } - } - - @Override - public Pair, Integer> searchPhysicalNetworks(Long id, Long zoneId, String keyword, Long startIndex, Long pageSize, String name) { - Filter searchFilter = new Filter(PhysicalNetworkVO.class, "id", Boolean.TRUE, startIndex, pageSize); - SearchCriteria sc = _physicalNetworkDao.createSearchCriteria(); - - if (id != null) { - sc.addAnd("id", SearchCriteria.Op.EQ, id); - } - - if (zoneId != null) { - sc.addAnd("dataCenterId", SearchCriteria.Op.EQ, zoneId); - } - - if (name != null) { - sc.addAnd("name", SearchCriteria.Op.LIKE, "%" + name + "%"); - } - - Pair, Integer> result = _physicalNetworkDao.searchAndCount(sc, searchFilter); - return new Pair, Integer>(result.first(), result.second()); - } - - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_UPDATE, eventDescription = "updating physical network", async = true) - public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List tags, String newVnetRangeString, String state) { - - // verify input parameters - PhysicalNetworkVO network = _physicalNetworkDao.findById(id); - if (network == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); - ex.addProxyObject(network, id, "physicalNetworkId"); - throw ex; - } - - // if zone is of Basic type, don't allow to add vnet range - DataCenter zone = _dcDao.findById(network.getDataCenterId()); - if (zone == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Zone with id=" + network.getDataCenterId() + " doesn't exist in the system"); - ex.addProxyObject(zone, network.getDataCenterId(), "dataCenterId"); - throw ex; - } - if (newVnetRangeString != null) { - if (zone.getNetworkType() == NetworkType.Basic - || (zone.getNetworkType() == NetworkType.Advanced && zone.isSecurityGroupEnabled())) { - throw new InvalidParameterValueException("Can't add vnet range to the physical network in the zone that supports " + zone.getNetworkType() + " network, Security Group enabled: " - + zone.isSecurityGroupEnabled()); - } - } - - if (tags != null && tags.size() > 1) { - throw new InvalidParameterException("Unable to support more than one tag on network yet"); - } - - PhysicalNetwork.State networkState = null; - if (state != null && !state.isEmpty()) { - try { - networkState = PhysicalNetwork.State.valueOf(state); - } catch (IllegalArgumentException ex) { - throw new InvalidParameterValueException("Unable to resolve state '" + state + "' to a supported value {Enabled or Disabled}"); - } - } - - if (state != null) { - network.setState(networkState); - } - - if (tags != null) { - network.setTags(tags); - } - - if (networkSpeed != null) { - network.setSpeed(networkSpeed); - } - - // Vnet range can be extended only - boolean replaceVnet = false; - ArrayList> vnetsToAdd = new ArrayList>(2); - - if (newVnetRangeString != null) { - Integer newStartVnet = 0; - Integer newEndVnet = 0; - String[] newVnetRange = newVnetRangeString.split("-"); - int maxVnet = 4096; - // for GRE phynets allow up to 32bits - // TODO: Not happy about this test. - // What about guru-like objects for physical networs? - s_logger.debug("ISOLATION METHODS:" + network.getIsolationMethods()); - // Java does not have unsigned types... - if (network.getIsolationMethods().contains("GRE")) { - maxVnet = (int)(Math.pow(2, 32)-1); - } - String rangeMessage = " between 0 and " + maxVnet; - if (newVnetRange.length < 2) { - throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage); - } - - if (newVnetRange[0] == null || newVnetRange[1] == null) { - throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage); - } - - try { - newStartVnet = Integer.parseInt(newVnetRange[0]); - newEndVnet = Integer.parseInt(newVnetRange[1]); - } catch (NumberFormatException e) { - s_logger.warn("Unable to parse vnet range:", e); - throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage); - } - if (newStartVnet < 0 || newEndVnet > maxVnet) { - throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage); - } - - if (newStartVnet > newEndVnet) { - throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage + " and start range should be lesser than or equal to stop range"); - } - - //check if new vnet conflicts with vnet ranges of other physical networks - checkGuestVnetsConflicts(network.getDataCenterId(), newStartVnet, newEndVnet, network.getId()); - - if (physicalNetworkHasAllocatedVnets(network.getDataCenterId(), network.getId())) { - String[] existingRange = network.getVnet().split("-"); - int existingStartVnet = Integer.parseInt(existingRange[0]); - int existingEndVnet = Integer.parseInt(existingRange[1]); - - // check if vnet is being extended - if (newStartVnet.intValue() > existingStartVnet || newEndVnet.intValue() < existingEndVnet) { - throw new InvalidParameterValueException("Can't shrink existing vnet range as it the range has vnets allocated. Only extending existing vnet is supported"); - } - - if (newStartVnet < existingStartVnet) { - vnetsToAdd.add(new Pair(newStartVnet, existingStartVnet - 1)); - } - - if (newEndVnet > existingEndVnet) { - vnetsToAdd.add(new Pair(existingEndVnet + 1, newEndVnet)); - } - - } else { - vnetsToAdd.add(new Pair(newStartVnet, newEndVnet)); - replaceVnet = true; - } - } - - if (newVnetRangeString != null) { - network.setVnet(newVnetRangeString); - } - - _physicalNetworkDao.update(id, network); - - if (replaceVnet) { - s_logger.debug("Deleting existing vnet range for the physicalNetwork id= " + id + " and zone id=" + network.getDataCenterId() + " as a part of updatePhysicalNetwork call"); - _dcDao.deleteVnet(network.getId()); - } - - for (Pair vnetToAdd : vnetsToAdd) { - s_logger.debug("Adding vnet range " + vnetToAdd.first() + "-" + vnetToAdd.second() + " for the physicalNetwork id= " + id + " and zone id=" + network.getDataCenterId() - + " as a part of updatePhysicalNetwork call"); - _dcDao.addVnet(network.getDataCenterId(), network.getId(), vnetToAdd.first(), vnetToAdd.second()); - } - - return network; - } - - protected void checkGuestVnetsConflicts(long zoneId, int newStartVnet, int newEndVnet, Long pNtwkIdToSkip) { - List pNtwks = _physicalNetworkDao.listByZone(zoneId); - for (PhysicalNetwork pNtwk : pNtwks) { - // skip my own network and networks that don't have vnet range set - if ((pNtwk.getVnet() == null || pNtwk.getVnet().isEmpty()) || (pNtwkIdToSkip != null && pNtwkIdToSkip == pNtwk.getId())) { - continue; - } - String[] existingRange = pNtwk.getVnet().split("-"); - int startVnet = Integer.parseInt(existingRange[0]); - int endVnet = Integer.parseInt(existingRange[1]); - if ((newStartVnet >= startVnet && newStartVnet <= endVnet) - || (newEndVnet <= endVnet && newEndVnet >= startVnet)) { - throw new InvalidParameterValueException("Vnet range for physical network conflicts with another " + - "physical network's vnet in the zone"); - } - } - } - - private boolean physicalNetworkHasAllocatedVnets(long zoneId, long physicalNetworkId) { - return !_dcDao.listAllocatedVnets(physicalNetworkId).isEmpty(); - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_DELETE, eventDescription = "deleting physical network", async = true) - @DB - public boolean deletePhysicalNetwork(Long physicalNetworkId) { - - // verify input parameters - PhysicalNetworkVO pNetwork = _physicalNetworkDao.findById(physicalNetworkId); - if (pNetwork == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); - ex.addProxyObject(pNetwork, physicalNetworkId, "physicalNetworkId"); - throw ex; - } - - checkIfPhysicalNetworkIsDeletable(physicalNetworkId); - - Transaction txn = Transaction.currentTxn(); - txn.start(); - // delete vlans for this zone - List vlans = _vlanDao.listVlansByPhysicalNetworkId(physicalNetworkId); - for (VlanVO vlan : vlans) { - _vlanDao.remove(vlan.getId()); - } - - // Delete networks - List networks = _networksDao.listByPhysicalNetwork(physicalNetworkId); - if (networks != null && !networks.isEmpty()) { - for (NetworkVO network : networks) { - _networksDao.remove(network.getId()); - } - } - - // delete vnets - _dcDao.deleteVnet(physicalNetworkId); - - // delete service providers - List providers = _pNSPDao.listBy(physicalNetworkId); - - for(PhysicalNetworkServiceProviderVO provider : providers){ - try { - deleteNetworkServiceProvider(provider.getId()); - }catch (ResourceUnavailableException e) { - s_logger.warn("Unable to complete destroy of the physical network provider: " + provider.getProviderName() + ", id: "+ provider.getId(), e); - return false; - } catch (ConcurrentOperationException e) { - s_logger.warn("Unable to complete destroy of the physical network provider: " + provider.getProviderName() + ", id: "+ provider.getId(), e); - return false; - } - } - - // delete traffic types - _pNTrafficTypeDao.deleteTrafficTypes(physicalNetworkId); - - boolean success = _physicalNetworkDao.remove(physicalNetworkId); - - txn.commit(); - - return success; - } - - @DB - private void checkIfPhysicalNetworkIsDeletable(Long physicalNetworkId) { - List> tablesToCheck = new ArrayList>(); - - List vnet = new ArrayList(); - vnet.add(0, "op_dc_vnet_alloc"); - vnet.add(1, "physical_network_id"); - vnet.add(2, "there are allocated vnets for this physical network"); - tablesToCheck.add(vnet); - - List networks = new ArrayList(); - networks.add(0, "networks"); - networks.add(1, "physical_network_id"); - networks.add(2, "there are networks associated to this physical network"); - tablesToCheck.add(networks); - - /* - * List privateIP = new ArrayList(); - * privateIP.add(0, "op_dc_ip_address_alloc"); - * privateIP.add(1, "data_center_id"); - * privateIP.add(2, "there are private IP addresses allocated for this zone"); - * tablesToCheck.add(privateIP); - */ - - List publicIP = new ArrayList(); - publicIP.add(0, "user_ip_address"); - publicIP.add(1, "physical_network_id"); - publicIP.add(2, "there are public IP addresses allocated for this physical network"); - tablesToCheck.add(publicIP); - - for (List table : tablesToCheck) { - String tableName = table.get(0); - String column = table.get(1); - String errorMsg = table.get(2); - - String dbName = "cloud"; - - String selectSql = "SELECT * FROM `" + dbName + "`.`" + tableName + "` WHERE " + column + " = ?"; - - if (tableName.equals("networks")) { - selectSql += " AND removed is NULL"; - } - - if (tableName.equals("op_dc_vnet_alloc")) { - selectSql += " AND taken IS NOT NULL"; - } - - if (tableName.equals("user_ip_address")) { - selectSql += " AND state!='Free'"; - } - - if (tableName.equals("op_dc_ip_address_alloc")) { - selectSql += " AND taken IS NOT NULL"; - } - - Transaction txn = Transaction.currentTxn(); - try { - PreparedStatement stmt = txn.prepareAutoCloseStatement(selectSql); - stmt.setLong(1, physicalNetworkId); - ResultSet rs = stmt.executeQuery(); - if (rs != null && rs.next()) { - throw new CloudRuntimeException("The Physical Network is not deletable because " + errorMsg); - } - } catch (SQLException ex) { - throw new CloudRuntimeException("The Management Server failed to detect if physical network is deletable. Please contact Cloud Support."); - } - } - - } - - @Override - public List listNetworkServices(String providerName) { - - Provider provider = null; - if (providerName != null) { - provider = Network.Provider.getProvider(providerName); - if (provider == null) { - throw new InvalidParameterValueException("Invalid Network Service Provider=" + providerName); - } - } - - if (provider != null) { - NetworkElement element = getElementImplementingProvider(providerName); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + providerName + "'"); - } - return new ArrayList(element.getCapabilities().keySet()); - } else { - return Service.listAllServices(); - } - } - - @Override - public List listSupportedNetworkServiceProviders(String serviceName) { - Network.Service service = null; - if (serviceName != null) { - service = Network.Service.getService(serviceName); - if (service == null) { - throw new InvalidParameterValueException("Invalid Network Service=" + serviceName); - } - } - - Set supportedProviders = new HashSet(); - - if (service != null) { - supportedProviders.addAll(s_serviceToImplementedProvidersMap.get(service)); - } else { - for (List pList : s_serviceToImplementedProvidersMap.values()) { - supportedProviders.addAll(pList); - } - } - - return new ArrayList(supportedProviders); - } - - @Override - public Provider getDefaultUniqueProviderForService(String serviceName) { - List providers = listSupportedNetworkServiceProviders(serviceName); - if (providers.isEmpty()) { - throw new CloudRuntimeException("No providers supporting service " + serviceName + " found in cloudStack"); - } - if (providers.size() > 1) { - throw new CloudRuntimeException("More than 1 provider supporting service " + serviceName + " found in cloudStack"); - } - - return providers.get(0); - } - - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_CREATE, eventDescription = "Creating Physical Network ServiceProvider", create = true) - public PhysicalNetworkServiceProvider addProviderToPhysicalNetwork(Long physicalNetworkId, String providerName, Long destinationPhysicalNetworkId, List enabledServices) { - - // verify input parameters - PhysicalNetworkVO network = _physicalNetworkDao.findById(physicalNetworkId); - if (network == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); - ex.addProxyObject(network, physicalNetworkId, "physicalNetworkId"); - throw ex; - } - - // verify input parameters - if (destinationPhysicalNetworkId != null) { - PhysicalNetworkVO destNetwork = _physicalNetworkDao.findById(destinationPhysicalNetworkId); - if (destNetwork == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Destination Physical Network with specified id doesn't exist in the system"); - ex.addProxyObject(destNetwork, destinationPhysicalNetworkId, "destinationPhysicalNetworkId"); - throw ex; - } - } - - if (providerName != null) { - Provider provider = Network.Provider.getProvider(providerName); - if (provider == null) { - throw new InvalidParameterValueException("Invalid Network Service Provider=" + providerName); - } - } - - if (_pNSPDao.findByServiceProvider(physicalNetworkId, providerName) != null) { - // TBD: send uuid instead of physicalNetworkId. - throw new CloudRuntimeException("The '" + providerName + "' provider already exists on physical network : " + physicalNetworkId); - } - - // check if services can be turned off - NetworkElement element = getElementImplementingProvider(providerName); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + providerName + "'"); - } - List services = new ArrayList(); - - if (enabledServices != null) { - if (!element.canEnableIndividualServices()) { - if (enabledServices.size() != element.getCapabilities().keySet().size()) { - throw new InvalidParameterValueException("Cannot enable subset of Services, Please specify the complete list of Services for this Service Provider '" + providerName + "'"); - } - } - - // validate Services - boolean addGatewayService = false; - for (String serviceName : enabledServices) { - Network.Service service = Network.Service.getService(serviceName); - if (service == null || service == Service.Gateway) { - throw new InvalidParameterValueException("Invalid Network Service specified=" + serviceName); - } else if (service == Service.SourceNat) { - addGatewayService = true; - } - - // check if the service is provided by this Provider - if (!element.getCapabilities().containsKey(service)) { - throw new InvalidParameterValueException(providerName + " Provider cannot provide this Service specified=" + serviceName); - } - services.add(service); - } - - if (addGatewayService) { - services.add(Service.Gateway); - } - } else { - // enable all the default services supported by this element. - services = new ArrayList(element.getCapabilities().keySet()); - } - - Transaction txn = Transaction.currentTxn(); - try { - txn.start(); - // Create the new physical network in the database - PhysicalNetworkServiceProviderVO nsp = new PhysicalNetworkServiceProviderVO(physicalNetworkId, providerName); - // set enabled services - nsp.setEnabledServices(services); - - if (destinationPhysicalNetworkId != null) { - nsp.setDestinationPhysicalNetworkId(destinationPhysicalNetworkId); - } - nsp = _pNSPDao.persist(nsp); - - txn.commit(); - return nsp; - } catch (Exception ex) { - s_logger.warn("Exception: ", ex); - throw new CloudRuntimeException("Fail to add a provider to physical network"); - } - - } - - @Override - public Pair, Integer> listNetworkServiceProviders(Long physicalNetworkId, - String name, String state, Long startIndex, Long pageSize) { - - Filter searchFilter = new Filter(PhysicalNetworkServiceProviderVO.class, "id", false, startIndex, pageSize); - SearchBuilder sb = _pNSPDao.createSearchBuilder(); - SearchCriteria sc = sb.create(); - - if (physicalNetworkId != null) { - sc.addAnd("physicalNetworkId", Op.EQ, physicalNetworkId); - } - - if (name != null) { - sc.addAnd("providerName", Op.EQ, name); - } - - if (state != null) { - sc.addAnd("state", Op.EQ, state); - } - - Pair, Integer> result = _pNSPDao.searchAndCount(sc, searchFilter); - return new Pair, Integer>(result.first(), result.second()); - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_UPDATE, eventDescription = "Updating physical network ServiceProvider", async = true) - public PhysicalNetworkServiceProvider updateNetworkServiceProvider(Long id, String stateStr, List enabledServices) { - - PhysicalNetworkServiceProviderVO provider = _pNSPDao.findById(id); - if (provider == null) { - throw new InvalidParameterValueException("Network Service Provider id=" + id + "doesn't exist in the system"); - } - - NetworkElement element = getElementImplementingProvider(provider.getProviderName()); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getProviderName() + "'"); - } - - PhysicalNetworkServiceProvider.State state = null; - if (stateStr != null && !stateStr.isEmpty()) { - try { - state = PhysicalNetworkServiceProvider.State.valueOf(stateStr); - } catch (IllegalArgumentException ex) { - throw new InvalidParameterValueException("Unable to resolve state '" + stateStr + "' to a supported value {Enabled or Disabled}"); - } - } - - boolean update = false; - - if (state != null) { - if (state == PhysicalNetworkServiceProvider.State.Shutdown) { - throw new InvalidParameterValueException("Updating the provider state to 'Shutdown' is not supported"); - } - - if (s_logger.isDebugEnabled()) { - s_logger.debug("updating state of the service provider id=" + id + " on physical network: " + provider.getPhysicalNetworkId() + " to state: " + stateStr); - } - switch (state) { - case Enabled: - if (element != null && element.isReady(provider)) { - provider.setState(PhysicalNetworkServiceProvider.State.Enabled); - update = true; - } else { - throw new CloudRuntimeException("Provider is not ready, cannot Enable the provider, please configure the provider first"); - } - break; - case Disabled: - // do we need to do anything for the provider instances before disabling? - provider.setState(PhysicalNetworkServiceProvider.State.Disabled); - update = true; - break; - } - } - - if (enabledServices != null) { - // check if services can be turned of - if (!element.canEnableIndividualServices()) { - throw new InvalidParameterValueException("Cannot update set of Services for this Service Provider '" + provider.getProviderName() + "'"); - } - - // validate Services - List services = new ArrayList(); - for (String serviceName : enabledServices) { - Network.Service service = Network.Service.getService(serviceName); - if (service == null) { - throw new InvalidParameterValueException("Invalid Network Service specified=" + serviceName); - } - services.add(service); - } - // set enabled services - provider.setEnabledServices(services); - update = true; - } - - if (update) { - _pNSPDao.update(id, provider); - } - return provider; - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_DELETE, eventDescription = "Deleting physical network ServiceProvider", async = true) - public boolean deleteNetworkServiceProvider(Long id) throws ConcurrentOperationException, ResourceUnavailableException { - PhysicalNetworkServiceProviderVO provider = _pNSPDao.findById(id); - - if (provider == null) { - throw new InvalidParameterValueException("Network Service Provider id=" + id + "doesn't exist in the system"); - } - - // check if there are networks using this provider - List networks = _networksDao.listByPhysicalNetworkAndProvider(provider.getPhysicalNetworkId(), provider.getProviderName()); - if (networks != null && !networks.isEmpty()) { - throw new CloudRuntimeException("Provider is not deletable because there are active networks using this provider, please upgrade these networks to new network offerings"); - } - - User callerUser = _accountMgr.getActiveUser(UserContext.current().getCallerUserId()); - Account callerAccount = _accountMgr.getActiveAccountById(callerUser.getAccountId()); - // shutdown the provider instances - ReservationContext context = new ReservationContextImpl(null, null, callerUser, callerAccount); - if (s_logger.isDebugEnabled()) { - s_logger.debug("Shutting down the service provider id=" + id + " on physical network: " + provider.getPhysicalNetworkId()); - } - NetworkElement element = getElementImplementingProvider(provider.getProviderName()); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getProviderName() + "'"); - } - - if (element != null && element.shutdownProviderInstances(provider, context)) { - provider.setState(PhysicalNetworkServiceProvider.State.Shutdown); - } - - return _pNSPDao.remove(id); - } - - @Override - public PhysicalNetwork getPhysicalNetwork(Long physicalNetworkId) { - return _physicalNetworkDao.findById(physicalNetworkId); - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_CREATE, eventDescription = "Creating Physical Network", async = true) - public PhysicalNetwork getCreatedPhysicalNetwork(Long physicalNetworkId) { - return getPhysicalNetwork(physicalNetworkId); - } - - @Override - public PhysicalNetworkServiceProvider getPhysicalNetworkServiceProvider(Long providerId) { - return _pNSPDao.findById(providerId); - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_CREATE, eventDescription = "Creating Physical Network ServiceProvider", async = true) - public PhysicalNetworkServiceProvider getCreatedPhysicalNetworkServiceProvider(Long providerId) { - return getPhysicalNetworkServiceProvider(providerId); - } - - @Override - public long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType) { - List pNtwks = new ArrayList(); - if (trafficType != null) { - pNtwks = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); - } else { - pNtwks = _physicalNetworkDao.listByZone(zoneId); - } - - if (pNtwks.isEmpty()) { - throw new InvalidParameterValueException("Unable to find physical network in zone id=" + zoneId); - } - - if (pNtwks.size() > 1) { - if (tag == null) { - throw new InvalidParameterValueException("More than one physical networks exist in zone id=" + zoneId + " and no tags are specified in order to make a choice"); - } - - Long pNtwkId = null; - for (PhysicalNetwork pNtwk : pNtwks) { - if (pNtwk.getTags().contains(tag)) { - s_logger.debug("Found physical network id=" + pNtwk.getId() + " based on requested tags " + tag); - pNtwkId = pNtwk.getId(); - break; - } - } - if (pNtwkId == null) { - throw new InvalidParameterValueException("Unable to find physical network which match the tags " + tag); - } - return pNtwkId; - } else { - return pNtwks.get(0).getId(); - } - } - - @Override - public List listNetworkOfferingsForUpgrade(long networkId) { - List offeringsToReturn = new ArrayList(); - NetworkOffering originalOffering = _configMgr.getNetworkOffering(getNetwork(networkId).getNetworkOfferingId()); - - boolean securityGroupSupportedByOriginalOff = areServicesSupportedByNetworkOffering(originalOffering.getId(), Service.SecurityGroup); - - // security group supported property should be the same - - List offerings = _networkOfferingDao.getOfferingIdsToUpgradeFrom(originalOffering); - - for (Long offeringId : offerings) { - if (areServicesSupportedByNetworkOffering(offeringId, Service.SecurityGroup) == securityGroupSupportedByOriginalOff) { - offeringsToReturn.add(offeringId); - } - } - - return offeringsToReturn; - } - private boolean cleanupNetworkResources(long networkId, Account caller, long callerUserId) { boolean success = true; - Network network = getNetwork(networkId); + Network network = _networksDao.findById(networkId); //remove all PF/Static Nat rules for the network try { @@ -6035,7 +2971,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag throw new InvalidParameterValueException("Source ip address of the rule id=" + firewallStaticNatRule.getId() + " is not static nat enabled"); } - String dstIp = getIpInNetwork(ip.getAssociatedWithVmId(), firewallStaticNatRule.getNetworkId()); + String dstIp = _networkModel.getIpInNetwork(ip.getAssociatedWithVmId(), firewallStaticNatRule.getNetworkId()); ruleVO.setState(FirewallRule.State.Revoke); staticNatRules.add(new StaticNatRuleImpl(ruleVO, dstIp)); } @@ -6128,7 +3064,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } // Get all ip addresses, mark as releasing and release them on the backend - Network network = getNetwork(networkId); + Network network = _networksDao.findById(networkId); List userIps = _ipAddressDao.listByAssociatedNetwork(networkId, null); List publicIpsToRelease = new ArrayList(); if (userIps != null && !userIps.isEmpty()) { @@ -6151,259 +3087,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - @Override - public boolean isSecurityGroupSupportedInNetwork(Network network) { - if (network.getTrafficType() != TrafficType.Guest) { - s_logger.trace("Security group can be enabled for Guest networks only; and network " + network + " has a diff traffic type"); - return false; - } - - Long physicalNetworkId = network.getPhysicalNetworkId(); - - // physical network id can be null in Guest Network in Basic zone, so locate the physical network - if (physicalNetworkId == null) { - physicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), null, null); - } - - return isServiceEnabledInNetwork(physicalNetworkId, network.getId(), Service.SecurityGroup); - } - - @Override - @DB - @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_CREATE, eventDescription = "Creating Physical Network TrafficType", create = true) - public PhysicalNetworkTrafficType addTrafficTypeToPhysicalNetwork(Long physicalNetworkId, String trafficTypeStr, String xenLabel, String kvmLabel, String vmwareLabel, String simulatorLabel, String vlan) { - - // verify input parameters - PhysicalNetworkVO network = _physicalNetworkDao.findById(physicalNetworkId); - if (network == null) { - throw new InvalidParameterValueException("Physical Network id=" + physicalNetworkId + "doesn't exist in the system"); - } - - Networks.TrafficType trafficType = null; - if (trafficTypeStr != null && !trafficTypeStr.isEmpty()) { - try { - trafficType = Networks.TrafficType.valueOf(trafficTypeStr); - } catch (IllegalArgumentException ex) { - throw new InvalidParameterValueException("Unable to resolve trafficType '" + trafficTypeStr + "' to a supported value"); - } - } - - if (_pNTrafficTypeDao.isTrafficTypeSupported(physicalNetworkId, trafficType)) { - throw new CloudRuntimeException("This physical network already supports the traffic type: " + trafficType); - } - // For Storage, Control, Management, Public check if the zone has any other physical network with this - // traffictype already present - // If yes, we cant add these traffics to one more physical network in the zone. - - if (TrafficType.isSystemNetwork(trafficType) || TrafficType.Public.equals(trafficType) || TrafficType.Storage.equals(trafficType)) { - if (!_physicalNetworkDao.listByZoneAndTrafficType(network.getDataCenterId(), trafficType).isEmpty()) { - throw new CloudRuntimeException("Fail to add the traffic type to physical network because Zone already has a physical network with this traffic type: " + trafficType); - } - } - - if (TrafficType.Storage.equals(trafficType)) { - List ssvms = _stnwMgr.getSSVMWithNoStorageNetwork(network.getDataCenterId()); - if (!ssvms.isEmpty()) { - StringBuilder sb = new StringBuilder( - "Cannot add " - + trafficType - + " traffic type as there are below secondary storage vm still running. Please stop them all and add Storage traffic type again, then destory them all to allow CloudStack recreate them with storage network(If you have added storage network ip range)"); - sb.append("SSVMs:"); - for (SecondaryStorageVmVO ssvm : ssvms) { - sb.append(ssvm.getInstanceName()).append(":").append(ssvm.getState()); - } - throw new CloudRuntimeException(sb.toString()); - } - } - - Transaction txn = Transaction.currentTxn(); - try { - txn.start(); - // Create the new traffic type in the database - if (xenLabel == null) { - xenLabel = getDefaultXenNetworkLabel(trafficType); - } - PhysicalNetworkTrafficTypeVO pNetworktrafficType = new PhysicalNetworkTrafficTypeVO(physicalNetworkId, trafficType, xenLabel, kvmLabel, vmwareLabel, simulatorLabel, vlan); - pNetworktrafficType = _pNTrafficTypeDao.persist(pNetworktrafficType); - - txn.commit(); - return pNetworktrafficType; - } catch (Exception ex) { - s_logger.warn("Exception: ", ex); - throw new CloudRuntimeException("Fail to add a traffic type to physical network"); - } - - } - - private String getDefaultXenNetworkLabel(TrafficType trafficType) { - String xenLabel = null; - switch (trafficType) { - case Public: - xenLabel = _configDao.getValue(Config.XenPublicNetwork.key()); - break; - case Guest: - xenLabel = _configDao.getValue(Config.XenGuestNetwork.key()); - break; - case Storage: - xenLabel = _configDao.getValue(Config.XenStorageNetwork1.key()); - break; - case Management: - xenLabel = _configDao.getValue(Config.XenPrivateNetwork.key()); - break; - case Control: - xenLabel = "cloud_link_local_network"; - break; - } - return xenLabel; - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_CREATE, eventDescription = "Creating Physical Network TrafficType", async = true) - public PhysicalNetworkTrafficType getPhysicalNetworkTrafficType(Long id) { - return _pNTrafficTypeDao.findById(id); - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_UPDATE, eventDescription = "Updating physical network TrafficType", async = true) - public PhysicalNetworkTrafficType updatePhysicalNetworkTrafficType(Long id, String xenLabel, String kvmLabel, String vmwareLabel) { - - PhysicalNetworkTrafficTypeVO trafficType = _pNTrafficTypeDao.findById(id); - - if (trafficType == null) { - throw new InvalidParameterValueException("Traffic Type with id=" + id + "doesn't exist in the system"); - } - - if (xenLabel != null) { - if("".equals(xenLabel)){ - xenLabel = null; - } - trafficType.setXenNetworkLabel(xenLabel); - } - if (kvmLabel != null) { - if("".equals(kvmLabel)){ - kvmLabel = null; - } - trafficType.setKvmNetworkLabel(kvmLabel); - } - if (vmwareLabel != null) { - if("".equals(vmwareLabel)){ - vmwareLabel = null; - } - trafficType.setVmwareNetworkLabel(vmwareLabel); - } - _pNTrafficTypeDao.update(id, trafficType); - - return trafficType; - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_DELETE, eventDescription = "Deleting physical network TrafficType", async = true) - public boolean deletePhysicalNetworkTrafficType(Long id) { - PhysicalNetworkTrafficTypeVO trafficType = _pNTrafficTypeDao.findById(id); - - if (trafficType == null) { - throw new InvalidParameterValueException("Traffic Type with id=" + id + "doesn't exist in the system"); - } - - // check if there are any networks associated to this physical network with this traffic type - if (TrafficType.Guest.equals(trafficType.getTrafficType())) { - if (!_networksDao.listByPhysicalNetworkTrafficType(trafficType.getPhysicalNetworkId(), trafficType.getTrafficType()).isEmpty()) { - throw new CloudRuntimeException("The Traffic Type is not deletable because there are existing networks with this traffic type:" + trafficType.getTrafficType()); - } - } else if (TrafficType.Storage.equals(trafficType.getTrafficType())) { - PhysicalNetworkVO pn = _physicalNetworkDao.findById(trafficType.getPhysicalNetworkId()); - if (_stnwMgr.isAnyStorageIpInUseInZone(pn.getDataCenterId())) { - throw new CloudRuntimeException("The Traffic Type is not deletable because there are still some storage network ip addresses in use:" + trafficType.getTrafficType()); - } - } - return _pNTrafficTypeDao.remove(id); - } - - @Override - public Pair, Integer> listTrafficTypes(Long physicalNetworkId) { - PhysicalNetworkVO network = _physicalNetworkDao.findById(physicalNetworkId); - if (network == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); - ex.addProxyObject(network, physicalNetworkId, "physicalNetworkId"); - throw ex; - } - - Pair, Integer> result = _pNTrafficTypeDao.listAndCountBy(physicalNetworkId); - return new Pair, Integer>(result.first(), result.second()); - } - - @Override - public PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - - List networkList = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); - - if (networkList.isEmpty()) { - InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find the default physical network with traffic=" + trafficType + " in the specified zone id"); - // Since we don't have a DataCenterVO object at our disposal, we just set the table name that the zoneId's corresponding uuid is looked up from, manually. - ex.addProxyObject("data_center", zoneId, "zoneId"); - throw ex; - } - - if (networkList.size() > 1) { - InvalidParameterValueException ex = new InvalidParameterValueException("More than one physical networks exist in zone id=" + zoneId + " with traffic type=" + trafficType); - ex.addProxyObject("data_center", zoneId, "zoneId"); - throw ex; - } - - return networkList.get(0); - } - - @Override - public String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType){ - try{ - PhysicalNetwork mgmtPhyNetwork = getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Management); - PhysicalNetworkTrafficTypeVO mgmtTraffic = _pNTrafficTypeDao.findBy(mgmtPhyNetwork.getId(), TrafficType.Management); - if(mgmtTraffic != null){ - String label = null; - switch(hypervisorType){ - case XenServer : label = mgmtTraffic.getXenNetworkLabel(); - break; - case KVM : label = mgmtTraffic.getKvmNetworkLabel(); - break; - case VMware : label = mgmtTraffic.getVmwareNetworkLabel(); - break; - } - return label; - } - }catch(Exception ex){ - if(s_logger.isDebugEnabled()){ - s_logger.debug("Failed to retrive the default label for management traffic:"+"zone: "+ zoneId +" hypervisor: "+hypervisorType +" due to:" + ex.getMessage()); - } - } - return null; - } - - @Override - public String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType){ - try{ - PhysicalNetwork storagePhyNetwork = getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Storage); - PhysicalNetworkTrafficTypeVO storageTraffic = _pNTrafficTypeDao.findBy(storagePhyNetwork.getId(), TrafficType.Storage); - if(storageTraffic != null){ - String label = null; - switch(hypervisorType){ - case XenServer : label = storageTraffic.getXenNetworkLabel(); - break; - case KVM : label = storageTraffic.getKvmNetworkLabel(); - break; - case VMware : label = storageTraffic.getVmwareNetworkLabel(); - break; - } - return label; - } - }catch(Exception ex){ - if(s_logger.isDebugEnabled()){ - s_logger.debug("Failed to retrive the default label for storage traffic:"+"zone: "+ zoneId +" hypervisor: "+hypervisorType +" due to:" + ex.getMessage()); - } - } - return null; - } - - @Override public boolean processAnswers(long agentId, long seq, Answer[] answers) { return false; @@ -6419,32 +3102,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return null; } - @Override - public List getPhysicalNetworkInfo(long dcId, HypervisorType hypervisorType) { - List networkInfoList = new ArrayList(); - List physicalNtwkList = _physicalNetworkDao.listByZone(dcId); - for (PhysicalNetworkVO pNtwk : physicalNtwkList) { - String publicName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Public, hypervisorType); - String privateName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Management, hypervisorType); - String guestName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Guest, hypervisorType); - String storageName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Storage, hypervisorType); - // String controlName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Control, hypervisorType); - PhysicalNetworkSetupInfo info = new PhysicalNetworkSetupInfo(); - info.setPhysicalNetworkId(pNtwk.getId()); - info.setGuestNetworkName(guestName); - info.setPrivateNetworkName(privateName); - info.setPublicNetworkName(publicName); - info.setStorageNetworkName(storageName); - PhysicalNetworkTrafficTypeVO mgmtTraffic = _pNTrafficTypeDao.findBy(pNtwk.getId(), TrafficType.Management); - if (mgmtTraffic != null) { - String vlan = mgmtTraffic.getVlan(); - info.setMgmtVlan(vlan); - } - networkInfoList.add(info); - } - return networkInfoList; - } - @Override public void processConnect(HostVO host, StartupCommand cmd, boolean forRebalance) throws ConnectionException { if (!(cmd instanceof StartupRoutingCommand)) { @@ -6483,7 +3140,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag String privateName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Management, hypervisorType); String guestName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Guest, hypervisorType); String storageName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Storage, hypervisorType); - // String controlName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Control, hypervisorType); + // String controlName = _pNTrafficTypeDao._networkModel.getNetworkTag(pNtwk.getId(), TrafficType.Control, hypervisorType); PhysicalNetworkSetupInfo info = new PhysicalNetworkSetupInfo(); info.setPhysicalNetworkId(pNtwk.getId()); info.setGuestNetworkName(guestName); @@ -6547,164 +3204,8 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return false; } - private boolean isProviderEnabled(PhysicalNetworkServiceProvider provider) { - if (provider == null || provider.getState() != PhysicalNetworkServiceProvider.State.Enabled) { // TODO: check -// for other states: Shutdown? - return false; - } - return true; - } - @Override - public boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName) { - PhysicalNetworkServiceProviderVO ntwkSvcProvider = _pNSPDao.findByServiceProvider(physicalNetowrkId, providerName); - if (ntwkSvcProvider == null) { - s_logger.warn("Unable to find provider " + providerName + " in physical network id=" + physicalNetowrkId); - return false; - } - return isProviderEnabled(ntwkSvcProvider); - } - - private boolean isServiceEnabledInNetwork(long physicalNetworkId, long networkId, Service service) { - // check if the service is supported in the network - if (!areServicesSupportedInNetwork(networkId, service)) { - s_logger.debug("Service " + service.getName() + " is not supported in the network id=" + networkId); - return false; - } - - // get provider for the service and check if all of them are supported - String provider = _ntwkSrvcDao.getProviderForServiceInNetwork(networkId, service); - if (!isProviderEnabledInPhysicalNetwork(physicalNetworkId, provider)) { - s_logger.debug("Provider " + provider + " is not enabled in physical network id=" + physicalNetworkId); - return false; - } - - return true; - } - - @Override - public String getNetworkTag(HypervisorType hType, Network network) { - // no network tag for control traffic type - TrafficType effectiveTrafficType = network.getTrafficType(); - if(hType == HypervisorType.VMware && effectiveTrafficType == TrafficType.Control) - effectiveTrafficType = TrafficType.Management; - - if (effectiveTrafficType == TrafficType.Control) { - return null; - } - - Long physicalNetworkId = null; - if (effectiveTrafficType != TrafficType.Guest) { - physicalNetworkId = getNonGuestNetworkPhysicalNetworkId(network); - } else { - NetworkOffering offering = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); - physicalNetworkId = network.getPhysicalNetworkId(); - if(physicalNetworkId == null){ - physicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), offering.getTags(), offering.getTrafficType()); - } - } - - if (physicalNetworkId == null) { - assert (false) : "Can't get the physical network"; - s_logger.warn("Can't get the physical network"); - return null; - } - - return _pNTrafficTypeDao.getNetworkTag(physicalNetworkId, effectiveTrafficType, hType); - } - - protected Long getNonGuestNetworkPhysicalNetworkId(Network network) { - // no physical network for control traffic type - - // have to remove this sanity check as VMware control network is management network - // we need to retrieve traffic label information through physical network -/* - if (network.getTrafficType() == TrafficType.Control) { - return null; - } -*/ - Long physicalNetworkId = network.getPhysicalNetworkId(); - - if (physicalNetworkId == null) { - List pNtwks = _physicalNetworkDao.listByZone(network.getDataCenterId()); - if (pNtwks.size() == 1) { - physicalNetworkId = pNtwks.get(0).getId(); - } else { - // locate physicalNetwork with supported traffic type - // We can make this assumptions based on the fact that Public/Management/Control traffic types are - // supported only in one physical network in the zone in 3.0 - for (PhysicalNetworkVO pNtwk : pNtwks) { - if (_pNTrafficTypeDao.isTrafficTypeSupported(pNtwk.getId(), network.getTrafficType())) { - physicalNetworkId = pNtwk.getId(); - break; - } - } - } - } - return physicalNetworkId; - } - - @Override - public NetworkVO getExclusiveGuestNetwork(long zoneId) { - List networks = _networksDao.listBy(Account.ACCOUNT_ID_SYSTEM, zoneId, GuestType.Shared, TrafficType.Guest); - if (networks == null || networks.isEmpty()) { - throw new InvalidParameterValueException("Unable to find network with trafficType " + TrafficType.Guest + " and guestType " + GuestType.Shared + " in zone " + zoneId); - } - - if (networks.size() > 1) { - throw new InvalidParameterValueException("Found more than 1 network with trafficType " + TrafficType.Guest + " and guestType " + GuestType.Shared + " in zone " + zoneId); - - } - - return networks.get(0); - } - - protected PhysicalNetworkServiceProvider addDefaultVirtualRouterToPhysicalNetwork(long physicalNetworkId) { - - PhysicalNetworkServiceProvider nsp = addProviderToPhysicalNetwork(physicalNetworkId, Network.Provider.VirtualRouter.getName(), null, null); - // add instance of the provider - VirtualRouterElement element = (VirtualRouterElement) getElementImplementingProvider(Network.Provider.VirtualRouter.getName()); - if (element == null) { - throw new CloudRuntimeException("Unable to find the Network Element implementing the VirtualRouter Provider"); - } - element.addElement(nsp.getId(), VirtualRouterProviderType.VirtualRouter); - - return nsp; - } - - protected PhysicalNetworkServiceProvider addDefaultVpcVirtualRouterToPhysicalNetwork(long physicalNetworkId) { - - PhysicalNetworkServiceProvider nsp = addProviderToPhysicalNetwork(physicalNetworkId, - Network.Provider.VPCVirtualRouter.getName(), null, null); - // add instance of the provider - VpcVirtualRouterElement element = (VpcVirtualRouterElement) getElementImplementingProvider(Network.Provider.VPCVirtualRouter.getName()); - if (element == null) { - throw new CloudRuntimeException("Unable to find the Network Element implementing the VPCVirtualRouter Provider"); - } - element.addElement(nsp.getId(), VirtualRouterProviderType.VPCVirtualRouter); - - return nsp; - } - - protected PhysicalNetworkServiceProvider addDefaultSecurityGroupProviderToPhysicalNetwork(long physicalNetworkId) { - - PhysicalNetworkServiceProvider nsp = addProviderToPhysicalNetwork(physicalNetworkId, - Network.Provider.SecurityGroupProvider.getName(), null, null); - - return nsp; - } - - @Override - public boolean isNetworkSystem(Network network) { - NetworkOffering no = _networkOfferingDao.findByIdIncludingRemoved(network.getNetworkOfferingId()); - if (no.isSystemOnly()) { - return true; - } else { - return false; - } - } - - protected Map finalizeServicesAndProvidersForNetwork(NetworkOffering offering, Long physicalNetworkId) { + public Map finalizeServicesAndProvidersForNetwork(NetworkOffering offering, Long physicalNetworkId) { Map svcProviders = new HashMap(); Map> providerSvcs = new HashMap>(); List servicesMap = _ntwkOfferingSrvcDao.listByNetworkOfferingId(offering.getId()); @@ -6722,7 +3223,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag String provider = serviceMap.getProvider(); if (provider == null) { - provider = getDefaultUniqueProviderForService(service).getName(); + provider = _networkModel.getDefaultUniqueProviderForService(service).getName(); } // check that provider is supported @@ -6744,25 +3245,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return svcProviders; } - @Override - public Long getPhysicalNetworkId(Network network) { - if (network.getTrafficType() != TrafficType.Guest) { - return getNonGuestNetworkPhysicalNetworkId(network); - } - - Long physicalNetworkId = network.getPhysicalNetworkId(); - NetworkOffering offering = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); - if (physicalNetworkId == null) { - physicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), offering.getTags(), offering.getTrafficType()); - } - return physicalNetworkId; - } - - @Override - public boolean getAllowSubdomainAccessGlobal() { - return _allowSubdomainNetworkAccess; - } - private List getNetworkProviders(long networkId) { List providerNames = _ntwkSrvcDao.getDistinctProviders(networkId); List providers = new ArrayList(); @@ -6774,198 +3256,9 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag } @Override - public boolean isProviderForNetwork(Provider provider, long networkId) { - if (_ntwkSrvcDao.isProviderForNetwork(networkId, provider) != null) { - return true; - } else { - return false; - } - } - - @Override - public boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId) { - if (_ntwkOfferingSrvcDao.isProviderForNetworkOffering(networkOfferingId, provider)) { - return true; - } else { - return false; - } - } - - @Override - public void canProviderSupportServices(Map> providersMap) { - for (Provider provider : providersMap.keySet()) { - // check if services can be turned off - NetworkElement element = getElementImplementingProvider(provider.getName()); - if (element == null) { - throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'"); - } - - Set enabledServices = new HashSet(); - enabledServices.addAll(providersMap.get(provider)); - - if (enabledServices != null && !enabledServices.isEmpty()) { - if (!element.canEnableIndividualServices()) { - Set requiredServices = new HashSet(); - requiredServices.addAll(element.getCapabilities().keySet()); - - if (requiredServices.contains(Network.Service.Gateway)) { - requiredServices.remove(Network.Service.Gateway); - } - - if (requiredServices.contains(Network.Service.Firewall)) { - requiredServices.remove(Network.Service.Firewall); - } - - if (enabledServices.contains(Network.Service.Firewall)) { - enabledServices.remove(Network.Service.Firewall); - } - - // exclude gateway service - if (enabledServices.size() != requiredServices.size()) { - StringBuilder servicesSet = new StringBuilder(); - - for (Service requiredService : requiredServices) { - // skip gateway service as we don't allow setting it via API - if (requiredService == Service.Gateway) { - continue; - } - servicesSet.append(requiredService.getName() + ", "); - } - servicesSet.delete(servicesSet.toString().length() - 2, servicesSet.toString().length()); - - throw new InvalidParameterValueException("Cannot enable subset of Services, Please specify the complete list of Services: " + servicesSet.toString() + " for Service Provider " - + provider.getName()); - } - } - List serviceList = new ArrayList(); - for (Service service : enabledServices) { - // check if the service is provided by this Provider - if (!element.getCapabilities().containsKey(service)) { - throw new UnsupportedServiceException(provider.getName() + " Provider cannot provide service " + service.getName()); - } - serviceList.add(service.getName()); - } - if (!element.verifyServicesCombination(enabledServices)) { - throw new UnsupportedServiceException("Provider " + provider.getName() + " doesn't support services combination: " + serviceList); - } - } - } - } - - @Override - public boolean canAddDefaultSecurityGroup() { - String defaultAdding = _configDao.getValue(Config.SecurityGroupDefaultAdding.key()); - return (defaultAdding != null && defaultAdding.equalsIgnoreCase("true")); - } - - @Override - public List listNetworkOfferingServices(long networkOfferingId) { - List services = new ArrayList(); - List servicesStr = _ntwkOfferingSrvcDao.listServicesForNetworkOffering(networkOfferingId); - for (String serviceStr : servicesStr) { - services.add(Service.getService(serviceStr)); - } - - return services; - } - - @Override - public boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services) { - long physicalNtwkId = findPhysicalNetworkId(zoneId, offering.getTags(), offering.getTrafficType()); - boolean result = true; - List checkedProvider = new ArrayList(); - for (Service service : services) { - // get all the providers, and check if each provider is enabled - List providerNames = _ntwkOfferingSrvcDao.listProvidersForServiceForNetworkOffering(offering.getId(), service); - for (String providerName : providerNames) { - if (!checkedProvider.contains(providerName)) { - result = result && isProviderEnabledInPhysicalNetwork(physicalNtwkId, providerName); - } - } - } - - return result; - } - - @Override - public boolean checkIpForService(IPAddressVO userIp, Service service, Long networkId) { - if (networkId == null) { - networkId = userIp.getAssociatedWithNetworkId(); - } - - NetworkVO network = _networksDao.findById(networkId); - NetworkOfferingVO offering = _networkOfferingDao.findById(network.getNetworkOfferingId()); - if (offering.getGuestType() != GuestType.Isolated) { - return true; - } - PublicIp publicIp = new PublicIp(userIp, _vlanDao.findById(userIp.getVlanId()), NetUtils.createSequenceBasedMacAddress(userIp.getMacAddress())); - if (!canIpUsedForService(publicIp, service, networkId)) { - return false; - } - if (!offering.isConserveMode()) { - return canIpUsedForNonConserveService(publicIp, service); - } - return true; - } - - @Override - public List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd) { - String type = cmd.getTrafficType(); - List> results = new ArrayList>(); - if (type != null) { - for (NetworkGuru guru : _networkGurus) { - if (guru.isMyTrafficType(TrafficType.getTrafficType(type))) { - results.add(new Pair(TrafficType.getTrafficType(type), guru.getName())); - break; - } - } - } else { - for (NetworkGuru guru : _networkGurus) { - TrafficType[] allTypes = guru.getSupportedTrafficType(); - for (TrafficType t : allTypes) { - results.add(new Pair(t, guru.getName())); - } - } - } - - return results; - } - - @Override - public void checkCapabilityForProvider(Set providers, Service service, Capability cap, String capValue) { - for (Provider provider : providers) { - NetworkElement element = getElementImplementingProvider(provider.getName()); - if (element != null) { - Map> elementCapabilities = element.getCapabilities(); - if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { - throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider.getName()); - } - Map serviceCapabilities = elementCapabilities.get(service); - if (serviceCapabilities == null || serviceCapabilities.isEmpty()) { - throw new UnsupportedServiceException("Service " + service.getName() + " doesn't have capabilites for element=" + element.getName() + " implementing Provider=" + provider.getName()); - } - - String value = serviceCapabilities.get(cap); - if (value == null || value.isEmpty()) { - throw new UnsupportedServiceException("Service " + service.getName() + " doesn't have capability " + cap.getName() + " for element=" + element.getName() + " implementing Provider=" - + provider.getName()); - } - - capValue = capValue.toLowerCase(); - - if (!value.contains(capValue)) { - throw new UnsupportedServiceException("Service " + service.getName() + " doesn't support value " + capValue + " for capability " + cap.getName() + " for element=" + element.getName() - + " implementing Provider=" + provider.getName()); - } - } else { - throw new UnsupportedServiceException("Unable to find network element for provider " + provider.getName()); - } - } - } - - public IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) + public IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) throws InsufficientAddressCapacityException { - Network guestNetwork = getNetwork(networkId); + Network guestNetwork = _networksDao.findById(networkId); NetworkOffering off = _configMgr.getNetworkOffering(guestNetwork.getNetworkOfferingId()); IpAddress ip = null; if ((off.getElasticLb() && forElasticLb) || (off.getElasticIp() && forElasticIp)) { @@ -6975,7 +3268,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag // allocate ip ip = allocateIP(owner, true, guestNetwork.getDataCenterId()); // apply ip associations - ip = associateIPToNetwork(ip.getId(), networkId); + ip = associateIPToGuestNetwork(ip.getId(), networkId, true);; } catch (ResourceAllocationException ex) { throw new CloudRuntimeException("Failed to allocate system ip due to ", ex); } catch (ConcurrentOperationException ex) { @@ -7010,21 +3303,6 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return success; } - @Override - public void checkNetworkPermissions(Account owner, Network network) { - // Perform account permission check - if (network.getGuestType() != Network.GuestType.Shared) { - List networkMap = _networksDao.listBy(owner.getId(), network.getId()); - if (networkMap == null || networkMap.isEmpty()) { - throw new PermissionDeniedException("Unable to use network with id= " + network.getId() + ", permission denied"); - } - } else { - if (!isNetworkAvailableInDomain(network.getId(), owner.getDomainId())) { - throw new PermissionDeniedException("Shared network id=" + network.getId() + " is not available in domain id=" + owner.getDomainId()); - } - } - } - public void allocateDirectIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, Network network, String requestedIp) throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException { if (nic.getIp4Address() == null) { @@ -7044,283 +3322,19 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag nic.setDns2(dc.getDns2()); } - @Override - public String getDefaultPublicTrafficLabel(long dcId, HypervisorType hypervisorType) { - try { - PhysicalNetwork publicPhyNetwork = getOnePhysicalNetworkByZoneAndTrafficType(dcId, TrafficType.Public); - PhysicalNetworkTrafficTypeVO publicTraffic = _pNTrafficTypeDao.findBy(publicPhyNetwork.getId(), - TrafficType.Public); - if (publicTraffic != null) { - String label = null; - switch (hypervisorType) { - case XenServer: - label = publicTraffic.getXenNetworkLabel(); - break; - case KVM: - label = publicTraffic.getKvmNetworkLabel(); - break; - case VMware: - label = publicTraffic.getVmwareNetworkLabel(); - break; - } - return label; - } - } catch (Exception ex) { - if (s_logger.isDebugEnabled()) { - s_logger.debug("Failed to retrieve the default label for public traffic." + "zone: " + dcId + " hypervisor: " + hypervisorType + " due to: " + ex.getMessage()); - } - } - return null; - } - - @Override - public String getDefaultGuestTrafficLabel(long dcId, HypervisorType hypervisorType) { - try { - PhysicalNetwork guestPhyNetwork = getOnePhysicalNetworkByZoneAndTrafficType(dcId, TrafficType.Guest); - PhysicalNetworkTrafficTypeVO guestTraffic = _pNTrafficTypeDao.findBy(guestPhyNetwork.getId(), - TrafficType.Guest); - if (guestTraffic != null) { - String label = null; - switch (hypervisorType) { - case XenServer: - label = guestTraffic.getXenNetworkLabel(); - break; - case KVM: - label = guestTraffic.getKvmNetworkLabel(); - break; - case VMware: - label = guestTraffic.getVmwareNetworkLabel(); - break; - } - return label; - } - } catch (Exception ex) { - if (s_logger.isDebugEnabled()) { - s_logger.debug("Failed to retrive the default label for management traffic:" + "zone: " + dcId + - " hypervisor: " + hypervisorType + " due to:" + ex.getMessage()); - } - } - return null; - } - - private PhysicalNetwork getOnePhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - List networkList = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); - - if (networkList.isEmpty()) { - throw new InvalidParameterValueException("Unable to find the default physical network with traffic=" - + trafficType + " in zone id=" + zoneId + ". "); - } - - if (networkList.size() > 1) { - s_logger.info("More than one physical networks exist in zone id=" + zoneId + " with traffic type=" - + trafficType + ". "); - } - - return networkList.get(0); - } - - @Override - public List listNetworksByVpc(long vpcId) { - return _networksDao.listByVpc(vpcId); - } - - @Override - public String getDefaultNetworkDomain() { - return _networkDomain; - } - - @Override - public List getNtwkOffDistinctProviders(long ntkwOffId) { - List providerNames = _ntwkOfferingSrvcDao.getDistinctProviders(ntkwOffId); - List providers = new ArrayList(); - for (String providerName : providerNames) { - providers.add(Network.Provider.getProvider(providerName)); - } - - return providers; - } - - @Override - public boolean isVmPartOfNetwork(long vmId, long ntwkId) { - if (_nicDao.findNonReleasedByInstanceIdAndNetworkId(ntwkId, vmId) != null) { - return true; - } - return false; - } - - @Override - @ActionEvent(eventType = EventTypes.EVENT_NET_IP_ASSIGN, eventDescription = "associating Ip", async = true) - public IpAddress associateIPToNetwork(long ipId, long networkId) throws InsufficientAddressCapacityException, - ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException { - - Network network = _networksDao.findById(networkId); - if (network == null) { - throw new InvalidParameterValueException("Invalid network id is given"); - } - - if (network.getVpcId() != null) { - throw new InvalidParameterValueException("Can't assign ip to the network directly when network belongs" + - " to VPC.Specify vpcId to associate ip address to VPC"); - } - return associateIPToGuestNetwork(ipId, networkId, true); - - } - - - @Override @DB - public Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, - String vlan, String startIp, String endIp, String gateway, String netmask, long networkOwnerId, Long vpcId) - throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { - - Account owner = _accountMgr.getAccount(networkOwnerId); - - // Get system network offeirng - NetworkOfferingVO ntwkOff = _systemNetworks.get(NetworkOffering.SystemPrivateGatewayNetworkOffering); - - // Validate physical network - PhysicalNetwork pNtwk = _physicalNetworkDao.findById(physicalNetworkId); - if (pNtwk == null) { - InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find a physical network" + - " having the given id"); - ex.addProxyObject("physical_network", physicalNetworkId, "physicalNetworkId"); - throw ex; - } - - // VALIDATE IP INFO - // if end ip is not specified, default it to startIp - if (!NetUtils.isValidIp(startIp)) { - throw new InvalidParameterValueException("Invalid format for the startIp parameter"); - } - if (endIp == null) { - endIp = startIp; - } else if (!NetUtils.isValidIp(endIp)) { - throw new InvalidParameterValueException("Invalid format for the endIp parameter"); - } - - String cidr = null; - if (!NetUtils.isValidIp(gateway)) { - throw new InvalidParameterValueException("Invalid gateway"); - } - if (!NetUtils.isValidNetmask(netmask)) { - throw new InvalidParameterValueException("Invalid netmask"); - } - - cidr = NetUtils.ipAndNetMaskToCidr(gateway, netmask); - - - Transaction txn = Transaction.currentTxn(); - txn.start(); - - //lock datacenter as we need to get mac address seq from there - DataCenterVO dc = _dcDao.lockRow(pNtwk.getDataCenterId(), true); - - //check if we need to create guest network - Network privateNetwork = _networksDao.getPrivateNetwork(BroadcastDomainType.Vlan.toUri(vlan).toString(), cidr, - networkOwnerId, pNtwk.getDataCenterId()); - if (privateNetwork == null) { - //create Guest network - privateNetwork = createGuestNetwork(ntwkOff.getId(), networkName, displayText, gateway, cidr, vlan, - null, owner, null, pNtwk, pNtwk.getDataCenterId(), ACLType.Account, null, null); - s_logger.debug("Created private network " + privateNetwork); - } else { - s_logger.debug("Private network already exists: " + privateNetwork); - } - - //add entry to private_ip_address table - PrivateIpVO privateIp = _privateIpDao.findByIpAndSourceNetworkId(privateNetwork.getId(), startIp); - if (privateIp != null) { - throw new InvalidParameterValueException("Private ip address " + startIp + " already used for private gateway" + - " in zone " + _configMgr.getZone(pNtwk.getDataCenterId()).getName()); - } - - Long mac = dc.getMacAddress(); - Long nextMac = mac + 1; - dc.setMacAddress(nextMac); - - privateIp = new PrivateIpVO(startIp, privateNetwork.getId(), nextMac, vpcId); - _privateIpDao.persist(privateIp); - - _dcDao.update(dc.getId(), dc); - - txn.commit(); - s_logger.debug("Private network " + privateNetwork + " is created"); - - return privateNetwork; - } - + @Override public boolean setupDns(Network network, Provider provider) { - boolean dnsProvided = isProviderSupportServiceInNetwork(network.getId(), Service.Dns, provider ); - boolean dhcpProvided =isProviderSupportServiceInNetwork(network.getId(), Service.Dhcp, + boolean dnsProvided = _networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.Dns, provider ); + boolean dhcpProvided =_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.Dhcp, provider); boolean setupDns = dnsProvided || dhcpProvided; return setupDns; } - - - @Override - public List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType) { - - List pNtwks = _physicalNetworkDao.listByZone(zoneId); - - Iterator it = pNtwks.iterator(); - while (it.hasNext()) { - PhysicalNetwork pNtwk = it.next(); - if (!_pNTrafficTypeDao.isTrafficTypeSupported(pNtwk.getId(), trafficType)) { - it.remove(); - } - } - return pNtwks; - } - - @Override - public boolean isPrivateGateway(Nic guestNic) { - Network network = getNetwork(guestNic.getNetworkId()); - if (network.getTrafficType() != TrafficType.Guest || network.getNetworkOfferingId() != _privateOfferingId.longValue()) { - return false; - } - return true; - } - - @Override - public NicProfile createNicForVm(Network network, NicProfile requested, ReservationContext context, - VirtualMachineProfileImpl vmProfile, boolean prepare) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, - ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { - - VirtualMachine vm = vmProfile.getVirtualMachine(); - NetworkVO networkVO = _networksDao.findById(network.getId()); - DataCenter dc = _configMgr.getZone(network.getDataCenterId()); - Host host = _hostDao.findById(vm.getHostId()); - DeployDestination dest = new DeployDestination(dc, null, null, host); - - NicProfile nic = getNicProfileForVm(network, requested, vm); - - //1) allocate nic (if needed) - if (nic == null) { - int deviceId = _nicDao.countNics(vm.getId()); - - nic = allocateNic(requested, network, false, - deviceId, vmProfile).first(); - - if (nic == null) { - throw new CloudRuntimeException("Failed to allocate nic for vm " + vm + " in network " + network); - } - - s_logger.debug("Nic is allocated successfully for vm " + vm + " in network " + network); - } - - //2) prepare nic - if (prepare) { - nic = prepareNic(vmProfile, dest, context, nic.getId(), networkVO); - s_logger.debug("Nic is prepared successfully for vm " + vm + " in network " + network); - } - - return nic; - } - - private NicProfile getNicProfileForVm(Network network, NicProfile requested, VirtualMachine vm) { + + + protected NicProfile getNicProfileForVm(Network network, NicProfile requested, VirtualMachine vm) { NicProfile nic = null; if (requested != null && requested.getBroadCastUri() != null) { String broadcastUri = requested.getBroadCastUri().toString(); @@ -7328,17 +3342,72 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag NicVO nicVO = _nicDao.findByNetworkIdInstanceIdAndBroadcastUri(network.getId(), vm.getId(), broadcastUri); if (nicVO != null) { if (ipAddress == null || nicVO.getIp4Address().equals(ipAddress)) { - nic = getNicProfile(vm, network.getId(), broadcastUri); + nic = _networkModel.getNicProfile(vm, network.getId(), broadcastUri); } } } else { NicVO nicVO = _nicDao.findByInstanceIdAndNetworkId(network.getId(), vm.getId()); if (nicVO != null) { - nic = getNicProfile(vm, network.getId(), null); + nic = _networkModel.getNicProfile(vm, network.getId(), null); } } return nic; } + + @Override + public NicProfile createNicForVm(Network network, NicProfile requested, ReservationContext context, VirtualMachineProfileImpl vmProfile, boolean prepare) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { + + VirtualMachine vm = vmProfile.getVirtualMachine(); + NetworkVO networkVO = _networksDao.findById(network.getId()); + DataCenter dc = _configMgr.getZone(network.getDataCenterId()); + Host host = _hostDao.findById(vm.getHostId()); + DeployDestination dest = new DeployDestination(dc, null, null, host); + + NicProfile nic = getNicProfileForVm(network, requested, vm); + + //1) allocate nic (if needed) + if (nic == null) { + int deviceId = _nicDao.countNics(vm.getId()); + + nic = allocateNic(requested, network, false, + deviceId, vmProfile).first(); + + if (nic == null) { + throw new CloudRuntimeException("Failed to allocate nic for vm " + vm + " in network " + network); + } + + s_logger.debug("Nic is allocated successfully for vm " + vm + " in network " + network); + } + + //2) prepare nic + if (prepare) { + nic = prepareNic(vmProfile, dest, context, nic.getId(), networkVO); + s_logger.debug("Nic is prepared successfully for vm " + vm + " in network " + network); + } + + return nic; + } + @Override + public List getNicProfiles(VirtualMachine vm) { + List nics = _nicDao.listByVmId(vm.getId()); + List profiles = new ArrayList(); + + if (nics != null) { + for (Nic nic : nics) { + NetworkVO network = _networksDao.findById(nic.getNetworkId()); + Integer networkRate = _networkModel.getNetworkRate(network.getId(), vm.getId()); + + NetworkGuru guru = _networkGurus.get(network.getGuruName()); + NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), + networkRate, _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(vm.getHypervisorType(), network)); + guru.updateNicProfile(profile, network); + profiles.add(profile); + } + } + return profiles; + } @Override @@ -7346,6 +3415,20 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag return _networkLockTimeout; } + private Map> getServiceProvidersMap(long networkId) { + Map> map = new HashMap>(); + List nsms = _ntwkSrvcDao.getServicesInNetwork(networkId); + for (NetworkServiceMapVO nsm : nsms) { + Set providers = map.get(Service.getService(nsm.getService())); + if (providers == null) { + providers = new HashSet(); + } + providers.add(Provider.getProvider(nsm.getProvider())); + map.put(Service.getService(nsm.getService()), providers); + } + return map; + } + @Override public List getProvidersForServiceInNetwork(Network network, Service service) { Map> service2ProviderMap = getServiceProvidersMap(network.getId()); @@ -7367,7 +3450,7 @@ public class NetworkManagerImpl implements NetworkManager, NetworkService, Manag s_logger.error("Found " + providers.size() + " " + service.getName() + " providers for network!" + network.getId()); return null; } - NetworkElement element = getElementImplementingProvider(providers.get(0).getName()); + NetworkElement element = _networkModel.getElementImplementingProvider(providers.get(0).getName()); s_logger.info("Let " + element.getName() + " handle " + service.getName() + " in network " + network.getId()); return element; } diff --git a/server/src/com/cloud/network/NetworkModelImpl.java b/server/src/com/cloud/network/NetworkModelImpl.java new file mode 100644 index 00000000000..a99e9c50cbe --- /dev/null +++ b/server/src/com/cloud/network/NetworkModelImpl.java @@ -0,0 +1,1839 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + +import java.security.InvalidParameterException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.log4j.Logger; + +import com.cloud.configuration.Config; +import com.cloud.configuration.ConfigurationManager; +import com.cloud.configuration.dao.ConfigurationDao; +import com.cloud.dc.PodVlanMapVO; +import com.cloud.dc.Vlan.VlanType; +import com.cloud.dc.VlanVO; +import com.cloud.dc.dao.DataCenterDao; +import com.cloud.dc.dao.PodVlanMapDao; +import com.cloud.dc.dao.VlanDao; +import com.cloud.domain.DomainVO; +import com.cloud.domain.dao.DomainDao; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.exception.InvalidParameterValueException; +import com.cloud.exception.PermissionDeniedException; +import com.cloud.exception.UnsupportedServiceException; +import com.cloud.hypervisor.Hypervisor.HypervisorType; +import com.cloud.network.IpAddress.State; +import com.cloud.network.Network.Capability; +import com.cloud.network.Network.GuestType; +import com.cloud.network.Network.Provider; +import com.cloud.network.Network.Service; +import com.cloud.network.Networks.TrafficType; +import com.cloud.network.addr.PublicIp; +import com.cloud.network.dao.FirewallRulesDao; +import com.cloud.network.dao.IPAddressDao; +import com.cloud.network.dao.NetworkDao; +import com.cloud.network.dao.NetworkDomainDao; +import com.cloud.network.dao.NetworkServiceMapDao; +import com.cloud.network.dao.PhysicalNetworkDao; +import com.cloud.network.dao.PhysicalNetworkServiceProviderDao; +import com.cloud.network.dao.PhysicalNetworkServiceProviderVO; +import com.cloud.network.dao.PhysicalNetworkTrafficTypeDao; +import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.UserDataServiceProvider; +import com.cloud.network.rules.FirewallRule.Purpose; +import com.cloud.network.rules.FirewallRuleVO; +import com.cloud.network.rules.dao.PortForwardingRulesDao; +import com.cloud.network.vpc.dao.PrivateIpDao; +import com.cloud.offering.NetworkOffering; +import com.cloud.offerings.NetworkOfferingServiceMapVO; +import com.cloud.offerings.NetworkOfferingVO; +import com.cloud.offerings.dao.NetworkOfferingDao; +import com.cloud.offerings.dao.NetworkOfferingServiceMapDao; +import com.cloud.user.Account; +import com.cloud.user.DomainManager; +import com.cloud.user.dao.AccountDao; +import com.cloud.utils.component.Adapters; +import com.cloud.utils.component.Inject; +import com.cloud.utils.component.Manager; +import com.cloud.utils.db.DB; +import com.cloud.utils.db.JoinBuilder; +import com.cloud.utils.db.JoinBuilder.JoinType; +import com.cloud.utils.db.SearchBuilder; +import com.cloud.utils.db.SearchCriteria; +import com.cloud.utils.db.SearchCriteria.Op; +import com.cloud.utils.exception.CloudRuntimeException; +import com.cloud.utils.net.NetUtils; +import com.cloud.vm.Nic; +import com.cloud.vm.NicProfile; +import com.cloud.vm.NicVO; +import com.cloud.vm.VMInstanceVO; +import com.cloud.vm.VirtualMachine; +import com.cloud.vm.VirtualMachine.Type; +import com.cloud.vm.dao.NicDao; +import com.cloud.vm.dao.VMInstanceDao; + +@Local(value = { NetworkModel.class}) +public class NetworkModelImpl implements NetworkModel, Manager{ + static final Logger s_logger = Logger.getLogger(NetworkModelImpl.class); + + String _name; + @Inject + DataCenterDao _dcDao = null; + @Inject + VlanDao _vlanDao = null; + @Inject + IPAddressDao _ipAddressDao = null; + @Inject + AccountDao _accountDao = null; + @Inject + DomainDao _domainDao = null; + @Inject + ConfigurationDao _configDao; + + @Inject + ConfigurationManager _configMgr; + + @Inject + NetworkOfferingDao _networkOfferingDao = null; + @Inject + NetworkDao _networksDao = null; + @Inject + NicDao _nicDao = null; + + @Inject + PodVlanMapDao _podVlanMapDao; + + @Inject(adapter = NetworkElement.class) + Adapters _networkElements; + + @Inject + NetworkDomainDao _networkDomainDao; + @Inject + VMInstanceDao _vmDao; + + @Inject + FirewallRulesDao _firewallDao; + @Inject + DomainManager _domainMgr; + + @Inject + NetworkOfferingServiceMapDao _ntwkOfferingSrvcDao; + @Inject + PhysicalNetworkDao _physicalNetworkDao; + @Inject + PhysicalNetworkServiceProviderDao _pNSPDao; + @Inject + PortForwardingRulesDao _portForwardingRulesDao; + @Inject + PhysicalNetworkTrafficTypeDao _pNTrafficTypeDao; + @Inject + NetworkServiceMapDao _ntwkSrvcDao; + @Inject + PrivateIpDao _privateIpDao; + + + + private final HashMap _systemNetworks = new HashMap(5); + static Long _privateOfferingId = null; + + + SearchBuilder IpAddressSearch; + SearchBuilder NicForTrafficTypeSearch; + + + private String _networkDomain; + private boolean _allowSubdomainNetworkAccess; + + private Map _configs; + + HashMap _lastNetworkIdsToFree = new HashMap(); + + static HashMap> s_serviceToImplementedProvidersMap = new HashMap>(); + static HashMap s_providerToNetworkElementMap = new HashMap(); + /** + * + */ + public NetworkModelImpl() { + super(); + } + + @Override + public NetworkElement getElementImplementingProvider(String providerName) { + String elementName = s_providerToNetworkElementMap.get(providerName); + NetworkElement element = _networkElements.get(elementName); + return element; + } + + @Override + public List getElementServices(Provider provider) { + NetworkElement element = getElementImplementingProvider(provider.getName()); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'"); + } + return new ArrayList(element.getCapabilities().keySet()); + } + + @Override + public boolean canElementEnableIndividualServices(Provider provider) { + NetworkElement element = getElementImplementingProvider(provider.getName()); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'"); + } + return element.canEnableIndividualServices(); + } + + Set getPublicIpPurposeInRules(PublicIpAddress ip, boolean includeRevoked, boolean includingFirewall) { + Set result = new HashSet(); + List rules = null; + if (includeRevoked) { + rules = _firewallDao.listByIp(ip.getId()); + } else { + rules = _firewallDao.listByIpAndNotRevoked(ip.getId()); + } + + if (rules == null || rules.isEmpty()) { + return null; + } + + for (FirewallRuleVO rule : rules) { + if (rule.getPurpose() != Purpose.Firewall || includingFirewall) { + result.add(rule.getPurpose()); + } + } + + return result; + } + + @Override + public Map> getIpToServices(List publicIps, boolean rulesRevoked, boolean includingFirewall) { + Map> ipToServices = new HashMap>(); + + if (publicIps != null && !publicIps.isEmpty()) { + Set networkSNAT = new HashSet(); + for (PublicIpAddress ip : publicIps) { + Set services = ipToServices.get(ip); + if (services == null) { + services = new HashSet(); + } + if (ip.isSourceNat()) { + if (!networkSNAT.contains(ip.getAssociatedWithNetworkId())) { + services.add(Service.SourceNat); + networkSNAT.add(ip.getAssociatedWithNetworkId()); + } else { + CloudRuntimeException ex = new CloudRuntimeException("Multiple generic soure NAT IPs provided for network"); + // see the IPAddressVO.java class. + ex.addProxyObject("user_ip_address", ip.getAssociatedWithNetworkId(), "networkId"); + throw ex; + } + } + ipToServices.put(ip, services); + + // if IP in allocating state then it will not have any rules attached so skip IPAssoc to network service + // provider + if (ip.getState() == State.Allocating) { + continue; + } + + // check if any active rules are applied on the public IP + Set purposes = getPublicIpPurposeInRules(ip, false, includingFirewall); + // Firewall rules didn't cover static NAT + if (ip.isOneToOneNat() && ip.getAssociatedWithVmId() != null) { + if (purposes == null) { + purposes = new HashSet(); + } + purposes.add(Purpose.StaticNat); + } + if (purposes == null || purposes.isEmpty()) { + // since no active rules are there check if any rules are applied on the public IP but are in + // revoking state + + purposes = getPublicIpPurposeInRules(ip, true, includingFirewall); + if (ip.isOneToOneNat()) { + if (purposes == null) { + purposes = new HashSet(); + } + purposes.add(Purpose.StaticNat); + } + if (purposes == null || purposes.isEmpty()) { + // IP is not being used for any purpose so skip IPAssoc to network service provider + continue; + } else { + if (rulesRevoked) { + // no active rules/revoked rules are associated with this public IP, so remove the + // association with the provider + ip.setState(State.Releasing); + } else { + if (ip.getState() == State.Releasing) { + // rules are not revoked yet, so don't let the network service provider revoke the IP + // association + // mark IP is allocated so that IP association will not be removed from the provider + ip.setState(State.Allocated); + } + } + } + } + if (purposes.contains(Purpose.StaticNat)) { + services.add(Service.StaticNat); + } + if (purposes.contains(Purpose.LoadBalancing)) { + services.add(Service.Lb); + } + if (purposes.contains(Purpose.PortForwarding)) { + services.add(Service.PortForwarding); + } + if (purposes.contains(Purpose.Vpn)) { + services.add(Service.Vpn); + } + if (purposes.contains(Purpose.Firewall)) { + services.add(Service.Firewall); + } + if (services.isEmpty()) { + continue; + } + ipToServices.put(ip, services); + } + } + return ipToServices; + } + + public boolean canIpUsedForNonConserveService(PublicIp ip, Service service) { + // If it's non-conserve mode, then the new ip should not be used by any other services + List ipList = new ArrayList(); + ipList.add(ip); + Map> ipToServices = getIpToServices(ipList, false, false); + Set services = ipToServices.get(ip); + // Not used currently, safe + if (services == null || services.isEmpty()) { + return true; + } + // Since it's non-conserve mode, only one service should used for IP + if (services.size() != 1) { + throw new InvalidParameterException("There are multiple services used ip " + ip.getAddress() + "."); + } + if (service != null && !((Service) services.toArray()[0] == service || service.equals(Service.Firewall))) { + throw new InvalidParameterException("The IP " + ip.getAddress() + " is already used as " + ((Service) services.toArray()[0]).getName() + " rather than " + service.getName()); + } + return true; + } + + Map> getServiceProvidersMap(long networkId) { + Map> map = new HashMap>(); + List nsms = _ntwkSrvcDao.getServicesInNetwork(networkId); + for (NetworkServiceMapVO nsm : nsms) { + Set providers = map.get(Service.getService(nsm.getService())); + if (providers == null) { + providers = new HashSet(); + } + providers.add(Provider.getProvider(nsm.getProvider())); + map.put(Service.getService(nsm.getService()), providers); + } + return map; + } + + public boolean canIpUsedForService(PublicIp publicIp, Service service, Long networkId) { + List ipList = new ArrayList(); + ipList.add(publicIp); + Map> ipToServices = getIpToServices(ipList, false, true); + Set services = ipToServices.get(publicIp); + if (services == null || services.isEmpty()) { + return true; + } + + if (networkId == null) { + networkId = publicIp.getAssociatedWithNetworkId(); + } + + // We only support one provider for one service now + Map> serviceToProviders = getServiceProvidersMap(networkId); + Set oldProviders = serviceToProviders.get(services.toArray()[0]); + Provider oldProvider = (Provider) oldProviders.toArray()[0]; + // Since IP already has service to bind with, the oldProvider can't be null + Set newProviders = serviceToProviders.get(service); + if (newProviders == null || newProviders.isEmpty()) { + throw new InvalidParameterException("There is no new provider for IP " + publicIp.getAddress() + " of service " + service.getName() + "!"); + } + Provider newProvider = (Provider) newProviders.toArray()[0]; + if (!oldProvider.equals(newProvider)) { + throw new InvalidParameterException("There would be multiple providers for IP " + publicIp.getAddress() + "!"); + } + return true; + } + + Map> getProviderServicesMap(long networkId) { + Map> map = new HashMap>(); + List nsms = _ntwkSrvcDao.getServicesInNetwork(networkId); + for (NetworkServiceMapVO nsm : nsms) { + Set services = map.get(Provider.getProvider(nsm.getProvider())); + if (services == null) { + services = new HashSet(); + } + services.add(Service.getService(nsm.getService())); + map.put(Provider.getProvider(nsm.getProvider()), services); + } + return map; + } + + @Override + public Map> getProviderToIpList(Network network, Map> ipToServices) { + NetworkOffering offering = _networkOfferingDao.findById(network.getNetworkOfferingId()); + if (!offering.isConserveMode()) { + for (PublicIpAddress ip : ipToServices.keySet()) { + Set services = new HashSet() ; + services.addAll(ipToServices.get(ip)); + if (services != null && services.contains(Service.Firewall)) { + services.remove(Service.Firewall); + } + if (services != null && services.size() > 1) { + throw new CloudRuntimeException("Ip " + ip.getAddress() + " is used by multiple services!"); + } + } + } + Map> serviceToIps = new HashMap>(); + for (PublicIpAddress ip : ipToServices.keySet()) { + for (Service service : ipToServices.get(ip)) { + Set ips = serviceToIps.get(service); + if (ips == null) { + ips = new HashSet(); + } + ips.add(ip); + serviceToIps.put(service, ips); + } + } + // TODO Check different provider for same IP + Map> providerToServices = getProviderServicesMap(network.getId()); + Map> providerToIpList = new HashMap>(); + for (Provider provider : providerToServices.keySet()) { + Set services = providerToServices.get(provider); + ArrayList ipList = new ArrayList(); + Set ipSet = new HashSet(); + for (Service service : services) { + Set serviceIps = serviceToIps.get(service); + if (serviceIps == null || serviceIps.isEmpty()) { + continue; + } + ipSet.addAll(serviceIps); + } + Set sourceNatIps = serviceToIps.get(Service.SourceNat); + if (sourceNatIps != null && !sourceNatIps.isEmpty()) { + ipList.addAll(0, sourceNatIps); + ipSet.removeAll(sourceNatIps); + } + ipList.addAll(ipSet); + providerToIpList.put(provider, ipList); + } + return providerToIpList; + } + + + + @Override + public List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat) { + SearchCriteria sc = IpAddressSearch.create(); + sc.setParameters("accountId", accountId); + sc.setParameters("associatedWithNetworkId", associatedNetworkId); + + if (sourceNat != null) { + sc.addAnd("sourceNat", SearchCriteria.Op.EQ, sourceNat); + } + sc.setJoinParameters("virtualNetworkVlanSB", "vlanType", VlanType.VirtualNetwork); + + return _ipAddressDao.search(sc, null); + } + + @Override + public List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat) { + SearchCriteria sc = IpAddressSearch.create(); + sc.setParameters("accountId", accountId); + sc.setParameters("dataCenterId", dcId); + + if (sourceNat != null) { + sc.addAnd("sourceNat", SearchCriteria.Op.EQ, sourceNat); + } + sc.setJoinParameters("virtualNetworkVlanSB", "vlanType", VlanType.VirtualNetwork); + + return _ipAddressDao.search(sc, null); + } + + @Override + public List getNics(long vmId) { + return _nicDao.listByVmId(vmId); + } + + + + @Override + public String getNextAvailableMacAddressInNetwork(long networkId) throws InsufficientAddressCapacityException { + String mac = _networksDao.getNextAvailableMacAddress(networkId); + if (mac == null) { + throw new InsufficientAddressCapacityException("Unable to create another mac address", Network.class, networkId); + } + return mac; + } + + @Override + @DB + public Network getNetwork(long id) { + return _networksDao.findById(id); + } + + @Override + public boolean canUseForDeploy(Network network) { + if (network.getTrafficType() != TrafficType.Guest) { + return false; + } + boolean hasFreeIps = true; + if (network.getGuestType() == GuestType.Shared) { + hasFreeIps = _ipAddressDao.countFreeIPsInNetwork(network.getId()) > 0; + } else { + hasFreeIps = (getAvailableIps(network, null)).size() > 0; + } + + return hasFreeIps; + } + + + + @Override + public Map> getNetworkCapabilities(long networkId) { + + Map> networkCapabilities = new HashMap>(); + + // list all services of this networkOffering + List servicesMap = _ntwkSrvcDao.getServicesInNetwork(networkId); + for (NetworkServiceMapVO instance : servicesMap) { + Service service = Service.getService(instance.getService()); + NetworkElement element = getElementImplementingProvider(instance.getProvider()); + if (element != null) { + Map> elementCapabilities = element.getCapabilities(); + ; + if (elementCapabilities != null) { + networkCapabilities.put(service, elementCapabilities.get(service)); + } + } + } + + return networkCapabilities; + } + + @Override + public Map getNetworkServiceCapabilities(long networkId, Service service) { + + if (!areServicesSupportedInNetwork(networkId, service)) { + // TBD: networkId to uuid. No VO object being passed. So we will need to call + // addProxyObject with hardcoded tablename. Or we should probably look up the correct dao proxy object. + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported in the network id=" + networkId); + } + + Map serviceCapabilities = new HashMap(); + + // get the Provider for this Service for this offering + String provider = _ntwkSrvcDao.getProviderForServiceInNetwork(networkId, service); + + NetworkElement element = getElementImplementingProvider(provider); + if (element != null) { + Map> elementCapabilities = element.getCapabilities(); + ; + + if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider); + } + serviceCapabilities = elementCapabilities.get(service); + } + + return serviceCapabilities; + } + + @Override + public Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) { + + if (!areServicesSupportedByNetworkOffering(offering.getId(), service)) { + // TBD: We should be sending networkOfferingId and not the offering object itself. + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the network offering " + offering); + } + + Map serviceCapabilities = new HashMap(); + + // get the Provider for this Service for this offering + List providers = _ntwkOfferingSrvcDao.listProvidersForServiceForNetworkOffering(offering.getId(), service); + if (providers.isEmpty()) { + // TBD: We should be sending networkOfferingId and not the offering object itself. + throw new InvalidParameterValueException("Service " + service.getName() + " is not supported by the network offering " + offering); + } + + // FIXME - in post 3.0 we are going to support multiple providers for the same service per network offering, so + // we have to calculate capabilities for all of them + String provider = providers.get(0); + + // FIXME we return the capabilities of the first provider of the service - what if we have multiple providers + // for same Service? + NetworkElement element = getElementImplementingProvider(provider); + if (element != null) { + Map> elementCapabilities = element.getCapabilities(); + ; + + if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { + // TBD: We should be sending providerId and not the offering object itself. + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider); + } + serviceCapabilities = elementCapabilities.get(service); + } + + return serviceCapabilities; + } + + @Override + public NetworkVO getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { + // find system public network offering + Long networkOfferingId = null; + List offerings = _networkOfferingDao.listSystemNetworkOfferings(); + for (NetworkOfferingVO offering : offerings) { + if (offering.getTrafficType() == trafficType) { + networkOfferingId = offering.getId(); + break; + } + } + + if (networkOfferingId == null) { + throw new InvalidParameterValueException("Unable to find system network offering with traffic type " + trafficType); + } + + List networks = _networksDao.listBy(Account.ACCOUNT_ID_SYSTEM, networkOfferingId, zoneId); + if (networks == null || networks.isEmpty()) { + // TBD: send uuid instead of zoneId. Hardcode tablename in call to addProxyObject(). + throw new InvalidParameterValueException("Unable to find network with traffic type " + trafficType + " in zone " + zoneId); + } + return networks.get(0); + } + + @Override + public NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId) { + List networks = _networksDao.listByZoneSecurityGroup(zoneId); + if (networks == null || networks.isEmpty()) { + return null; + } + + if (networks.size() > 1) { + s_logger.debug("There are multiple network with security group enabled? select one of them..."); + } + return networks.get(0); + } + + @Override + public PublicIpAddress getPublicIpAddress(long ipAddressId) { + IPAddressVO addr = _ipAddressDao.findById(ipAddressId); + if (addr == null) { + return null; + } + + return new PublicIp(addr, _vlanDao.findById(addr.getVlanId()), NetUtils.createSequenceBasedMacAddress(addr.getMacAddress())); + } + + @Override + public List listPodVlans(long podId) { + List vlans = _vlanDao.listVlansForPodByType(podId, VlanType.DirectAttached); + return vlans; + } + + @Override + public List listNetworksUsedByVm(long vmId, boolean isSystem) { + List networks = new ArrayList(); + + List nics = _nicDao.listByVmId(vmId); + if (nics != null) { + for (Nic nic : nics) { + NetworkVO network = _networksDao.findByIdIncludingRemoved(nic.getNetworkId()); + + if (isNetworkSystem(network) == isSystem) { + networks.add(network); + } + } + } + + return networks; + } + + @Override + public Nic getNicInNetwork(long vmId, long networkId) { + return _nicDao.findByInstanceIdAndNetworkId(networkId, vmId); + } + + @Override + public String getIpInNetwork(long vmId, long networkId) { + Nic guestNic = getNicInNetwork(vmId, networkId); + assert (guestNic != null && guestNic.getIp4Address() != null) : "Vm doesn't belong to network associated with " + + "ipAddress or ip4 address is null"; + return guestNic.getIp4Address(); + } + + @Override + public String getIpInNetworkIncludingRemoved(long vmId, long networkId) { + Nic guestNic = getNicInNetworkIncludingRemoved(vmId, networkId); + assert (guestNic != null && guestNic.getIp4Address() != null) : "Vm doesn't belong to network associated with " + + "ipAddress or ip4 address is null"; + return guestNic.getIp4Address(); + } + + @Override + public List getNicsForTraffic(long vmId, TrafficType type) { + SearchCriteria sc = NicForTrafficTypeSearch.create(); + sc.setParameters("instance", vmId); + sc.setJoinParameters("network", "traffictype", type); + + return _nicDao.search(sc, null); + } + + @Override + public IpAddress getIp(long ipAddressId) { + return _ipAddressDao.findById(ipAddressId); + } + + @Override + public Network getDefaultNetworkForVm(long vmId) { + Nic defaultNic = getDefaultNic(vmId); + if (defaultNic == null) { + return null; + } else { + return _networksDao.findById(defaultNic.getNetworkId()); + } + } + + @Override + public Nic getDefaultNic(long vmId) { + List nics = _nicDao.listByVmId(vmId); + Nic defaultNic = null; + if (nics != null) { + for (Nic nic : nics) { + if (nic.isDefaultNic()) { + defaultNic = nic; + break; + } + } + } else { + s_logger.debug("Unable to find default network for the vm; vm doesn't have any nics"); + return null; + } + + if (defaultNic == null) { + s_logger.debug("Unable to find default network for the vm; vm doesn't have default nic"); + } + + return defaultNic; + + } + + @Override + public UserDataServiceProvider getUserDataUpdateProvider(Network network) { + String userDataProvider = _ntwkSrvcDao.getProviderForServiceInNetwork(network.getId(), Service.UserData); + + if (userDataProvider == null) { + s_logger.debug("Network " + network + " doesn't support service " + Service.UserData.getName()); + return null; + } + + return (UserDataServiceProvider)getElementImplementingProvider(userDataProvider); + } + + @Override + public boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) { + return (_ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(networkOfferingId, services)); + } + + @Override + public boolean areServicesSupportedInNetwork(long networkId, Service... services) { + return (_ntwkSrvcDao.areServicesSupportedInNetwork(networkId, services)); + } + + @Override + public String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId) { + + List virtualNetworks = _networksDao.listByZoneAndGuestType(accountId, dataCenterId, Network.GuestType.Isolated, false); + + if (virtualNetworks.isEmpty()) { + s_logger.trace("Unable to find default Virtual network account id=" + accountId); + return null; + } + + NetworkVO virtualNetwork = virtualNetworks.get(0); + + NicVO networkElementNic = _nicDao.findByNetworkIdAndType(virtualNetwork.getId(), Type.DomainRouter); + + if (networkElementNic != null) { + return networkElementNic.getIp4Address(); + } else { + s_logger.warn("Unable to set find network element for the network id=" + virtualNetwork.getId()); + return null; + } + } + + @Override + public List listNetworksForAccount(long accountId, long zoneId, Network.GuestType type) { + List accountNetworks = new ArrayList(); + List zoneNetworks = _networksDao.listByZone(zoneId); + + for (NetworkVO network : zoneNetworks) { + if (!isNetworkSystem(network)) { + if (network.getGuestType() == Network.GuestType.Shared || !_networksDao.listBy(accountId, network.getId()).isEmpty()) { + if (type == null || type == network.getGuestType()) { + accountNetworks.add(network); + } + } + } + } + return accountNetworks; + } + + @Override + public List listAllNetworksInAllZonesByType(Network.GuestType type) { + List networks = new ArrayList(); + for (NetworkVO network: _networksDao.listAll()) { + if (!isNetworkSystem(network)) { + networks.add(network); + } + } + return networks; + } + + @Override + public Long getDedicatedNetworkDomain(long networkId) { + NetworkDomainVO networkMaps = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId); + if (networkMaps != null) { + return networkMaps.getDomainId(); + } else { + return null; + } + } + + @Override + public Integer getNetworkRate(long networkId, Long vmId) { + VMInstanceVO vm = null; + if (vmId != null) { + vm = _vmDao.findById(vmId); + } + Network network = getNetwork(networkId); + NetworkOffering ntwkOff = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); + + // For default userVm Default network and domR guest/public network, get rate information from the service + // offering; for other situations get information + // from the network offering + boolean isUserVmsDefaultNetwork = false; + boolean isDomRGuestOrPublicNetwork = false; + if (vm != null) { + Nic nic = _nicDao.findByInstanceIdAndNetworkId(networkId, vmId); + if (vm.getType() == Type.User && nic != null && nic.isDefaultNic()) { + isUserVmsDefaultNetwork = true; + } else if (vm.getType() == Type.DomainRouter && ntwkOff != null && (ntwkOff.getTrafficType() == TrafficType.Public || ntwkOff.getTrafficType() == TrafficType.Guest)) { + isDomRGuestOrPublicNetwork = true; + } + } + if (isUserVmsDefaultNetwork || isDomRGuestOrPublicNetwork) { + return _configMgr.getServiceOfferingNetworkRate(vm.getServiceOfferingId()); + } else { + return _configMgr.getNetworkOfferingNetworkRate(ntwkOff.getId()); + } + } + + @Override + public String getAccountNetworkDomain(long accountId, long zoneId) { + String networkDomain = _accountDao.findById(accountId).getNetworkDomain(); + + if (networkDomain == null) { + // get domain level network domain + return getDomainNetworkDomain(_accountDao.findById(accountId).getDomainId(), zoneId); + } + + return networkDomain; + } + + @Override + public String getGlobalGuestDomainSuffix() { + return _networkDomain; + } + + @Override + public String getStartIpAddress(long networkId) { + List vlans = _vlanDao.listVlansByNetworkId(networkId); + if (vlans.isEmpty()) { + return null; + } + + String startIP = vlans.get(0).getIpRange().split("-")[0]; + + for (VlanVO vlan : vlans) { + String startIP1 = vlan.getIpRange().split("-")[0]; + long startIPLong = NetUtils.ip2Long(startIP); + long startIPLong1 = NetUtils.ip2Long(startIP1); + + if (startIPLong1 < startIPLong) { + startIP = startIP1; + } + } + + return startIP; + } + + @Override + public Long getPodIdForVlan(long vlanDbId) { + PodVlanMapVO podVlanMaps = _podVlanMapDao.listPodVlanMapsByVlan(vlanDbId); + if (podVlanMaps == null) { + return null; + } else { + return podVlanMaps.getPodId(); + } + } + + @Override + public Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId) { + Map> serviceProviderMap = new HashMap>(); + List map = _ntwkOfferingSrvcDao.listByNetworkOfferingId(networkOfferingId); + + for (NetworkOfferingServiceMapVO instance : map) { + String service = instance.getService(); + Set providers; + providers = serviceProviderMap.get(service); + if (providers == null) { + providers = new HashSet(); + } + providers.add(Provider.getProvider(instance.getProvider())); + serviceProviderMap.put(Service.getService(service), providers); + } + + return serviceProviderMap; + } + + @Override + public boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider) { + return _ntwkSrvcDao.canProviderSupportServiceInNetwork(networkId, service, provider); + } + + @Override + public List listSupportedNetworkServiceProviders(String serviceName) { + Network.Service service = null; + if (serviceName != null) { + service = Network.Service.getService(serviceName); + if (service == null) { + throw new InvalidParameterValueException("Invalid Network Service=" + serviceName); + } + } + + Set supportedProviders = new HashSet(); + + if (service != null) { + supportedProviders.addAll(s_serviceToImplementedProvidersMap.get(service)); + } else { + for (List pList : s_serviceToImplementedProvidersMap.values()) { + supportedProviders.addAll(pList); + } + } + + return new ArrayList(supportedProviders); + } + + @Override + public Provider getDefaultUniqueProviderForService(String serviceName) { + List providers = listSupportedNetworkServiceProviders(serviceName); + if (providers.isEmpty()) { + throw new CloudRuntimeException("No providers supporting service " + serviceName + " found in cloudStack"); + } + if (providers.size() > 1) { + throw new CloudRuntimeException("More than 1 provider supporting service " + serviceName + " found in cloudStack"); + } + + return providers.get(0); + } + + @Override + public long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType) { + List pNtwks = new ArrayList(); + if (trafficType != null) { + pNtwks = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); + } else { + pNtwks = _physicalNetworkDao.listByZone(zoneId); + } + + if (pNtwks.isEmpty()) { + throw new InvalidParameterValueException("Unable to find physical network in zone id=" + zoneId); + } + + if (pNtwks.size() > 1) { + if (tag == null) { + throw new InvalidParameterValueException("More than one physical networks exist in zone id=" + zoneId + " and no tags are specified in order to make a choice"); + } + + Long pNtwkId = null; + for (PhysicalNetwork pNtwk : pNtwks) { + if (pNtwk.getTags().contains(tag)) { + s_logger.debug("Found physical network id=" + pNtwk.getId() + " based on requested tags " + tag); + pNtwkId = pNtwk.getId(); + break; + } + } + if (pNtwkId == null) { + throw new InvalidParameterValueException("Unable to find physical network which match the tags " + tag); + } + return pNtwkId; + } else { + return pNtwks.get(0).getId(); + } + } + + @Override + public List listNetworkOfferingsForUpgrade(long networkId) { + List offeringsToReturn = new ArrayList(); + NetworkOffering originalOffering = _configMgr.getNetworkOffering(getNetwork(networkId).getNetworkOfferingId()); + + boolean securityGroupSupportedByOriginalOff = areServicesSupportedByNetworkOffering(originalOffering.getId(), Service.SecurityGroup); + + // security group supported property should be the same + + List offerings = _networkOfferingDao.getOfferingIdsToUpgradeFrom(originalOffering); + + for (Long offeringId : offerings) { + if (areServicesSupportedByNetworkOffering(offeringId, Service.SecurityGroup) == securityGroupSupportedByOriginalOff) { + offeringsToReturn.add(offeringId); + } + } + + return offeringsToReturn; + } + + @Override + public boolean isSecurityGroupSupportedInNetwork(Network network) { + if (network.getTrafficType() != TrafficType.Guest) { + s_logger.trace("Security group can be enabled for Guest networks only; and network " + network + " has a diff traffic type"); + return false; + } + + Long physicalNetworkId = network.getPhysicalNetworkId(); + + // physical network id can be null in Guest Network in Basic zone, so locate the physical network + if (physicalNetworkId == null) { + physicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), null, null); + } + + return isServiceEnabledInNetwork(physicalNetworkId, network.getId(), Service.SecurityGroup); + } + + @Override + public PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { + + List networkList = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); + + if (networkList.isEmpty()) { + InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find the default physical network with traffic=" + trafficType + " in the specified zone id"); + // Since we don't have a DataCenterVO object at our disposal, we just set the table name that the zoneId's corresponding uuid is looked up from, manually. + ex.addProxyObject("data_center", zoneId, "zoneId"); + throw ex; + } + + if (networkList.size() > 1) { + InvalidParameterValueException ex = new InvalidParameterValueException("More than one physical networks exist in zone id=" + zoneId + " with traffic type=" + trafficType); + ex.addProxyObject("data_center", zoneId, "zoneId"); + throw ex; + } + + return networkList.get(0); + } + + @Override + public String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType) { + try{ + PhysicalNetwork mgmtPhyNetwork = getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Management); + PhysicalNetworkTrafficTypeVO mgmtTraffic = _pNTrafficTypeDao.findBy(mgmtPhyNetwork.getId(), TrafficType.Management); + if(mgmtTraffic != null){ + String label = null; + switch(hypervisorType){ + case XenServer : label = mgmtTraffic.getXenNetworkLabel(); + break; + case KVM : label = mgmtTraffic.getKvmNetworkLabel(); + break; + case VMware : label = mgmtTraffic.getVmwareNetworkLabel(); + break; + } + return label; + } + }catch(Exception ex){ + if(s_logger.isDebugEnabled()){ + s_logger.debug("Failed to retrive the default label for management traffic:"+"zone: "+ zoneId +" hypervisor: "+hypervisorType +" due to:" + ex.getMessage()); + } + } + return null; + } + + @Override + public String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType) { + try{ + PhysicalNetwork storagePhyNetwork = getDefaultPhysicalNetworkByZoneAndTrafficType(zoneId, TrafficType.Storage); + PhysicalNetworkTrafficTypeVO storageTraffic = _pNTrafficTypeDao.findBy(storagePhyNetwork.getId(), TrafficType.Storage); + if(storageTraffic != null){ + String label = null; + switch(hypervisorType){ + case XenServer : label = storageTraffic.getXenNetworkLabel(); + break; + case KVM : label = storageTraffic.getKvmNetworkLabel(); + break; + case VMware : label = storageTraffic.getVmwareNetworkLabel(); + break; + } + return label; + } + }catch(Exception ex){ + if(s_logger.isDebugEnabled()){ + s_logger.debug("Failed to retrive the default label for storage traffic:"+"zone: "+ zoneId +" hypervisor: "+hypervisorType +" due to:" + ex.getMessage()); + } + } + return null; + } + + @Override + public List getPhysicalNetworkInfo(long dcId, HypervisorType hypervisorType) { + List networkInfoList = new ArrayList(); + List physicalNtwkList = _physicalNetworkDao.listByZone(dcId); + for (PhysicalNetworkVO pNtwk : physicalNtwkList) { + String publicName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Public, hypervisorType); + String privateName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Management, hypervisorType); + String guestName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Guest, hypervisorType); + String storageName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Storage, hypervisorType); + // String controlName = _pNTrafficTypeDao.getNetworkTag(pNtwk.getId(), TrafficType.Control, hypervisorType); + PhysicalNetworkSetupInfo info = new PhysicalNetworkSetupInfo(); + info.setPhysicalNetworkId(pNtwk.getId()); + info.setGuestNetworkName(guestName); + info.setPrivateNetworkName(privateName); + info.setPublicNetworkName(publicName); + info.setStorageNetworkName(storageName); + PhysicalNetworkTrafficTypeVO mgmtTraffic = _pNTrafficTypeDao.findBy(pNtwk.getId(), TrafficType.Management); + if (mgmtTraffic != null) { + String vlan = mgmtTraffic.getVlan(); + info.setMgmtVlan(vlan); + } + networkInfoList.add(info); + } + return networkInfoList; + } + + @Override + public boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName) { + PhysicalNetworkServiceProviderVO ntwkSvcProvider = _pNSPDao.findByServiceProvider(physicalNetowrkId, providerName); + if (ntwkSvcProvider == null) { + s_logger.warn("Unable to find provider " + providerName + " in physical network id=" + physicalNetowrkId); + return false; + } + return isProviderEnabled(ntwkSvcProvider); + } + + @Override + public String getNetworkTag(HypervisorType hType, Network network) { + // no network tag for control traffic type + TrafficType effectiveTrafficType = network.getTrafficType(); + if(hType == HypervisorType.VMware && effectiveTrafficType == TrafficType.Control) + effectiveTrafficType = TrafficType.Management; + + if (effectiveTrafficType == TrafficType.Control) { + return null; + } + + Long physicalNetworkId = null; + if (effectiveTrafficType != TrafficType.Guest) { + physicalNetworkId = getNonGuestNetworkPhysicalNetworkId(network); + } else { + NetworkOffering offering = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); + physicalNetworkId = network.getPhysicalNetworkId(); + if(physicalNetworkId == null){ + physicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), offering.getTags(), offering.getTrafficType()); + } + } + + if (physicalNetworkId == null) { + assert (false) : "Can't get the physical network"; + s_logger.warn("Can't get the physical network"); + return null; + } + + return _pNTrafficTypeDao.getNetworkTag(physicalNetworkId, effectiveTrafficType, hType); + } + + @Override + public NetworkVO getExclusiveGuestNetwork(long zoneId) { + List networks = _networksDao.listBy(Account.ACCOUNT_ID_SYSTEM, zoneId, GuestType.Shared, TrafficType.Guest); + if (networks == null || networks.isEmpty()) { + throw new InvalidParameterValueException("Unable to find network with trafficType " + TrafficType.Guest + " and guestType " + GuestType.Shared + " in zone " + zoneId); + } + + if (networks.size() > 1) { + throw new InvalidParameterValueException("Found more than 1 network with trafficType " + TrafficType.Guest + " and guestType " + GuestType.Shared + " in zone " + zoneId); + + } + + return networks.get(0); + } + + @Override + public boolean isNetworkSystem(Network network) { + NetworkOffering no = _networkOfferingDao.findByIdIncludingRemoved(network.getNetworkOfferingId()); + if (no.isSystemOnly()) { + return true; + } else { + return false; + } + } + + @Override + public Long getPhysicalNetworkId(Network network) { + if (network.getTrafficType() != TrafficType.Guest) { + return getNonGuestNetworkPhysicalNetworkId(network); + } + + Long physicalNetworkId = network.getPhysicalNetworkId(); + NetworkOffering offering = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); + if (physicalNetworkId == null) { + physicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), offering.getTags(), offering.getTrafficType()); + } + return physicalNetworkId; + } + + @Override + public boolean getAllowSubdomainAccessGlobal() { + return _allowSubdomainNetworkAccess; + } + + @Override + public boolean isProviderForNetwork(Provider provider, long networkId) { + if (_ntwkSrvcDao.isProviderForNetwork(networkId, provider) != null) { + return true; + } else { + return false; + } + } + + @Override + public boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId) { + if (_ntwkOfferingSrvcDao.isProviderForNetworkOffering(networkOfferingId, provider)) { + return true; + } else { + return false; + } + } + + @Override + public void canProviderSupportServices(Map> providersMap) { + for (Provider provider : providersMap.keySet()) { + // check if services can be turned off + NetworkElement element = getElementImplementingProvider(provider.getName()); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'"); + } + + Set enabledServices = new HashSet(); + enabledServices.addAll(providersMap.get(provider)); + + if (enabledServices != null && !enabledServices.isEmpty()) { + if (!element.canEnableIndividualServices()) { + Set requiredServices = new HashSet(); + requiredServices.addAll(element.getCapabilities().keySet()); + + if (requiredServices.contains(Network.Service.Gateway)) { + requiredServices.remove(Network.Service.Gateway); + } + + if (requiredServices.contains(Network.Service.Firewall)) { + requiredServices.remove(Network.Service.Firewall); + } + + if (enabledServices.contains(Network.Service.Firewall)) { + enabledServices.remove(Network.Service.Firewall); + } + + // exclude gateway service + if (enabledServices.size() != requiredServices.size()) { + StringBuilder servicesSet = new StringBuilder(); + + for (Service requiredService : requiredServices) { + // skip gateway service as we don't allow setting it via API + if (requiredService == Service.Gateway) { + continue; + } + servicesSet.append(requiredService.getName() + ", "); + } + servicesSet.delete(servicesSet.toString().length() - 2, servicesSet.toString().length()); + + throw new InvalidParameterValueException("Cannot enable subset of Services, Please specify the complete list of Services: " + servicesSet.toString() + " for Service Provider " + + provider.getName()); + } + } + List serviceList = new ArrayList(); + for (Service service : enabledServices) { + // check if the service is provided by this Provider + if (!element.getCapabilities().containsKey(service)) { + throw new UnsupportedServiceException(provider.getName() + " Provider cannot provide service " + service.getName()); + } + serviceList.add(service.getName()); + } + if (!element.verifyServicesCombination(enabledServices)) { + throw new UnsupportedServiceException("Provider " + provider.getName() + " doesn't support services combination: " + serviceList); + } + } + } + } + + @Override + public boolean canAddDefaultSecurityGroup() { + String defaultAdding = _configDao.getValue(Config.SecurityGroupDefaultAdding.key()); + return (defaultAdding != null && defaultAdding.equalsIgnoreCase("true")); + } + + @Override + public List listNetworkOfferingServices(long networkOfferingId) { + List services = new ArrayList(); + List servicesStr = _ntwkOfferingSrvcDao.listServicesForNetworkOffering(networkOfferingId); + for (String serviceStr : servicesStr) { + services.add(Service.getService(serviceStr)); + } + + return services; + } + + @Override + public boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services) { + long physicalNtwkId = findPhysicalNetworkId(zoneId, offering.getTags(), offering.getTrafficType()); + boolean result = true; + List checkedProvider = new ArrayList(); + for (Service service : services) { + // get all the providers, and check if each provider is enabled + List providerNames = _ntwkOfferingSrvcDao.listProvidersForServiceForNetworkOffering(offering.getId(), service); + for (String providerName : providerNames) { + if (!checkedProvider.contains(providerName)) { + result = result && isProviderEnabledInPhysicalNetwork(physicalNtwkId, providerName); + } + } + } + + return result; + } + + @Override + public boolean checkIpForService(IpAddress userIp, Service service, Long networkId) { + if (networkId == null) { + networkId = userIp.getAssociatedWithNetworkId(); + } + + NetworkVO network = _networksDao.findById(networkId); + NetworkOfferingVO offering = _networkOfferingDao.findById(network.getNetworkOfferingId()); + if (offering.getGuestType() != GuestType.Isolated) { + return true; + } + IPAddressVO ipVO = _ipAddressDao.findById(userIp.getId()); + PublicIp publicIp = new PublicIp(ipVO, _vlanDao.findById(userIp.getVlanId()), NetUtils.createSequenceBasedMacAddress(ipVO.getMacAddress())); + if (!canIpUsedForService(publicIp, service, networkId)) { + return false; + } + if (!offering.isConserveMode()) { + return canIpUsedForNonConserveService(publicIp, service); + } + return true; + } + + @Override + public void checkCapabilityForProvider(Set providers, Service service, Capability cap, String capValue) { + for (Provider provider : providers) { + NetworkElement element = getElementImplementingProvider(provider.getName()); + if (element != null) { + Map> elementCapabilities = element.getCapabilities(); + if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider.getName()); + } + Map serviceCapabilities = elementCapabilities.get(service); + if (serviceCapabilities == null || serviceCapabilities.isEmpty()) { + throw new UnsupportedServiceException("Service " + service.getName() + " doesn't have capabilites for element=" + element.getName() + " implementing Provider=" + provider.getName()); + } + + String value = serviceCapabilities.get(cap); + if (value == null || value.isEmpty()) { + throw new UnsupportedServiceException("Service " + service.getName() + " doesn't have capability " + cap.getName() + " for element=" + element.getName() + " implementing Provider=" + + provider.getName()); + } + + capValue = capValue.toLowerCase(); + + if (!value.contains(capValue)) { + throw new UnsupportedServiceException("Service " + service.getName() + " doesn't support value " + capValue + " for capability " + cap.getName() + " for element=" + element.getName() + + " implementing Provider=" + provider.getName()); + } + } else { + throw new UnsupportedServiceException("Unable to find network element for provider " + provider.getName()); + } + } + } + + @Override + public void checkNetworkPermissions(Account owner, Network network) { + // Perform account permission check + if (network.getGuestType() != Network.GuestType.Shared) { + List networkMap = _networksDao.listBy(owner.getId(), network.getId()); + if (networkMap == null || networkMap.isEmpty()) { + throw new PermissionDeniedException("Unable to use network with id= " + network.getId() + ", permission denied"); + } + } else { + if (!isNetworkAvailableInDomain(network.getId(), owner.getDomainId())) { + throw new PermissionDeniedException("Shared network id=" + network.getId() + " is not available in domain id=" + owner.getDomainId()); + } + } + } + + @Override + public String getDefaultPublicTrafficLabel(long dcId, HypervisorType hypervisorType) { + try { + PhysicalNetwork publicPhyNetwork = getOnePhysicalNetworkByZoneAndTrafficType(dcId, TrafficType.Public); + PhysicalNetworkTrafficTypeVO publicTraffic = _pNTrafficTypeDao.findBy(publicPhyNetwork.getId(), + TrafficType.Public); + if (publicTraffic != null) { + String label = null; + switch (hypervisorType) { + case XenServer: + label = publicTraffic.getXenNetworkLabel(); + break; + case KVM: + label = publicTraffic.getKvmNetworkLabel(); + break; + case VMware: + label = publicTraffic.getVmwareNetworkLabel(); + break; + } + return label; + } + } catch (Exception ex) { + if (s_logger.isDebugEnabled()) { + s_logger.debug("Failed to retrieve the default label for public traffic." + "zone: " + dcId + " hypervisor: " + hypervisorType + " due to: " + ex.getMessage()); + } + } + return null; + } + + @Override + public String getDefaultGuestTrafficLabel(long dcId, HypervisorType hypervisorType) { + try { + PhysicalNetwork guestPhyNetwork = getOnePhysicalNetworkByZoneAndTrafficType(dcId, TrafficType.Guest); + PhysicalNetworkTrafficTypeVO guestTraffic = _pNTrafficTypeDao.findBy(guestPhyNetwork.getId(), + TrafficType.Guest); + if (guestTraffic != null) { + String label = null; + switch (hypervisorType) { + case XenServer: + label = guestTraffic.getXenNetworkLabel(); + break; + case KVM: + label = guestTraffic.getKvmNetworkLabel(); + break; + case VMware: + label = guestTraffic.getVmwareNetworkLabel(); + break; + } + return label; + } + } catch (Exception ex) { + if (s_logger.isDebugEnabled()) { + s_logger.debug("Failed to retrive the default label for management traffic:" + "zone: " + dcId + + " hypervisor: " + hypervisorType + " due to:" + ex.getMessage()); + } + } + return null; + } + + @Override + public List listNetworksByVpc(long vpcId) { + return _networksDao.listByVpc(vpcId); + } + + @Override + public String getDefaultNetworkDomain() { + return _networkDomain; + } + + @Override + public List getNtwkOffDistinctProviders(long ntkwOffId) { + List providerNames = _ntwkOfferingSrvcDao.getDistinctProviders(ntkwOffId); + List providers = new ArrayList(); + for (String providerName : providerNames) { + providers.add(Network.Provider.getProvider(providerName)); + } + + return providers; + } + + @Override + public boolean isVmPartOfNetwork(long vmId, long ntwkId) { + if (_nicDao.findNonReleasedByInstanceIdAndNetworkId(ntwkId, vmId) != null) { + return true; + } + return false; + } + + @Override + public List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType) { + + List pNtwks = _physicalNetworkDao.listByZone(zoneId); + + Iterator it = pNtwks.iterator(); + while (it.hasNext()) { + PhysicalNetwork pNtwk = it.next(); + if (!_pNTrafficTypeDao.isTrafficTypeSupported(pNtwk.getId(), trafficType)) { + it.remove(); + } + } + return pNtwks; + } + + @Override + public boolean isPrivateGateway(Nic guestNic) { + Network network = getNetwork(guestNic.getNetworkId()); + if (network.getTrafficType() != TrafficType.Guest || network.getNetworkOfferingId() != _privateOfferingId.longValue()) { + return false; + } + return true; + } + + + @Override + public List getSystemAccountNetworkOfferings(String... offeringNames) { + List offerings = new ArrayList(offeringNames.length); + for (String offeringName : offeringNames) { + NetworkOfferingVO network = _systemNetworks.get(offeringName); + if (network == null) { + throw new CloudRuntimeException("Unable to find system network profile for " + offeringName); + } + offerings.add(network); + } + return offerings; + } + + @Override + public boolean isNetworkAvailableInDomain(long networkId, long domainId) { + Long networkDomainId = null; + Network network = getNetwork(networkId); + if (network.getGuestType() != Network.GuestType.Shared) { + s_logger.trace("Network id=" + networkId + " is not shared"); + return false; + } + + NetworkDomainVO networkDomainMap = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId); + if (networkDomainMap == null) { + s_logger.trace("Network id=" + networkId + " is shared, but not domain specific"); + return true; + } else { + networkDomainId = networkDomainMap.getDomainId(); + } + + if (domainId == networkDomainId.longValue()) { + return true; + } + + if (networkDomainMap.subdomainAccess) { + Set parentDomains = _domainMgr.getDomainParentIds(domainId); + + if (parentDomains.contains(domainId)) { + return true; + } + } + + return false; + } + + @Override + public Set getAvailableIps(Network network, String requestedIp) { + String[] cidr = network.getCidr().split("/"); + List ips = _nicDao.listIpAddressInNetwork(network.getId()); + Set allPossibleIps = NetUtils.getAllIpsFromCidr(cidr[0], Integer.parseInt(cidr[1])); + Set usedIps = new TreeSet(); + + for (String ip : ips) { + if (requestedIp != null && requestedIp.equals(ip)) { + s_logger.warn("Requested ip address " + requestedIp + " is already in use in network" + network); + return null; + } + + usedIps.add(NetUtils.ip2Long(ip)); + } + if (usedIps.size() != 0) { + allPossibleIps.removeAll(usedIps); + } + return allPossibleIps; + } + + @Override + public String getDomainNetworkDomain(long domainId, long zoneId) { + String networkDomain = null; + Long searchDomainId = domainId; + while(searchDomainId != null){ + DomainVO domain = _domainDao.findById(searchDomainId); + if(domain.getNetworkDomain() != null){ + networkDomain = domain.getNetworkDomain(); + break; + } + searchDomainId = domain.getParent(); + } + if (networkDomain == null) { + return getZoneNetworkDomain(zoneId); + } + return networkDomain; + } + + boolean isProviderEnabled(PhysicalNetworkServiceProvider provider) { + if (provider == null || provider.getState() != PhysicalNetworkServiceProvider.State.Enabled) { // TODO: check + // for other states: Shutdown? + return false; + } + return true; + } + + boolean isServiceEnabledInNetwork(long physicalNetworkId, long networkId, Service service) { + // check if the service is supported in the network + if (!areServicesSupportedInNetwork(networkId, service)) { + s_logger.debug("Service " + service.getName() + " is not supported in the network id=" + networkId); + return false; + } + + // get provider for the service and check if all of them are supported + String provider = _ntwkSrvcDao.getProviderForServiceInNetwork(networkId, service); + if (!isProviderEnabledInPhysicalNetwork(physicalNetworkId, provider)) { + s_logger.debug("Provider " + provider + " is not enabled in physical network id=" + physicalNetworkId); + return false; + } + + return true; + } + + Nic getNicInNetworkIncludingRemoved(long vmId, long networkId) { + return _nicDao.findByInstanceIdAndNetworkIdIncludingRemoved(networkId, vmId); + } + + String getZoneNetworkDomain(long zoneId) { + return _dcDao.findById(zoneId).getDomain(); + } + + PhysicalNetwork getOnePhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { + List networkList = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); + + if (networkList.isEmpty()) { + throw new InvalidParameterValueException("Unable to find the default physical network with traffic=" + + trafficType + " in zone id=" + zoneId + ". "); + } + + if (networkList.size() > 1) { + s_logger.info("More than one physical networks exist in zone id=" + zoneId + " with traffic type=" + + trafficType + ". "); + } + + return networkList.get(0); + } + + + + protected Long getNonGuestNetworkPhysicalNetworkId(Network network) { + // no physical network for control traffic type + + // have to remove this sanity check as VMware control network is management network + // we need to retrieve traffic label information through physical network + /* + if (network.getTrafficType() == TrafficType.Control) { + return null; + } + */ + Long physicalNetworkId = network.getPhysicalNetworkId(); + + if (physicalNetworkId == null) { + List pNtwks = _physicalNetworkDao.listByZone(network.getDataCenterId()); + if (pNtwks.size() == 1) { + physicalNetworkId = pNtwks.get(0).getId(); + } else { + // locate physicalNetwork with supported traffic type + // We can make this assumptions based on the fact that Public/Management/Control traffic types are + // supported only in one physical network in the zone in 3.0 + for (PhysicalNetworkVO pNtwk : pNtwks) { + if (_pNTrafficTypeDao.isTrafficTypeSupported(pNtwk.getId(), network.getTrafficType())) { + physicalNetworkId = pNtwk.getId(); + break; + } + } + } + } + return physicalNetworkId; + } + + @Override + public NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri) { + NicVO nic = null; + if (broadcastUri != null) { + nic = _nicDao.findByNetworkIdInstanceIdAndBroadcastUri(networkId, vm.getId(), broadcastUri); + } else { + nic = _nicDao.findByInstanceIdAndNetworkId(networkId, vm.getId()); + } + NetworkVO network = _networksDao.findById(networkId); + Integer networkRate = getNetworkRate(network.getId(), vm.getId()); + +// NetworkGuru guru = _networkGurus.get(network.getGuruName()); + NicProfile profile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), + networkRate, isSecurityGroupSupportedInNetwork(network), getNetworkTag(vm.getHypervisorType(), network)); +// guru.updateNicProfile(profile, network); + + return profile; + } + + @Override + public boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId) { + boolean netscalerInNetwork = isProviderForNetwork(Network.Provider.Netscaler, networkId); + boolean juniperInNetwork = isProviderForNetwork(Network.Provider.JuniperSRX, networkId); + boolean f5InNetwork = isProviderForNetwork(Network.Provider.F5BigIp, networkId); + + if (netscalerInNetwork || juniperInNetwork || f5InNetwork) { + return true; + } else { + return false; + } + } + + + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + _name = name; + _configs = _configDao.getConfiguration("Network", params); + _networkDomain = _configs.get(Config.GuestDomainSuffix.key()); + _allowSubdomainNetworkAccess = Boolean.valueOf(_configs.get(Config.SubDomainNetworkAccess.key())); + + NetworkOfferingVO publicNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemPublicNetwork, TrafficType.Public, true); + publicNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(publicNetworkOffering); + _systemNetworks.put(NetworkOfferingVO.SystemPublicNetwork, publicNetworkOffering); + NetworkOfferingVO managementNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemManagementNetwork, TrafficType.Management, false); + managementNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(managementNetworkOffering); + _systemNetworks.put(NetworkOfferingVO.SystemManagementNetwork, managementNetworkOffering); + NetworkOfferingVO controlNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemControlNetwork, TrafficType.Control, false); + controlNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(controlNetworkOffering); + _systemNetworks.put(NetworkOfferingVO.SystemControlNetwork, controlNetworkOffering); + NetworkOfferingVO storageNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemStorageNetwork, TrafficType.Storage, true); + storageNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(storageNetworkOffering); + _systemNetworks.put(NetworkOfferingVO.SystemStorageNetwork, storageNetworkOffering); + NetworkOfferingVO privateGatewayNetworkOffering = new NetworkOfferingVO(NetworkOfferingVO.SystemPrivateGatewayNetworkOffering, + GuestType.Isolated); + privateGatewayNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(privateGatewayNetworkOffering); + _systemNetworks.put(NetworkOfferingVO.SystemPrivateGatewayNetworkOffering, privateGatewayNetworkOffering); + _privateOfferingId = privateGatewayNetworkOffering.getId(); + + + IpAddressSearch = _ipAddressDao.createSearchBuilder(); + IpAddressSearch.and("accountId", IpAddressSearch.entity().getAllocatedToAccountId(), Op.EQ); + IpAddressSearch.and("dataCenterId", IpAddressSearch.entity().getDataCenterId(), Op.EQ); + IpAddressSearch.and("vpcId", IpAddressSearch.entity().getVpcId(), Op.EQ); + IpAddressSearch.and("associatedWithNetworkId", IpAddressSearch.entity().getAssociatedWithNetworkId(), Op.EQ); + SearchBuilder virtualNetworkVlanSB = _vlanDao.createSearchBuilder(); + virtualNetworkVlanSB.and("vlanType", virtualNetworkVlanSB.entity().getVlanType(), Op.EQ); + IpAddressSearch.join("virtualNetworkVlanSB", virtualNetworkVlanSB, IpAddressSearch.entity().getVlanId(), virtualNetworkVlanSB.entity().getId(), JoinBuilder.JoinType.INNER); + IpAddressSearch.done(); + + NicForTrafficTypeSearch = _nicDao.createSearchBuilder(); + SearchBuilder networkSearch = _networksDao.createSearchBuilder(); + NicForTrafficTypeSearch.join("network", networkSearch, networkSearch.entity().getId(), NicForTrafficTypeSearch.entity().getNetworkId(), JoinType.INNER); + NicForTrafficTypeSearch.and("instance", NicForTrafficTypeSearch.entity().getInstanceId(), Op.EQ); + networkSearch.and("traffictype", networkSearch.entity().getTrafficType(), Op.EQ); + NicForTrafficTypeSearch.done(); + + s_logger.info("Network Model is configured."); + + return true; + } + + + @Override + public boolean start() { + // populate s_serviceToImplementedProvidersMap & s_providerToNetworkElementMap with current _networkElements + // Need to do this in start() since _networkElements are not completely configured until then. + for (NetworkElement element : _networkElements) { + Map> capabilities = element.getCapabilities(); + Provider implementedProvider = element.getProvider(); + if (implementedProvider != null) { + if (s_providerToNetworkElementMap.containsKey(implementedProvider.getName())) { + s_logger.error("Cannot start NetworkModel: Provider <-> NetworkElement must be a one-to-one map, " + + "multiple NetworkElements found for Provider: " + implementedProvider.getName()); + return false; + } + s_providerToNetworkElementMap.put(implementedProvider.getName(), element.getName()); + } + if (capabilities != null && implementedProvider != null) { + for (Service service : capabilities.keySet()) { + if (s_serviceToImplementedProvidersMap.containsKey(service)) { + List providers = s_serviceToImplementedProvidersMap.get(service); + providers.add(implementedProvider); + } else { + List providers = new ArrayList(); + providers.add(implementedProvider); + s_serviceToImplementedProvidersMap.put(service, providers); + } + } + } + } + s_logger.info("Started Network Model"); + return true; + } + + + @Override + public boolean stop() { + return true; + } + + + @Override + public String getName() { + return _name; + } + + @Override + public PublicIpAddress getSourceNatIpAddressForGuestNetwork(Account owner, Network guestNetwork) { + List addrs = listPublicIpsAssignedToGuestNtwk(owner.getId(), guestNetwork.getId(), true); + + IPAddressVO sourceNatIp = null; + if (addrs.isEmpty()) { + return null; + } else { + for (IpAddress addr : addrs) { + if (addr.isSourceNat()) { + sourceNatIp = _ipAddressDao.findById(addr.getId()); + return new PublicIp(sourceNatIp, _vlanDao.findById(sourceNatIp.getVlanId()), + NetUtils.createSequenceBasedMacAddress(sourceNatIp.getMacAddress())); + } + } + + } + + return null; + } + + public boolean isNetworkInlineMode(Network network) { + NetworkOfferingVO offering = _networkOfferingDao.findById(network.getNetworkOfferingId()); + return offering.isInline(); + } + +} \ No newline at end of file diff --git a/server/src/com/cloud/network/NetworkRuleApplier.java b/server/src/com/cloud/network/NetworkRuleApplier.java new file mode 100644 index 00000000000..31763d0ac54 --- /dev/null +++ b/server/src/com/cloud/network/NetworkRuleApplier.java @@ -0,0 +1,28 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + +import java.util.List; + +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.rules.FirewallRule; + +public interface NetworkRuleApplier { + public boolean applyRules(Network network, FirewallRule.Purpose purpose, List rules) throws ResourceUnavailableException; + +} \ No newline at end of file diff --git a/server/src/com/cloud/network/NetworkServiceImpl.java b/server/src/com/cloud/network/NetworkServiceImpl.java new file mode 100755 index 00000000000..b05aece918e --- /dev/null +++ b/server/src/com/cloud/network/NetworkServiceImpl.java @@ -0,0 +1,2885 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.network; + +import java.security.InvalidParameterException; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.log4j.Logger; + +import org.apache.cloudstack.acl.ControlledEntity.ACLType; +import org.apache.cloudstack.acl.SecurityChecker.AccessType; +import org.apache.cloudstack.api.command.admin.usage.ListTrafficTypeImplementorsCmd; +import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd; +import org.apache.cloudstack.api.command.user.network.ListNetworksCmd; +import org.apache.cloudstack.api.command.user.network.RestartNetworkCmd; + +import com.cloud.configuration.Config; +import com.cloud.configuration.ConfigurationManager; +import com.cloud.configuration.dao.ConfigurationDao; +import com.cloud.dc.DataCenter; +import com.cloud.dc.DataCenter.NetworkType; +import com.cloud.dc.DataCenterVO; +import com.cloud.dc.Vlan.VlanType; +import com.cloud.dc.VlanVO; +import com.cloud.dc.dao.AccountVlanMapDao; +import com.cloud.dc.dao.DataCenterDao; +import com.cloud.dc.dao.VlanDao; +import com.cloud.deploy.DeployDestination; +import com.cloud.domain.Domain; +import com.cloud.domain.DomainVO; +import com.cloud.domain.dao.DomainDao; +import com.cloud.event.ActionEvent; +import com.cloud.event.EventTypes; +import com.cloud.event.UsageEventVO; +import com.cloud.event.dao.EventDao; +import com.cloud.event.dao.UsageEventDao; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.InvalidParameterValueException; +import com.cloud.exception.PermissionDeniedException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.exception.UnsupportedServiceException; +import com.cloud.network.IpAddress.State; +import com.cloud.network.Network.Capability; +import com.cloud.network.Network.GuestType; +import com.cloud.network.Network.Provider; +import com.cloud.network.Network.Service; +import com.cloud.network.Networks.BroadcastDomainType; +import com.cloud.network.Networks.TrafficType; +import com.cloud.network.PhysicalNetwork.BroadcastDomainRange; +import com.cloud.network.VirtualRouterProvider.VirtualRouterProviderType; +import com.cloud.network.addr.PublicIp; +import com.cloud.network.dao.FirewallRulesDao; +import com.cloud.network.dao.IPAddressDao; +import com.cloud.network.dao.NetworkDao; +import com.cloud.network.dao.NetworkDomainDao; +import com.cloud.network.dao.NetworkServiceMapDao; +import com.cloud.network.dao.PhysicalNetworkDao; +import com.cloud.network.dao.PhysicalNetworkServiceProviderDao; +import com.cloud.network.dao.PhysicalNetworkServiceProviderVO; +import com.cloud.network.dao.PhysicalNetworkTrafficTypeDao; +import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.VirtualRouterElement; +import com.cloud.network.element.VpcVirtualRouterElement; +import com.cloud.network.guru.NetworkGuru; +import com.cloud.network.rules.FirewallRule.Purpose; +import com.cloud.network.rules.FirewallRuleVO; +import com.cloud.network.rules.RulesManager; +import com.cloud.network.vpc.PrivateIpVO; +import com.cloud.network.vpc.VpcManager; +import com.cloud.network.vpc.dao.PrivateIpDao; +import com.cloud.offering.NetworkOffering; +import com.cloud.offerings.NetworkOfferingVO; +import com.cloud.offerings.dao.NetworkOfferingDao; +import com.cloud.offerings.dao.NetworkOfferingServiceMapDao; +import com.cloud.org.Grouping; +import com.cloud.projects.Project; +import com.cloud.projects.ProjectManager; +import com.cloud.server.ResourceTag.TaggedResourceType; +import com.cloud.tags.ResourceTagVO; +import com.cloud.tags.dao.ResourceTagDao; +import com.cloud.user.Account; +import com.cloud.user.AccountManager; +import com.cloud.user.AccountVO; +import com.cloud.user.DomainManager; +import com.cloud.user.ResourceLimitService; +import com.cloud.user.User; +import com.cloud.user.UserContext; +import com.cloud.user.dao.AccountDao; +import com.cloud.utils.AnnotationHelper; +import com.cloud.utils.NumbersUtil; +import com.cloud.utils.Pair; +import com.cloud.utils.component.Adapters; +import com.cloud.utils.component.Inject; +import com.cloud.utils.component.Manager; +import com.cloud.utils.db.DB; +import com.cloud.utils.db.Filter; +import com.cloud.utils.db.JoinBuilder; +import com.cloud.utils.db.SearchBuilder; +import com.cloud.utils.db.SearchCriteria; +import com.cloud.utils.db.SearchCriteria.Op; +import com.cloud.utils.db.Transaction; +import com.cloud.utils.exception.CloudRuntimeException; +import com.cloud.utils.net.NetUtils; +import com.cloud.vm.NicVO; +import com.cloud.vm.ReservationContext; +import com.cloud.vm.ReservationContextImpl; +import com.cloud.vm.SecondaryStorageVmVO; +import com.cloud.vm.UserVmVO; +import com.cloud.vm.VMInstanceVO; +import com.cloud.vm.VirtualMachine; +import com.cloud.vm.dao.NicDao; +import com.cloud.vm.dao.UserVmDao; +import com.cloud.vm.dao.VMInstanceDao; + +/** + * NetworkServiceImpl implements NetworkService. + */ +@Local(value = { NetworkService.class }) +public class NetworkServiceImpl implements NetworkService, Manager { + private static final Logger s_logger = Logger.getLogger(NetworkServiceImpl.class); + + String _name; + @Inject + DataCenterDao _dcDao = null; + @Inject + VlanDao _vlanDao = null; + @Inject + IPAddressDao _ipAddressDao = null; + @Inject + AccountDao _accountDao = null; + @Inject + DomainDao _domainDao = null; + + @Inject + EventDao _eventDao = null; + @Inject + ConfigurationDao _configDao; + @Inject + UserVmDao _userVmDao = null; + + @Inject + AccountManager _accountMgr; + @Inject + ConfigurationManager _configMgr; + @Inject + AccountVlanMapDao _accountVlanMapDao; + @Inject + NetworkOfferingDao _networkOfferingDao = null; + @Inject + NetworkDao _networksDao = null; + @Inject + NicDao _nicDao = null; + @Inject + RulesManager _rulesMgr; + + @Inject + UsageEventDao _usageEventDao; + + @Inject(adapter = NetworkGuru.class) + Adapters _networkGurus; + + @Inject + NetworkDomainDao _networkDomainDao; + @Inject + VMInstanceDao _vmDao; + + @Inject + FirewallRulesDao _firewallDao; + + @Inject + ResourceLimitService _resourceLimitMgr; + + @Inject + DomainManager _domainMgr; + @Inject + ProjectManager _projectMgr; + @Inject + NetworkOfferingServiceMapDao _ntwkOfferingSrvcDao; + @Inject + PhysicalNetworkDao _physicalNetworkDao; + @Inject + PhysicalNetworkServiceProviderDao _pNSPDao; + + @Inject + PhysicalNetworkTrafficTypeDao _pNTrafficTypeDao; + + @Inject + NetworkServiceMapDao _ntwkSrvcDao; + @Inject + StorageNetworkManager _stnwMgr; + @Inject + VpcManager _vpcMgr; + @Inject + PrivateIpDao _privateIpDao; + @Inject + ResourceTagDao _resourceTagDao; + @Inject + NetworkManager _networkMgr; + @Inject + NetworkModel _networkModel; + + int _cidrLimit; + boolean _allowSubdomainNetworkAccess; + + private Map _configs; + + /* Get a list of IPs, classify them by service */ + protected Map> getIpToServices(List publicIps, boolean rulesRevoked, boolean includingFirewall) { + Map> ipToServices = new HashMap>(); + + if (publicIps != null && !publicIps.isEmpty()) { + Set networkSNAT = new HashSet(); + for (PublicIp ip : publicIps) { + Set services = ipToServices.get(ip); + if (services == null) { + services = new HashSet(); + } + if (ip.isSourceNat()) { + if (!networkSNAT.contains(ip.getAssociatedWithNetworkId())) { + services.add(Service.SourceNat); + networkSNAT.add(ip.getAssociatedWithNetworkId()); + } else { + CloudRuntimeException ex = new CloudRuntimeException("Multiple generic soure NAT IPs provided for network"); + // see the IPAddressVO.java class. + ex.addProxyObject("user_ip_address", ip.getAssociatedWithNetworkId(), "networkId"); + throw ex; + } + } + ipToServices.put(ip, services); + + // if IP in allocating state then it will not have any rules attached so skip IPAssoc to network service + // provider + if (ip.getState() == State.Allocating) { + continue; + } + + // check if any active rules are applied on the public IP + Set purposes = getPublicIpPurposeInRules(ip, false, includingFirewall); + // Firewall rules didn't cover static NAT + if (ip.isOneToOneNat() && ip.getAssociatedWithVmId() != null) { + if (purposes == null) { + purposes = new HashSet(); + } + purposes.add(Purpose.StaticNat); + } + if (purposes == null || purposes.isEmpty()) { + // since no active rules are there check if any rules are applied on the public IP but are in +// revoking state + + purposes = getPublicIpPurposeInRules(ip, true, includingFirewall); + if (ip.isOneToOneNat()) { + if (purposes == null) { + purposes = new HashSet(); + } + purposes.add(Purpose.StaticNat); + } + if (purposes == null || purposes.isEmpty()) { + // IP is not being used for any purpose so skip IPAssoc to network service provider + continue; + } else { + if (rulesRevoked) { + // no active rules/revoked rules are associated with this public IP, so remove the +// association with the provider + ip.setState(State.Releasing); + } else { + if (ip.getState() == State.Releasing) { + // rules are not revoked yet, so don't let the network service provider revoke the IP +// association + // mark IP is allocated so that IP association will not be removed from the provider + ip.setState(State.Allocated); + } + } + } + } + if (purposes.contains(Purpose.StaticNat)) { + services.add(Service.StaticNat); + } + if (purposes.contains(Purpose.LoadBalancing)) { + services.add(Service.Lb); + } + if (purposes.contains(Purpose.PortForwarding)) { + services.add(Service.PortForwarding); + } + if (purposes.contains(Purpose.Vpn)) { + services.add(Service.Vpn); + } + if (purposes.contains(Purpose.Firewall)) { + services.add(Service.Firewall); + } + if (services.isEmpty()) { + continue; + } + ipToServices.put(ip, services); + } + } + return ipToServices; + } + + protected boolean canIpUsedForNonConserveService(PublicIp ip, Service service) { + // If it's non-conserve mode, then the new ip should not be used by any other services + List ipList = new ArrayList(); + ipList.add(ip); + Map> ipToServices = getIpToServices(ipList, false, false); + Set services = ipToServices.get(ip); + // Not used currently, safe + if (services == null || services.isEmpty()) { + return true; + } + // Since it's non-conserve mode, only one service should used for IP + if (services.size() != 1) { + throw new InvalidParameterException("There are multiple services used ip " + ip.getAddress() + "."); + } + if (service != null && !((Service) services.toArray()[0] == service || service.equals(Service.Firewall))) { + throw new InvalidParameterException("The IP " + ip.getAddress() + " is already used as " + ((Service) services.toArray()[0]).getName() + " rather than " + service.getName()); + } + return true; + } + + protected boolean canIpsUsedForNonConserve(List publicIps) { + boolean result = true; + for (PublicIp ip : publicIps) { + result = canIpUsedForNonConserveService(ip, null); + if (!result) { + break; + } + } + return result; + } + + private boolean canIpsUseOffering(List publicIps, long offeringId) { + Map> ipToServices = getIpToServices(publicIps, false, true); + Map> serviceToProviders = _networkModel.getNetworkOfferingServiceProvidersMap(offeringId); + for (PublicIp ip : ipToServices.keySet()) { + Set services = ipToServices.get(ip); + Provider provider = null; + for (Service service : services) { + Set curProviders = serviceToProviders.get(service); + if (curProviders == null || curProviders.isEmpty()) { + continue; + } + Provider curProvider = (Provider) curProviders.toArray()[0]; + if (provider == null) { + provider = curProvider; + continue; + } + // We don't support multiple providers for one service now + if (!provider.equals(curProvider)) { + throw new InvalidParameterException("There would be multiple providers for IP " + ip.getAddress() + " with the new network offering!"); + } + } + } + return true; + } + + + + + private Set getPublicIpPurposeInRules(PublicIp ip, boolean includeRevoked, boolean includingFirewall) { + Set result = new HashSet(); + List rules = null; + if (includeRevoked) { + rules = _firewallDao.listByIp(ip.getId()); + } else { + rules = _firewallDao.listByIpAndNotRevoked(ip.getId()); + } + + if (rules == null || rules.isEmpty()) { + return null; + } + + for (FirewallRuleVO rule : rules) { + if (rule.getPurpose() != Purpose.Firewall || includingFirewall) { + result.add(rule.getPurpose()); + } + } + + return result; + } + + @Override + public List getIsolatedNetworksOwnedByAccountInZone(long zoneId, Account owner) { + + return _networksDao.listByZoneAndGuestType(owner.getId(), zoneId, Network.GuestType.Isolated, false); + } + + @Override + public List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { + + return _networksDao.listSourceNATEnabledNetworks(owner.getId(), zoneId, Network.GuestType.Isolated); + } + + + + + @Override + @ActionEvent(eventType = EventTypes.EVENT_NET_IP_ASSIGN, eventDescription = "allocating Ip", create = true) + public IpAddress allocateIP(Account ipOwner, boolean isSystem, long zoneId) + throws ResourceAllocationException, InsufficientAddressCapacityException, ConcurrentOperationException { + Account caller = UserContext.current().getCaller(); + // check permissions + _accountMgr.checkAccess(caller, null, false, ipOwner); + long callerUserId = UserContext.current().getCallerUserId(); + DataCenter zone = _configMgr.getZone(zoneId); + + return _networkMgr.allocateIp(ipOwner, isSystem, caller, callerUserId, zone); + } + + @Override + @DB + public boolean configure(final String name, final Map params) throws ConfigurationException { + _name = name; + _configs = _configDao.getConfiguration("Network", params); + + _cidrLimit = NumbersUtil.parseInt(_configs.get(Config.NetworkGuestCidrLimit.key()), 22); + + _allowSubdomainNetworkAccess = Boolean.valueOf(_configs.get(Config.SubDomainNetworkAccess.key())); + + s_logger.info("Network Service is configured."); + + return true; + } + + @Override + public String getName() { + return _name; + } + + @Override + public boolean start() { + return true; + } + + @Override + public boolean stop() { + return true; + } + + protected NetworkServiceImpl() { + } + + + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_NET_IP_RELEASE, eventDescription = "disassociating Ip", async = true) + public boolean releaseIpAddress(long ipAddressId) throws InsufficientAddressCapacityException { + Long userId = UserContext.current().getCallerUserId(); + Account caller = UserContext.current().getCaller(); + + // 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."); + } + + // Check for account wide pool. It will have an entry for account_vlan_map. + if (_accountVlanMapDao.findAccountVlanMap(ipVO.getAllocatedToAccountId(), ipVO.getVlanId()) != null) { + //see IPaddressVO.java + InvalidParameterValueException ex = new InvalidParameterValueException("Sepcified IP address uuid belongs to" + + " Account wide IP pool and cannot be disassociated"); + ex.addProxyObject("user_ip_address", ipAddressId, "ipAddressId"); + throw ex; + } + + // don't allow releasing system ip address + if (ipVO.getSystem()) { + InvalidParameterValueException ex = new InvalidParameterValueException("Can't release system IP address with specified id"); + ex.addProxyObject(ipVO, ipVO.getId(), "systemIpAddrId"); + throw ex; + } + + boolean success = _networkMgr.disassociatePublicIpAddress(ipAddressId, userId, caller); + + if (success) { + Long networkId = ipVO.getAssociatedWithNetworkId(); + if (networkId != null) { + Network guestNetwork = getNetwork(networkId); + NetworkOffering offering = _configMgr.getNetworkOffering(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; + } + + + @Override + @DB + public Network getNetwork(long id) { + return _networksDao.findById(id); + } + + + private void checkSharedNetworkCidrOverlap(Long zoneId, long physicalNetworkId, String cidr) { + if (zoneId == null || cidr == null) { + return; + } + + DataCenter zone = _dcDao.findById(zoneId); + List networks = _networksDao.listByZone(zoneId); + Map networkToCidr = new HashMap(); + + // check for CIDR overlap with all possible CIDR for isolated guest networks + // in the zone when using external networking + PhysicalNetworkVO pNetwork = _physicalNetworkDao.findById(physicalNetworkId); + if (pNetwork.getVnet() != null) { + String vlanRange[] = pNetwork.getVnet().split("-"); + int lowestVlanTag = Integer.valueOf(vlanRange[0]); + int highestVlanTag = Integer.valueOf(vlanRange[1]); + for (int vlan=lowestVlanTag; vlan <= highestVlanTag; ++vlan) { + int offset = vlan - lowestVlanTag; + String globalVlanBits = _configDao.getValue(Config.GuestVlanBits.key()); + int cidrSize = 8 + Integer.parseInt(globalVlanBits); + String guestNetworkCidr = zone.getGuestNetworkCidr(); + String[] cidrTuple = guestNetworkCidr.split("\\/"); + long newCidrAddress = (NetUtils.ip2Long(cidrTuple[0]) & 0xff000000) | (offset << (32 - cidrSize)); + if (NetUtils.isNetworksOverlap(NetUtils.long2Ip(newCidrAddress), cidr)) { + throw new InvalidParameterValueException("Specified CIDR for shared network conflict with CIDR that is reserved for zone vlan " + vlan); + } + } + } + + // check for CIDR overlap with all CIDR's of the shared networks in the zone + for (NetworkVO network : networks) { + if (network.getGuestType() == GuestType.Isolated) { + continue; + } + if (network.getCidr() != null) { + networkToCidr.put(network.getId(), network.getCidr()); + } + } + if (networkToCidr != null && !networkToCidr.isEmpty()) { + for (long networkId : networkToCidr.keySet()) { + String ntwkCidr = networkToCidr.get(networkId); + if (NetUtils.isNetworksOverlap(ntwkCidr, cidr)) { + throw new InvalidParameterValueException("Specified CIDR for shared network conflict with CIDR of a shared network in the zone."); + } + } + } + } + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_NETWORK_CREATE, eventDescription = "creating network") + public Network createGuestNetwork(CreateNetworkCmd cmd) throws InsufficientCapacityException, ConcurrentOperationException, ResourceAllocationException { + Long networkOfferingId = cmd.getNetworkOfferingId(); + String gateway = cmd.getGateway(); + String startIP = cmd.getStartIp(); + String endIP = cmd.getEndIp(); + String netmask = cmd.getNetmask(); + String networkDomain = cmd.getNetworkDomain(); + String vlanId = cmd.getVlan(); + String name = cmd.getNetworkName(); + String displayText = cmd.getDisplayText(); + Account caller = UserContext.current().getCaller(); + Long physicalNetworkId = cmd.getPhysicalNetworkId(); + Long zoneId = cmd.getZoneId(); + String aclTypeStr = cmd.getAclType(); + Long domainId = cmd.getDomainId(); + boolean isDomainSpecific = false; + Boolean subdomainAccess = cmd.getSubdomainAccess(); + Long vpcId = cmd.getVpcId(); + + // Validate network offering + NetworkOfferingVO ntwkOff = _networkOfferingDao.findById(networkOfferingId); + if (ntwkOff == null || ntwkOff.isSystemOnly()) { + InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find network offering by specified id"); + if (ntwkOff != null) { + ex.addProxyObject(ntwkOff, networkOfferingId, "networkOfferingId"); + // Get the VO object's table name. + String tablename = AnnotationHelper.getTableName(ntwkOff); + if (tablename != null) { + ex.addProxyObject(tablename, networkOfferingId, "networkOfferingId"); + } else { + s_logger.info("\nCould not retrieve table name (annotation) from " + tablename + " VO proxy object\n"); + } + throw ex; + } + throw ex; + } + // validate physical network and zone + // Check if physical network exists + PhysicalNetwork pNtwk = null; + if (physicalNetworkId != null) { + pNtwk = _physicalNetworkDao.findById(physicalNetworkId); + if (pNtwk == null) { + throw new InvalidParameterValueException("Unable to find a physical network having the specified physical network id"); + } + } + + if (zoneId == null) { + zoneId = pNtwk.getDataCenterId(); + } + + DataCenter zone = _dcDao.findById(zoneId); + if (zone == null) { + throw new InvalidParameterValueException("Specified zone id was not found"); + } + + if (Grouping.AllocationState.Disabled == zone.getAllocationState() && !_accountMgr.isRootAdmin(caller.getType())) { + // See DataCenterVO.java + PermissionDeniedException ex = new PermissionDeniedException("Cannot perform this operation since specified Zone is currently disabled"); + ex.addProxyObject(zone, zoneId, "zoneId"); + throw ex; + } + + // Only domain and account ACL types are supported in Acton. + ACLType aclType = null; + if (aclTypeStr != null) { + if (aclTypeStr.equalsIgnoreCase(ACLType.Account.toString())) { + aclType = ACLType.Account; + } else if (aclTypeStr.equalsIgnoreCase(ACLType.Domain.toString())) { + aclType = ACLType.Domain; + } else { + throw new InvalidParameterValueException("Incorrect aclType specified. Check the API documentation for supported types"); + } + // In 3.0 all Shared networks should have aclType == Domain, all Isolated networks aclType==Account + if (ntwkOff.getGuestType() == GuestType.Isolated) { + if (aclType != ACLType.Account) { + throw new InvalidParameterValueException("AclType should be " + ACLType.Account + " for network of type " + Network.GuestType.Isolated); + } + } else if (ntwkOff.getGuestType() == GuestType.Shared) { + if (!(aclType == ACLType.Domain || aclType == ACLType.Account)) { + throw new InvalidParameterValueException("AclType should be " + ACLType.Domain + " or " + + ACLType.Account + " for network of type " + Network.GuestType.Shared); + } + } + } else { + if (ntwkOff.getGuestType() == GuestType.Isolated) { + aclType = ACLType.Account; + } else if (ntwkOff.getGuestType() == GuestType.Shared) { + aclType = ACLType.Domain; + } + } + + // Only Admin can create Shared networks + if (ntwkOff.getGuestType() == GuestType.Shared && !_accountMgr.isAdmin(caller.getType())) { + throw new InvalidParameterValueException("Only Admins can create network with guest type " + GuestType.Shared); + } + + // Check if the network is domain specific + if (aclType == ACLType.Domain) { + // only Admin can create domain with aclType=Domain + if (!_accountMgr.isAdmin(caller.getType())) { + throw new PermissionDeniedException("Only admin can create networks with aclType=Domain"); + } + + // only shared networks can be Domain specific + if (ntwkOff.getGuestType() != GuestType.Shared) { + throw new InvalidParameterValueException("Only " + GuestType.Shared + " networks can have aclType=" + ACLType.Domain); + } + + if (domainId != null) { + if (ntwkOff.getTrafficType() != TrafficType.Guest || ntwkOff.getGuestType() != Network.GuestType.Shared) { + throw new InvalidParameterValueException("Domain level networks are supported just for traffic type " + + TrafficType.Guest + " and guest type " + Network.GuestType.Shared); + } + + DomainVO domain = _domainDao.findById(domainId); + if (domain == null) { + throw new InvalidParameterValueException("Unable to find domain by specified id"); + } + _accountMgr.checkAccess(caller, domain); + } + isDomainSpecific = true; + + } else if (subdomainAccess != null) { + throw new InvalidParameterValueException("Parameter subDomainAccess can be specified only with aclType=Domain"); + } + Account owner = null; + if ((cmd.getAccountName() != null && domainId != null) || cmd.getProjectId() != null) { + owner = _accountMgr.finalizeOwner(caller, cmd.getAccountName(), domainId, cmd.getProjectId()); + } else { + owner = caller; + } + + UserContext.current().setAccountId(owner.getAccountId()); + + // VALIDATE IP INFO + // if end ip is not specified, default it to startIp + if (startIP != null) { + if (!NetUtils.isValidIp(startIP)) { + throw new InvalidParameterValueException("Invalid format for the startIp parameter"); + } + if (endIP == null) { + endIP = startIP; + } else if (!NetUtils.isValidIp(endIP)) { + throw new InvalidParameterValueException("Invalid format for the endIp parameter"); + } + } + + if (startIP != null && endIP != null) { + if (!(gateway != null && netmask != null)) { + throw new InvalidParameterValueException("gateway and netmask should be defined when startIP/endIP are passed in"); + } + } + + String cidr = null; + if (gateway != null && netmask != null) { + if (!NetUtils.isValidIp(gateway)) { + throw new InvalidParameterValueException("Invalid gateway"); + } + if (!NetUtils.isValidNetmask(netmask)) { + throw new InvalidParameterValueException("Invalid netmask"); + } + + cidr = NetUtils.ipAndNetMaskToCidr(gateway, netmask); + } + + // Regular user can create Guest Isolated Source Nat enabled network only + if (caller.getType() == Account.ACCOUNT_TYPE_NORMAL + && (ntwkOff.getTrafficType() != TrafficType.Guest || ntwkOff.getGuestType() != Network.GuestType.Isolated + && areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat))) { + throw new InvalidParameterValueException("Regular user can create a network only from the network" + + " offering having traffic type " + TrafficType.Guest + " and network type " + + Network.GuestType.Isolated + " with a service " + Service.SourceNat.getName() + " enabled"); + } + + // Don't allow to specify vlan if the caller is a regular user + if (caller.getType() == Account.ACCOUNT_TYPE_NORMAL && (ntwkOff.getSpecifyVlan() || vlanId != null)) { + throw new InvalidParameterValueException("Regular user is not allowed to specify vlanId"); + } + + // For non-root admins check cidr limit - if it's allowed by global config value + if (caller.getType() != Account.ACCOUNT_TYPE_ADMIN && cidr != null) { + + String[] cidrPair = cidr.split("\\/"); + int cidrSize = Integer.valueOf(cidrPair[1]); + + if (cidrSize < _cidrLimit) { + throw new InvalidParameterValueException("Cidr size can't be less than " + _cidrLimit); + } + } + + Collection ntwkProviders = _networkMgr.finalizeServicesAndProvidersForNetwork(ntwkOff, physicalNetworkId).values(); + if (cidr != null && providersConfiguredForExternalNetworking(ntwkProviders)) { + if (ntwkOff.getGuestType() == GuestType.Shared && (zone.getNetworkType() == NetworkType.Advanced) && + isSharedNetworkOfferingWithServices(networkOfferingId)) { + // validate if CIDR specified overlaps with any of the CIDR's allocated for isolated networks and shared networks in the zone + checkSharedNetworkCidrOverlap(zoneId, pNtwk.getId(), cidr); + } else { + throw new InvalidParameterValueException("Cannot specify CIDR when using network offering with external devices!"); + } + } + + + // Vlan is created in 2 cases - works in Advance zone only: + // 1) GuestType is Shared + // 2) GuestType is Isolated, but SourceNat service is disabled + boolean createVlan = (startIP != null && endIP != null && zone.getNetworkType() == NetworkType.Advanced + && ((ntwkOff.getGuestType() == Network.GuestType.Shared) + || (ntwkOff.getGuestType() == GuestType.Isolated && + !areServicesSupportedByNetworkOffering(ntwkOff.getId(), Service.SourceNat)))); + + // Can add vlan range only to the network which allows it + if (createVlan && !ntwkOff.getSpecifyIpRanges()) { + InvalidParameterValueException ex = new InvalidParameterValueException("Network offering with specified id doesn't support adding multiple ip ranges"); + ex.addProxyObject(ntwkOff, ntwkOff.getId(), "networkOfferingId"); + String tablename = AnnotationHelper.getTableName(ntwkOff); + if (tablename != null) { + ex.addProxyObject(tablename, ntwkOff.getId(), "networkOfferingId"); + } else { + s_logger.info("\nCould not retrieve table name (annotation) from " + tablename + " VO proxy object\n"); + } + throw ex; + } + + Transaction txn = Transaction.currentTxn(); + txn.start(); + + Long sharedDomainId = null; + if (isDomainSpecific) { + if (domainId != null) { + sharedDomainId = domainId; + } else { + sharedDomainId = _domainMgr.getDomain(Domain.ROOT_DOMAIN).getId(); + subdomainAccess = true; + } + } + + // default owner to system if network has aclType=Domain + if (aclType == ACLType.Domain) { + owner = _accountMgr.getAccount(Account.ACCOUNT_ID_SYSTEM); + } + + //Create guest network + Network network = null; + if (vpcId != null) { + if (!_configMgr.isOfferingForVpc(ntwkOff)){ + throw new InvalidParameterValueException("Network offering can't be used for VPC networks"); + } + network = _vpcMgr.createVpcGuestNetwork(networkOfferingId, name, displayText, gateway, cidr, vlanId, + networkDomain, owner, sharedDomainId, pNtwk, zoneId, aclType, subdomainAccess, vpcId, caller); + } else { + if (_configMgr.isOfferingForVpc(ntwkOff)){ + throw new InvalidParameterValueException("Network offering can be used for VPC networks only"); + } + network = _networkMgr.createGuestNetwork(networkOfferingId, name, displayText, gateway, cidr, vlanId, + networkDomain, owner, sharedDomainId, pNtwk, zoneId, aclType, subdomainAccess, vpcId); + } + + if (caller.getType() == Account.ACCOUNT_TYPE_ADMIN && createVlan) { + // Create vlan ip range + _configMgr.createVlanAndPublicIpRange(pNtwk.getDataCenterId(), network.getId(), physicalNetworkId, + false, null, startIP, endIP, gateway, netmask, vlanId, null); + } + + txn.commit(); + + return network; + } + + + + @Override + public List searchForNetworks(ListNetworksCmd cmd) { + Long id = cmd.getId(); + String keyword = cmd.getKeyword(); + Long zoneId = cmd.getZoneId(); + Account caller = UserContext.current().getCaller(); + Long domainId = cmd.getDomainId(); + String accountName = cmd.getAccountName(); + String guestIpType = cmd.getGuestIpType(); + String trafficType = cmd.getTrafficType(); + Boolean isSystem = cmd.getIsSystem(); + String aclType = cmd.getAclType(); + Long projectId = cmd.getProjectId(); + List permittedAccounts = new ArrayList(); + String path = null; + Long physicalNetworkId = cmd.getPhysicalNetworkId(); + List supportedServicesStr = cmd.getSupportedServices(); + Boolean restartRequired = cmd.getRestartRequired(); + boolean listAll = cmd.listAll(); + boolean isRecursive = cmd.isRecursive(); + Boolean specifyIpRanges = cmd.getSpecifyIpRanges(); + Long vpcId = cmd.getVpcId(); + Boolean canUseForDeploy = cmd.canUseForDeploy(); + Map tags = cmd.getTags(); + Boolean forVpc = cmd.getForVpc(); + + // 1) default is system to false if not specified + // 2) reset parameter to false if it's specified by the regular user + if ((isSystem == null || caller.getType() == Account.ACCOUNT_TYPE_NORMAL) && id == null) { + isSystem = false; + } + + // Account/domainId parameters and isSystem are mutually exclusive + if (isSystem != null && isSystem && (accountName != null || domainId != null)) { + throw new InvalidParameterValueException("System network belongs to system, account and domainId parameters can't be specified"); + } + + if (domainId != null) { + DomainVO domain = _domainDao.findById(domainId); + if (domain == null) { + // see DomainVO.java + throw new InvalidParameterValueException("Specified domain id doesn't exist in the system"); + } + + _accountMgr.checkAccess(caller, domain); + if (accountName != null) { + Account owner = _accountMgr.getActiveAccountByName(accountName, domainId); + if (owner == null) { + // see DomainVO.java + throw new InvalidParameterValueException("Unable to find account " + accountName + " in specified domain"); + } + + _accountMgr.checkAccess(caller, null, true, owner); + permittedAccounts.add(owner.getId()); + } + } + + if (!_accountMgr.isAdmin(caller.getType()) || (!listAll && (projectId != null && projectId.longValue() != -1 && domainId == null))) { + permittedAccounts.add(caller.getId()); + domainId = caller.getDomainId(); + } + + // set project information + boolean skipProjectNetworks = true; + if (projectId != null) { + if (projectId.longValue() == -1) { + if (!_accountMgr.isAdmin(caller.getType())) { + permittedAccounts.addAll(_projectMgr.listPermittedProjectAccounts(caller.getId())); + } + } else { + permittedAccounts.clear(); + Project project = _projectMgr.getProject(projectId); + if (project == null) { + throw new InvalidParameterValueException("Unable to find project by specified id"); + } + if (!_projectMgr.canAccessProjectAccount(caller, project.getProjectAccountId())) { + // getProject() returns type ProjectVO. + InvalidParameterValueException ex = new InvalidParameterValueException("Account " + caller + " cannot access specified project id"); + ex.addProxyObject(project, projectId, "projectId"); + throw ex; + } + permittedAccounts.add(project.getProjectAccountId()); + } + skipProjectNetworks = false; + } + + if (domainId != null) { + path = _domainDao.findById(domainId).getPath(); + } else { + path = _domainDao.findById(caller.getDomainId()).getPath(); + } + + if (listAll && domainId == null) { + isRecursive = true; + } + + Filter searchFilter = new Filter(NetworkVO.class, "id", false, cmd.getStartIndex(), cmd.getPageSizeVal()); + SearchBuilder sb = _networksDao.createSearchBuilder(); + + if (forVpc != null) { + if (forVpc) { + sb.and("vpc", sb.entity().getVpcId(), Op.NNULL); + } else { + sb.and("vpc", sb.entity().getVpcId(), Op.NULL); + } + } + + // Don't display networks created of system network offerings + SearchBuilder networkOfferingSearch = _networkOfferingDao.createSearchBuilder(); + networkOfferingSearch.and("systemOnly", networkOfferingSearch.entity().isSystemOnly(), SearchCriteria.Op.EQ); + if (isSystem != null && isSystem) { + networkOfferingSearch.and("trafficType", networkOfferingSearch.entity().getTrafficType(), SearchCriteria.Op.EQ); + } + sb.join("networkOfferingSearch", networkOfferingSearch, sb.entity().getNetworkOfferingId(), networkOfferingSearch.entity().getId(), JoinBuilder.JoinType.INNER); + + SearchBuilder zoneSearch = _dcDao.createSearchBuilder(); + zoneSearch.and("networkType", zoneSearch.entity().getNetworkType(), SearchCriteria.Op.EQ); + sb.join("zoneSearch", zoneSearch, sb.entity().getDataCenterId(), zoneSearch.entity().getId(), JoinBuilder.JoinType.INNER); + sb.and("removed", sb.entity().getRemoved(), Op.NULL); + + if (tags != null && !tags.isEmpty()) { + SearchBuilder tagSearch = _resourceTagDao.createSearchBuilder(); + for (int count=0; count < tags.size(); count++) { + tagSearch.or().op("key" + String.valueOf(count), tagSearch.entity().getKey(), SearchCriteria.Op.EQ); + tagSearch.and("value" + String.valueOf(count), tagSearch.entity().getValue(), SearchCriteria.Op.EQ); + tagSearch.cp(); + } + tagSearch.and("resourceType", tagSearch.entity().getResourceType(), SearchCriteria.Op.EQ); + sb.groupBy(sb.entity().getId()); + sb.join("tagSearch", tagSearch, sb.entity().getId(), tagSearch.entity().getResourceId(), JoinBuilder.JoinType.INNER); + } + + if (permittedAccounts.isEmpty()) { + SearchBuilder domainSearch = _domainDao.createSearchBuilder(); + domainSearch.and("path", domainSearch.entity().getPath(), SearchCriteria.Op.LIKE); + sb.join("domainSearch", domainSearch, sb.entity().getDomainId(), domainSearch.entity().getId(), JoinBuilder.JoinType.INNER); + } + + + SearchBuilder accountSearch = _accountDao.createSearchBuilder(); + accountSearch.and("typeNEQ", accountSearch.entity().getType(), SearchCriteria.Op.NEQ); + accountSearch.and("typeEQ", accountSearch.entity().getType(), SearchCriteria.Op.EQ); + + + sb.join("accountSearch", accountSearch, sb.entity().getAccountId(), accountSearch.entity().getId(), JoinBuilder.JoinType.INNER); + + List networksToReturn = new ArrayList(); + + if (isSystem == null || !isSystem) { + if (!permittedAccounts.isEmpty()) { + //get account level networks + networksToReturn.addAll(listAccountSpecificNetworks( + buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, + physicalNetworkId, aclType, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, + permittedAccounts)); + //get domain level networks + if (domainId != null) { + networksToReturn + .addAll(listDomainLevelNetworks( + buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, + physicalNetworkId, aclType, true, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, + domainId, false)); + } + } else { + //add account specific networks + networksToReturn.addAll(listAccountSpecificNetworksByDomainPath( + buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, + physicalNetworkId, aclType, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, path, + isRecursive)); + //add domain specific networks of domain + parent domains + networksToReturn.addAll(listDomainSpecificNetworksByDomainPath( + buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, + physicalNetworkId, aclType, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, path, + isRecursive)); + //add networks of subdomains + if (domainId == null) { + networksToReturn + .addAll(listDomainLevelNetworks( + buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, guestIpType, trafficType, + physicalNetworkId, aclType, true, restartRequired, specifyIpRanges, vpcId, tags), searchFilter, + caller.getDomainId(), true)); + } + } + } else { + networksToReturn = _networksDao.search(buildNetworkSearchCriteria(sb, keyword, id, isSystem, zoneId, + guestIpType, trafficType, physicalNetworkId, null, skipProjectNetworks, restartRequired, specifyIpRanges, vpcId, tags), + searchFilter); + } + + if (supportedServicesStr != null && !supportedServicesStr.isEmpty() && !networksToReturn.isEmpty()) { + List supportedNetworks = new ArrayList(); + Service[] suppportedServices = new Service[supportedServicesStr.size()]; + int i = 0; + for (String supportedServiceStr : supportedServicesStr) { + Service service = Service.getService(supportedServiceStr); + if (service == null) { + throw new InvalidParameterValueException("Invalid service specified " + supportedServiceStr); + } else { + suppportedServices[i] = service; + } + i++; + } + + for (NetworkVO network : networksToReturn) { + if (areServicesSupportedInNetwork(network.getId(), suppportedServices)) { + supportedNetworks.add(network); + } + } + + networksToReturn=supportedNetworks; + } + + if (canUseForDeploy != null) { + List networksForDeploy = new ArrayList(); + for (NetworkVO network : networksToReturn) { + if (_networkModel.canUseForDeploy(network) == canUseForDeploy) { + networksForDeploy.add(network); + } + } + + networksToReturn=networksForDeploy; + } + + return networksToReturn; + } + + + + private SearchCriteria buildNetworkSearchCriteria(SearchBuilder sb, String keyword, Long id, + Boolean isSystem, Long zoneId, String guestIpType, String trafficType, Long physicalNetworkId, + String aclType, boolean skipProjectNetworks, Boolean restartRequired, Boolean specifyIpRanges, Long vpcId, Map tags) { + + SearchCriteria sc = sb.create(); + + if (isSystem != null) { + sc.setJoinParameters("networkOfferingSearch", "systemOnly", isSystem); + } + + if (keyword != null) { + SearchCriteria ssc = _networksDao.createSearchCriteria(); + ssc.addOr("name", SearchCriteria.Op.LIKE, "%" + keyword + "%"); + sc.addAnd("name", SearchCriteria.Op.SC, ssc); + } + + if (id != null) { + sc.addAnd("id", SearchCriteria.Op.EQ, id); + } + + if (zoneId != null) { + sc.addAnd("dataCenterId", SearchCriteria.Op.EQ, zoneId); + } + + if (guestIpType != null) { + sc.addAnd("guestType", SearchCriteria.Op.EQ, guestIpType); + } + + if (trafficType != null) { + sc.addAnd("trafficType", SearchCriteria.Op.EQ, trafficType); + } + + if (aclType != null) { + sc.addAnd("aclType", SearchCriteria.Op.EQ, aclType.toString()); + } + + if (physicalNetworkId != null) { + sc.addAnd("physicalNetworkId", SearchCriteria.Op.EQ, physicalNetworkId); + } + + if (skipProjectNetworks) { + sc.setJoinParameters("accountSearch", "typeNEQ", Account.ACCOUNT_TYPE_PROJECT); + } else { + sc.setJoinParameters("accountSearch", "typeEQ", Account.ACCOUNT_TYPE_PROJECT); + } + + if (restartRequired != null) { + sc.addAnd("restartRequired", SearchCriteria.Op.EQ, restartRequired); + } + + if (specifyIpRanges != null) { + sc.addAnd("specifyIpRanges", SearchCriteria.Op.EQ, specifyIpRanges); + } + + if (vpcId != null) { + sc.addAnd("vpcId", SearchCriteria.Op.EQ, vpcId); + } + + if (tags != null && !tags.isEmpty()) { + int count = 0; + sc.setJoinParameters("tagSearch", "resourceType", TaggedResourceType.Network.toString()); + for (String key : tags.keySet()) { + sc.setJoinParameters("tagSearch", "key" + String.valueOf(count), key); + sc.setJoinParameters("tagSearch", "value" + String.valueOf(count), tags.get(key)); + count++; + } + } + + return sc; + } + + private List listDomainLevelNetworks(SearchCriteria sc, Filter searchFilter, long domainId, boolean parentDomainsOnly) { + List networkIds = new ArrayList(); + Set allowedDomains = _domainMgr.getDomainParentIds(domainId); + List maps = _networkDomainDao.listDomainNetworkMapByDomain(allowedDomains.toArray()); + + for (NetworkDomainVO map : maps) { + if (map.getDomainId() == domainId && parentDomainsOnly) { + continue; + } + boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : getAllowSubdomainAccessGlobal(); + if (map.getDomainId() == domainId || subdomainAccess) { + networkIds.add(map.getNetworkId()); + } + } + + if (!networkIds.isEmpty()) { + SearchCriteria domainSC = _networksDao.createSearchCriteria(); + domainSC.addAnd("id", SearchCriteria.Op.IN, networkIds.toArray()); + domainSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Domain.toString()); + + sc.addAnd("id", SearchCriteria.Op.SC, domainSC); + return _networksDao.search(sc, searchFilter); + } else { + return new ArrayList(); + } + } + + private List listAccountSpecificNetworks(SearchCriteria sc, Filter searchFilter, List permittedAccounts) { + SearchCriteria accountSC = _networksDao.createSearchCriteria(); + if (!permittedAccounts.isEmpty()) { + accountSC.addAnd("accountId", SearchCriteria.Op.IN, permittedAccounts.toArray()); + } + + accountSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Account.toString()); + + sc.addAnd("id", SearchCriteria.Op.SC, accountSC); + return _networksDao.search(sc, searchFilter); + } + + private List listAccountSpecificNetworksByDomainPath(SearchCriteria sc, Filter searchFilter, String path, boolean isRecursive) { + SearchCriteria accountSC = _networksDao.createSearchCriteria(); + accountSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Account.toString()); + + if (path != null) { + if (isRecursive) { + sc.setJoinParameters("domainSearch", "path", path + "%"); + } else { + sc.setJoinParameters("domainSearch", "path", path); + } + } + + sc.addAnd("id", SearchCriteria.Op.SC, accountSC); + return _networksDao.search(sc, searchFilter); + } + + private List listDomainSpecificNetworksByDomainPath(SearchCriteria sc, Filter searchFilter, + String path, boolean isRecursive) { + + Set allowedDomains = new HashSet(); + if (path != null) { + if (isRecursive) { + allowedDomains = _domainMgr.getDomainChildrenIds(path); + } else { + Domain domain = _domainDao.findDomainByPath(path); + allowedDomains.add(domain.getId()); + } + } + + List networkIds = new ArrayList(); + + List maps = _networkDomainDao.listDomainNetworkMapByDomain(allowedDomains.toArray()); + + for (NetworkDomainVO map : maps) { + networkIds.add(map.getNetworkId()); + } + + if (!networkIds.isEmpty()) { + SearchCriteria domainSC = _networksDao.createSearchCriteria(); + domainSC.addAnd("id", SearchCriteria.Op.IN, networkIds.toArray()); + domainSC.addAnd("aclType", SearchCriteria.Op.EQ, ACLType.Domain.toString()); + + sc.addAnd("id", SearchCriteria.Op.SC, domainSC); + return _networksDao.search(sc, searchFilter); + } else { + return new ArrayList(); + } + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_NETWORK_DELETE, eventDescription = "deleting network", async = true) + public boolean deleteNetwork(long networkId) { + + Account caller = UserContext.current().getCaller(); + + // Verify network id + NetworkVO network = _networksDao.findById(networkId); + if (network == null) { + // see NetworkVO.java + + InvalidParameterValueException ex = new InvalidParameterValueException("unable to find network with specified id"); + ex.addProxyObject(network, networkId, "networkId"); + throw ex; + } + + // don't allow to delete system network + if (isNetworkSystem(network)) { + InvalidParameterValueException ex = new InvalidParameterValueException("Network with specified id is system and can't be removed"); + ex.addProxyObject(network, network.getId(), "networkId"); + throw ex; + } + + Account owner = _accountMgr.getAccount(network.getAccountId()); + + // Perform permission check + _accountMgr.checkAccess(caller, null, true, network); + + User callerUser = _accountMgr.getActiveUser(UserContext.current().getCallerUserId()); + ReservationContext context = new ReservationContextImpl(null, null, callerUser, owner); + + return _networkMgr.destroyNetwork(networkId, context); + } + + + @Override + @ActionEvent(eventType = EventTypes.EVENT_NETWORK_RESTART, eventDescription = "restarting network", async = true) + public boolean restartNetwork(RestartNetworkCmd cmd, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { + // This method restarts all network elements belonging to the network and re-applies all the rules + Long networkId = cmd.getNetworkId(); + + User callerUser = _accountMgr.getActiveUser(UserContext.current().getCallerUserId()); + Account callerAccount = _accountMgr.getActiveAccountById(callerUser.getAccountId()); + + // Check if network exists + NetworkVO network = _networksDao.findById(networkId); + if (network == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Network with specified id doesn't exist"); + ex.addProxyObject("networks", networkId, "networkId"); + throw ex; + } + + // Don't allow to restart network if it's not in Implemented/Setup state + if (!(network.getState() == Network.State.Implemented || network.getState() == Network.State.Setup)) { + throw new InvalidParameterValueException("Network is not in the right state to be restarted. Correct states are: " + Network.State.Implemented + ", " + Network.State.Setup); + } + + if (network.getBroadcastDomainType() == BroadcastDomainType.Lswitch ) { + /** + * Unable to restart these networks now. + * TODO Restarting a SDN based network requires updating the nics and the configuration + * in the controller. This requires a non-trivial rewrite of the restart procedure. + */ + throw new InvalidParameterException("Unable to restart a running SDN network."); + } + + _accountMgr.checkAccess(callerAccount, null, true, network); + + boolean success = _networkMgr.restartNetwork(networkId, callerAccount, callerUser, cleanup); + + if (success) { + s_logger.debug("Network id=" + networkId + " is restarted successfully."); + } else { + s_logger.warn("Network id=" + networkId + " failed to restart."); + } + + return success; + } + + @Override + public int getActiveNicsInNetwork(long networkId) { + return _networksDao.getActiveNicsIn(networkId); + } + + + + + + + protected Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) { + + if (!areServicesSupportedByNetworkOffering(offering.getId(), service)) { + // TBD: We should be sending networkOfferingId and not the offering object itself. + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the network offering " + offering); + } + + Map serviceCapabilities = new HashMap(); + + // get the Provider for this Service for this offering + List providers = _ntwkOfferingSrvcDao.listProvidersForServiceForNetworkOffering(offering.getId(), service); + if (providers.isEmpty()) { + // TBD: We should be sending networkOfferingId and not the offering object itself. + throw new InvalidParameterValueException("Service " + service.getName() + " is not supported by the network offering " + offering); + } + + // FIXME - in post 3.0 we are going to support multiple providers for the same service per network offering, so + // we have to calculate capabilities for all of them + String provider = providers.get(0); + + // FIXME we return the capabilities of the first provider of the service - what if we have multiple providers + // for same Service? + NetworkElement element = _networkModel.getElementImplementingProvider(provider); + if (element != null) { + Map> elementCapabilities = element.getCapabilities(); + ; + + if (elementCapabilities == null || !elementCapabilities.containsKey(service)) { + // TBD: We should be sending providerId and not the offering object itself. + throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider); + } + serviceCapabilities = elementCapabilities.get(service); + } + + return serviceCapabilities; + } + + + @Override + public IpAddress getIp(long ipAddressId) { + return _ipAddressDao.findById(ipAddressId); + } + + + protected boolean providersConfiguredForExternalNetworking(Collection providers) { + for(String providerStr : providers){ + Provider provider = Network.Provider.getProvider(providerStr); + if(provider.isExternal()){ + return true; + } + } + return false; + } + + protected boolean isSharedNetworkOfferingWithServices(long networkOfferingId) { + NetworkOfferingVO networkOffering = _networkOfferingDao.findById(networkOfferingId); + if ( (networkOffering.getGuestType() == Network.GuestType.Shared) && ( + areServicesSupportedByNetworkOffering(networkOfferingId, Service.SourceNat) || + areServicesSupportedByNetworkOffering(networkOfferingId, Service.StaticNat) || + areServicesSupportedByNetworkOffering(networkOfferingId, Service.Firewall) || + areServicesSupportedByNetworkOffering(networkOfferingId, Service.PortForwarding) || + areServicesSupportedByNetworkOffering(networkOfferingId, Service.Lb))) { + return true; + } + return false; + } + + + protected boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) { + return (_ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(networkOfferingId, services)); + } + + + protected boolean areServicesSupportedInNetwork(long networkId, Service... services) { + return (_ntwkSrvcDao.areServicesSupportedInNetwork(networkId, services)); + } + + + + + + + + private boolean checkForNonStoppedVmInNetwork(long networkId) { + List vms = _userVmDao.listByNetworkIdAndStates(networkId, VirtualMachine.State.Starting, + VirtualMachine.State.Running, VirtualMachine.State.Migrating, VirtualMachine.State.Stopping); + return vms.isEmpty(); + } + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_NETWORK_UPDATE, eventDescription = "updating network", async = true) + public Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, + User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr) { + boolean restartNetwork = false; + + // verify input parameters + NetworkVO network = _networksDao.findById(networkId); + if (network == null) { + // see NetworkVO.java + InvalidParameterValueException ex = new InvalidParameterValueException("Specified network id doesn't exist in the system"); + ex.addProxyObject("networks", networkId, "networkId"); + throw ex; + } + + // don't allow to update network in Destroy state + if (network.getState() == Network.State.Destroy) { + throw new InvalidParameterValueException("Don't allow to update network in state " + Network.State.Destroy); + } + + // Don't allow to update system network + NetworkOffering offering = _networkOfferingDao.findByIdIncludingRemoved(network.getNetworkOfferingId()); + if (offering.isSystemOnly()) { + throw new InvalidParameterValueException("Can't update system networks"); + } + + // allow to upgrade only Guest networks + if (network.getTrafficType() != Networks.TrafficType.Guest) { + throw new InvalidParameterValueException("Can't allow networks which traffic type is not " + TrafficType.Guest); + } + + _accountMgr.checkAccess(callerAccount, null, true, network); + + if (name != null) { + network.setName(name); + } + + if (displayText != null) { + network.setDisplayText(displayText); + } + + // network offering and domain suffix can be updated for Isolated networks only in 3.0 + if ((networkOfferingId != null || domainSuffix != null) && network.getGuestType() != GuestType.Isolated) { + throw new InvalidParameterValueException("NetworkOffering and domain suffix upgrade can be perfomed for Isolated networks only"); + } + + boolean networkOfferingChanged = false; + + long oldNetworkOfferingId = network.getNetworkOfferingId(); + if (networkOfferingId != null) { + + NetworkOfferingVO networkOffering = _networkOfferingDao.findById(networkOfferingId); + if (networkOffering == null || networkOffering.isSystemOnly()) { + InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find network offering with specified id"); + ex.addProxyObject(networkOffering, networkOfferingId, "networkOfferingId"); + throw ex; + } + + // network offering should be in Enabled state + if (networkOffering.getState() != NetworkOffering.State.Enabled) { + InvalidParameterValueException ex = new InvalidParameterValueException("Network offering with specified id is not in " + NetworkOffering.State.Enabled + " state, can't upgrade to it"); + ex.addProxyObject(networkOffering, networkOfferingId, "networkOfferingId"); + throw ex; + } + + + //can't update from vpc to non-vpc network offering + boolean forVpcNew = _configMgr.isOfferingForVpc(networkOffering); + boolean vorVpcOriginal = _configMgr.isOfferingForVpc(_configMgr.getNetworkOffering(oldNetworkOfferingId)); + if (forVpcNew != vorVpcOriginal) { + String errMsg = forVpcNew ? "a vpc offering " : "not a vpc offering"; + throw new InvalidParameterValueException("Can't update as the new offering is " + errMsg); + } + + if (networkOfferingId != oldNetworkOfferingId) { + NetworkOffering oldNtwkOff = _networkOfferingDao.findByIdIncludingRemoved(oldNetworkOfferingId); + Collection newProviders = _networkMgr.finalizeServicesAndProvidersForNetwork(networkOffering, network.getPhysicalNetworkId()).values(); + Collection oldProviders = _networkMgr.finalizeServicesAndProvidersForNetwork(oldNtwkOff, network.getPhysicalNetworkId()).values(); + + if (providersConfiguredForExternalNetworking(newProviders) != providersConfiguredForExternalNetworking(oldProviders) + && !changeCidr) { + throw new InvalidParameterValueException("Updating network failed since guest CIDR needs to be changed!"); + } + if (changeCidr) { + if (!checkForNonStoppedVmInNetwork(network.getId())) { + InvalidParameterValueException ex = new InvalidParameterValueException("All user vm of network of specified id should be stopped before changing CIDR!"); + ex.addProxyObject(network, networkId, "networkId"); + throw ex; + } + } + // check if the network is upgradable + if (!canUpgrade(network, oldNetworkOfferingId, networkOfferingId)) { + throw new InvalidParameterValueException("Can't upgrade from network offering " + oldNetworkOfferingId + " to " + networkOfferingId + "; check logs for more information"); + } + restartNetwork = true; + networkOfferingChanged = true; + } + } + Map newSvcProviders = new HashMap(); + if (networkOfferingChanged) { + newSvcProviders = _networkMgr.finalizeServicesAndProvidersForNetwork(_configMgr.getNetworkOffering(networkOfferingId), network.getPhysicalNetworkId()); + } + + // don't allow to modify network domain if the service is not supported + if (domainSuffix != null) { + // validate network domain + if (!NetUtils.verifyDomainName(domainSuffix)) { + throw new InvalidParameterValueException( + "Invalid network domain. Total length shouldn't exceed 190 chars. Each domain label must be between 1 and 63 characters long, can contain ASCII letters 'a' through 'z', the digits '0' through '9', " + + "and the hyphen ('-'); can't start or end with \"-\""); + } + + long offeringId = oldNetworkOfferingId; + if (networkOfferingId != null) { + offeringId = networkOfferingId; + } + + Map dnsCapabilities = getNetworkOfferingServiceCapabilities(_configMgr.getNetworkOffering(offeringId), Service.Dns); + String isUpdateDnsSupported = dnsCapabilities.get(Capability.AllowDnsSuffixModification); + if (isUpdateDnsSupported == null || !Boolean.valueOf(isUpdateDnsSupported)) { + // TBD: use uuid instead of networkOfferingId. May need to hardcode tablename in call to addProxyObject(). + throw new InvalidParameterValueException("Domain name change is not supported by the network offering id=" + networkOfferingId); + } + + network.setNetworkDomain(domainSuffix); + // have to restart the network + restartNetwork = true; + } + + ReservationContext context = new ReservationContextImpl(null, null, callerUser, callerAccount); + // 1) Shutdown all the elements and cleanup all the rules. Don't allow to shutdown network in intermediate + // states - Shutdown and Implementing + boolean validStateToShutdown = (network.getState() == Network.State.Implemented || network.getState() == Network.State.Setup || network.getState() == Network.State.Allocated); + if (restartNetwork) { + if (validStateToShutdown) { + if (!changeCidr) { + s_logger.debug("Shutting down elements and resources for network id=" + networkId + " as a part of network update"); + + if (!_networkMgr.shutdownNetworkElementsAndResources(context, true, network)) { + s_logger.warn("Failed to shutdown the network elements and resources as a part of network restart: " + network); + CloudRuntimeException ex = new CloudRuntimeException("Failed to shutdown the network elements and resources as a part of update to network of specified id"); + ex.addProxyObject(network, networkId, "networkId"); + throw ex; + } + } else { + // We need to shutdown the network, since we want to re-implement the network. + s_logger.debug("Shutting down network id=" + networkId + " as a part of network update"); + + if (!_networkMgr.shutdownNetwork(network.getId(), context, true)) { + s_logger.warn("Failed to shutdown the network as a part of update to network with specified id"); + CloudRuntimeException ex = new CloudRuntimeException("Failed to shutdown the network as a part of update of specified network id"); + ex.addProxyObject(network, networkId, "networkId"); + throw ex; + } + } + } else { + CloudRuntimeException ex = new CloudRuntimeException("Failed to shutdown the network elements and resources as a part of update to network with specified id; network is in wrong state: " + network.getState()); + ex.addProxyObject(network, networkId, "networkId"); + throw ex; + } + } + + // 2) Only after all the elements and rules are shutdown properly, update the network VO + // get updated network + Network.State networkState = _networksDao.findById(networkId).getState(); + boolean validStateToImplement = (networkState == Network.State.Implemented || networkState == Network.State.Setup || networkState == Network.State.Allocated); + if (restartNetwork && !validStateToImplement) { + CloudRuntimeException ex = new CloudRuntimeException("Failed to implement the network elements and resources as a part of update to network with specified id; network is in wrong state: " + networkState); + ex.addProxyObject(network, networkId, "networkId"); + throw ex; + } + + if (networkOfferingId != null) { + if (networkOfferingChanged) { + Transaction txn = Transaction.currentTxn(); + txn.start(); + network.setNetworkOfferingId(networkOfferingId); + _networksDao.update(networkId, network, newSvcProviders); + // get all nics using this network + // log remove usage events for old offering + // log assign usage events for new offering + List nics = _nicDao.listByNetworkId(networkId); + for (NicVO nic : nics) { + long vmId = nic.getInstanceId(); + VMInstanceVO vm = _vmDao.findById(vmId); + if (vm == null) { + s_logger.error("Vm for nic " + nic.getId() + " not found with Vm Id:" + vmId); + continue; + } + long isDefault = (nic.isDefaultNic()) ? 1 : 0; + UsageEventVO usageEvent = new UsageEventVO(EventTypes.EVENT_NETWORK_OFFERING_REMOVE, vm.getAccountId(), vm.getDataCenterIdToDeployIn(), vm.getId(), null, oldNetworkOfferingId, null, 0L); + _usageEventDao.persist(usageEvent); + usageEvent = new UsageEventVO(EventTypes.EVENT_NETWORK_OFFERING_ASSIGN, vm.getAccountId(), vm.getDataCenterIdToDeployIn(), vm.getId(), vm.getHostName(), networkOfferingId, null, isDefault); + _usageEventDao.persist(usageEvent); + } + txn.commit(); + } else { + network.setNetworkOfferingId(networkOfferingId); + _networksDao.update(networkId, network, _networkMgr.finalizeServicesAndProvidersForNetwork(_configMgr.getNetworkOffering(networkOfferingId), network.getPhysicalNetworkId())); + } + } else { + _networksDao.update(networkId, network); + } + + // 3) Implement the elements and rules again + if (restartNetwork) { + if (network.getState() != Network.State.Allocated) { + DeployDestination dest = new DeployDestination(_dcDao.findById(network.getDataCenterId()), null, null, null); + s_logger.debug("Implementing the network " + network + " elements and resources as a part of network update"); + try { + if (!changeCidr) { + _networkMgr.implementNetworkElementsAndResources(dest, context, network, _networkOfferingDao.findById(network.getNetworkOfferingId())); + } else { + _networkMgr.implementNetwork(network.getId(), dest, context); + } + } catch (Exception ex) { + s_logger.warn("Failed to implement network " + network + " elements and resources as a part of network update due to ", ex); + CloudRuntimeException e = new CloudRuntimeException("Failed to implement network (with specified id) elements and resources as a part of network update"); + e.addProxyObject(network, networkId, "networkId"); + throw e; + } + } + } + + return getNetwork(network.getId()); + } + + + + + protected Set getAvailableIps(Network network, String requestedIp) { + String[] cidr = network.getCidr().split("/"); + List ips = _nicDao.listIpAddressInNetwork(network.getId()); + Set allPossibleIps = NetUtils.getAllIpsFromCidr(cidr[0], Integer.parseInt(cidr[1])); + Set usedIps = new TreeSet(); + + for (String ip : ips) { + if (requestedIp != null && requestedIp.equals(ip)) { + s_logger.warn("Requested ip address " + requestedIp + " is already in use in network" + network); + return null; + } + + usedIps.add(NetUtils.ip2Long(ip)); + } + if (usedIps.size() != 0) { + allPossibleIps.removeAll(usedIps); + } + return allPossibleIps; + } + + + + protected boolean canUpgrade(Network network, long oldNetworkOfferingId, long newNetworkOfferingId) { + NetworkOffering oldNetworkOffering = _networkOfferingDao.findByIdIncludingRemoved(oldNetworkOfferingId); + NetworkOffering newNetworkOffering = _networkOfferingDao.findById(newNetworkOfferingId); + + // can upgrade only Isolated networks + if (oldNetworkOffering.getGuestType() != GuestType.Isolated) { + throw new InvalidParameterValueException("NetworkOfferingId can be upgraded only for the network of type " + GuestType.Isolated); + } + + // security group service should be the same + if (areServicesSupportedByNetworkOffering(oldNetworkOfferingId, Service.SecurityGroup) != areServicesSupportedByNetworkOffering(newNetworkOfferingId, Service.SecurityGroup)) { + s_logger.debug("Offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different securityGroupProperty, can't upgrade"); + return false; + } + + // Type of the network should be the same + if (oldNetworkOffering.getGuestType() != newNetworkOffering.getGuestType()) { + s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " are of different types, can't upgrade"); + return false; + } + + // tags should be the same + if (newNetworkOffering.getTags() != null) { + if (oldNetworkOffering.getTags() == null) { + s_logger.debug("New network offering id=" + newNetworkOfferingId + " has tags and old network offering id=" + oldNetworkOfferingId + " doesn't, can't upgrade"); + return false; + } + if (!oldNetworkOffering.getTags().equalsIgnoreCase(newNetworkOffering.getTags())) { + s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different tags, can't upgrade"); + return false; + } + } + + // Traffic types should be the same + if (oldNetworkOffering.getTrafficType() != newNetworkOffering.getTrafficType()) { + s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different traffic types, can't upgrade"); + return false; + } + + // specify vlan should be the same + if (oldNetworkOffering.getSpecifyVlan() != newNetworkOffering.getSpecifyVlan()) { + s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different values for specifyVlan, can't upgrade"); + return false; + } + + // specify ipRanges should be the same + if (oldNetworkOffering.getSpecifyIpRanges() != newNetworkOffering.getSpecifyIpRanges()) { + s_logger.debug("Network offerings " + newNetworkOfferingId + " and " + oldNetworkOfferingId + " have different values for specifyIpRangess, can't upgrade"); + return false; + } + + // Check all ips + List userIps = _ipAddressDao.listByAssociatedNetwork(network.getId(), null); + List publicIps = new ArrayList(); + if (userIps != null && !userIps.isEmpty()) { + for (IPAddressVO userIp : userIps) { + PublicIp publicIp = new PublicIp(userIp, _vlanDao.findById(userIp.getVlanId()), NetUtils.createSequenceBasedMacAddress(userIp.getMacAddress())); + publicIps.add(publicIp); + } + } + if (oldNetworkOffering.isConserveMode() && !newNetworkOffering.isConserveMode()) { + if (!canIpsUsedForNonConserve(publicIps)) { + return false; + } + } + + return canIpsUseOffering(publicIps, newNetworkOfferingId); + } + + + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_CREATE, eventDescription = "Creating Physical Network", create = true) + public PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, List + isolationMethods, String broadcastDomainRangeStr, Long domainId, List tags, String name) { + + // Check if zone exists + if (zoneId == null) { + throw new InvalidParameterValueException("Please specify a valid zone."); + } + + DataCenterVO zone = _dcDao.findById(zoneId); + if (zone == null) { + throw new InvalidParameterValueException("Please specify a valid zone."); + } + + if (Grouping.AllocationState.Enabled == zone.getAllocationState()) { + // TBD: Send uuid instead of zoneId; may have to hardcode tablename in call to addProxyObject(). + throw new PermissionDeniedException("Cannot create PhysicalNetwork since the Zone is currently enabled, zone Id: " + zoneId); + } + + NetworkType zoneType = zone.getNetworkType(); + + if (zoneType == NetworkType.Basic) { + if (!_physicalNetworkDao.listByZone(zoneId).isEmpty()) { + // TBD: Send uuid instead of zoneId; may have to hardcode tablename in call to addProxyObject(). + throw new CloudRuntimeException("Cannot add the physical network to basic zone id: " + zoneId + ", there is a physical network already existing in this basic Zone"); + } + } + if (tags != null && tags.size() > 1) { + throw new InvalidParameterException("Only one tag can be specified for a physical network at this time"); + } + + if (isolationMethods != null && isolationMethods.size() > 1) { + throw new InvalidParameterException("Only one isolationMethod can be specified for a physical network at this time"); + } + + int vnetStart = 0; + int vnetEnd = 0; + if (vnetRange != null) { + // Verify zone type + if (zoneType == NetworkType.Basic + || (zoneType == NetworkType.Advanced && zone.isSecurityGroupEnabled())) { + throw new InvalidParameterValueException("Can't add vnet range to the physical network in the zone that supports " + zoneType + " network, Security Group enabled: " + zone.isSecurityGroupEnabled()); + } + + String[] tokens = vnetRange.split("-"); + try { + vnetStart = Integer.parseInt(tokens[0]); + if (tokens.length == 1) { + vnetEnd = vnetStart; + } else { + vnetEnd = Integer.parseInt(tokens[1]); + } + } catch (NumberFormatException e) { + throw new InvalidParameterValueException("Please specify valid integers for the vlan range."); + } + + //check for vnet conflicts with other physical network(s) in the zone + checkGuestVnetsConflicts(zoneId, vnetStart, vnetEnd, null); + + if ((vnetStart > vnetEnd) || (vnetStart < 0) || (vnetEnd > 4096)) { + s_logger.warn("Invalid vnet range: start range:" + vnetStart + " end range:" + vnetEnd); + throw new InvalidParameterValueException("Vnet range should be between 0-4096 and start range should be lesser than or equal to end range"); + } + } + + BroadcastDomainRange broadcastDomainRange = null; + if (broadcastDomainRangeStr != null && !broadcastDomainRangeStr.isEmpty()) { + try { + broadcastDomainRange = PhysicalNetwork.BroadcastDomainRange.valueOf(broadcastDomainRangeStr.toUpperCase()); + } catch (IllegalArgumentException ex) { + throw new InvalidParameterValueException("Unable to resolve broadcastDomainRange '" + broadcastDomainRangeStr + "' to a supported value {Pod or Zone}"); + } + + // in Acton release you can specify only Zone broadcastdomain type in Advance zone, and Pod in Basic + if (zoneType == NetworkType.Basic && broadcastDomainRange != null && broadcastDomainRange != BroadcastDomainRange.POD) { + throw new InvalidParameterValueException("Basic zone can have broadcast domain type of value " + BroadcastDomainRange.POD + " only"); + } else if (zoneType == NetworkType.Advanced && broadcastDomainRange != null && broadcastDomainRange != BroadcastDomainRange.ZONE) { + throw new InvalidParameterValueException("Advance zone can have broadcast domain type of value " + BroadcastDomainRange.ZONE + " only"); + } + } + + if (broadcastDomainRange == null) { + if (zoneType == NetworkType.Basic) { + broadcastDomainRange = PhysicalNetwork.BroadcastDomainRange.POD; + } else { + broadcastDomainRange = PhysicalNetwork.BroadcastDomainRange.ZONE; + } + } + + Transaction txn = Transaction.currentTxn(); + try { + txn.start(); + // Create the new physical network in the database + long id = _physicalNetworkDao.getNextInSequence(Long.class, "id"); + PhysicalNetworkVO pNetwork = new PhysicalNetworkVO(id, zoneId, vnetRange, networkSpeed, domainId, broadcastDomainRange, name); + pNetwork.setTags(tags); + pNetwork.setIsolationMethods(isolationMethods); + + pNetwork = _physicalNetworkDao.persist(pNetwork); + + // Add vnet entries for the new zone if zone type is Advanced + if (vnetRange != null) { + _dcDao.addVnet(zone.getId(), pNetwork.getId(), vnetStart, vnetEnd); + } + + // add VirtualRouter as the default network service provider + addDefaultVirtualRouterToPhysicalNetwork(pNetwork.getId()); + + // add security group provider to the physical network + addDefaultSecurityGroupProviderToPhysicalNetwork(pNetwork.getId()); + + // add VPCVirtualRouter as the defualt network service provider + addDefaultVpcVirtualRouterToPhysicalNetwork(pNetwork.getId()); + + txn.commit(); + return pNetwork; + } catch (Exception ex) { + s_logger.warn("Exception: ", ex); + throw new CloudRuntimeException("Fail to create a physical network"); + } + } + + @Override + public Pair, Integer> searchPhysicalNetworks(Long id, Long zoneId, String keyword, Long startIndex, Long pageSize, String name) { + Filter searchFilter = new Filter(PhysicalNetworkVO.class, "id", Boolean.TRUE, startIndex, pageSize); + SearchCriteria sc = _physicalNetworkDao.createSearchCriteria(); + + if (id != null) { + sc.addAnd("id", SearchCriteria.Op.EQ, id); + } + + if (zoneId != null) { + sc.addAnd("dataCenterId", SearchCriteria.Op.EQ, zoneId); + } + + if (name != null) { + sc.addAnd("name", SearchCriteria.Op.LIKE, "%" + name + "%"); + } + + Pair, Integer> result = _physicalNetworkDao.searchAndCount(sc, searchFilter); + return new Pair, Integer>(result.first(), result.second()); + } + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_UPDATE, eventDescription = "updating physical network", async = true) + public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List tags, String newVnetRangeString, String state) { + + // verify input parameters + PhysicalNetworkVO network = _physicalNetworkDao.findById(id); + if (network == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); + ex.addProxyObject(network, id, "physicalNetworkId"); + throw ex; + } + + // if zone is of Basic type, don't allow to add vnet range + DataCenter zone = _dcDao.findById(network.getDataCenterId()); + if (zone == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Zone with id=" + network.getDataCenterId() + " doesn't exist in the system"); + ex.addProxyObject(zone, network.getDataCenterId(), "dataCenterId"); + throw ex; + } + if (newVnetRangeString != null) { + if (zone.getNetworkType() == NetworkType.Basic + || (zone.getNetworkType() == NetworkType.Advanced && zone.isSecurityGroupEnabled())) { + throw new InvalidParameterValueException("Can't add vnet range to the physical network in the zone that supports " + zone.getNetworkType() + " network, Security Group enabled: " + + zone.isSecurityGroupEnabled()); + } + } + + if (tags != null && tags.size() > 1) { + throw new InvalidParameterException("Unable to support more than one tag on network yet"); + } + + PhysicalNetwork.State networkState = null; + if (state != null && !state.isEmpty()) { + try { + networkState = PhysicalNetwork.State.valueOf(state); + } catch (IllegalArgumentException ex) { + throw new InvalidParameterValueException("Unable to resolve state '" + state + "' to a supported value {Enabled or Disabled}"); + } + } + + if (state != null) { + network.setState(networkState); + } + + if (tags != null) { + network.setTags(tags); + } + + if (networkSpeed != null) { + network.setSpeed(networkSpeed); + } + + // Vnet range can be extended only + boolean replaceVnet = false; + ArrayList> vnetsToAdd = new ArrayList>(2); + + if (newVnetRangeString != null) { + Integer newStartVnet = 0; + Integer newEndVnet = 0; + String[] newVnetRange = newVnetRangeString.split("-"); + int maxVnet = 4096; + // for GRE phynets allow up to 32bits + // TODO: Not happy about this test. + // What about guru-like objects for physical networs? + s_logger.debug("ISOLATION METHODS:" + network.getIsolationMethods()); + // Java does not have unsigned types... + if (network.getIsolationMethods().contains("GRE")) { + maxVnet = (int)(Math.pow(2, 32)-1); + } + String rangeMessage = " between 0 and " + maxVnet; + if (newVnetRange.length < 2) { + throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage); + } + + if (newVnetRange[0] == null || newVnetRange[1] == null) { + throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage); + } + + try { + newStartVnet = Integer.parseInt(newVnetRange[0]); + newEndVnet = Integer.parseInt(newVnetRange[1]); + } catch (NumberFormatException e) { + s_logger.warn("Unable to parse vnet range:", e); + throw new InvalidParameterValueException("Please provide valid vnet range" + rangeMessage); + } + if (newStartVnet < 0 || newEndVnet > maxVnet) { + throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage); + } + + if (newStartVnet > newEndVnet) { + throw new InvalidParameterValueException("Vnet range has to be" + rangeMessage + " and start range should be lesser than or equal to stop range"); + } + + //check if new vnet conflicts with vnet ranges of other physical networks + checkGuestVnetsConflicts(network.getDataCenterId(), newStartVnet, newEndVnet, network.getId()); + + if (physicalNetworkHasAllocatedVnets(network.getDataCenterId(), network.getId())) { + String[] existingRange = network.getVnet().split("-"); + int existingStartVnet = Integer.parseInt(existingRange[0]); + int existingEndVnet = Integer.parseInt(existingRange[1]); + + // check if vnet is being extended + if (newStartVnet.intValue() > existingStartVnet || newEndVnet.intValue() < existingEndVnet) { + throw new InvalidParameterValueException("Can't shrink existing vnet range as it the range has vnets allocated. Only extending existing vnet is supported"); + } + + if (newStartVnet < existingStartVnet) { + vnetsToAdd.add(new Pair(newStartVnet, existingStartVnet - 1)); + } + + if (newEndVnet > existingEndVnet) { + vnetsToAdd.add(new Pair(existingEndVnet + 1, newEndVnet)); + } + + } else { + vnetsToAdd.add(new Pair(newStartVnet, newEndVnet)); + replaceVnet = true; + } + } + + if (newVnetRangeString != null) { + network.setVnet(newVnetRangeString); + } + + _physicalNetworkDao.update(id, network); + + if (replaceVnet) { + s_logger.debug("Deleting existing vnet range for the physicalNetwork id= " + id + " and zone id=" + network.getDataCenterId() + " as a part of updatePhysicalNetwork call"); + _dcDao.deleteVnet(network.getId()); + } + + for (Pair vnetToAdd : vnetsToAdd) { + s_logger.debug("Adding vnet range " + vnetToAdd.first() + "-" + vnetToAdd.second() + " for the physicalNetwork id= " + id + " and zone id=" + network.getDataCenterId() + + " as a part of updatePhysicalNetwork call"); + _dcDao.addVnet(network.getDataCenterId(), network.getId(), vnetToAdd.first(), vnetToAdd.second()); + } + + return network; + } + + protected void checkGuestVnetsConflicts(long zoneId, int newStartVnet, int newEndVnet, Long pNtwkIdToSkip) { + List pNtwks = _physicalNetworkDao.listByZone(zoneId); + for (PhysicalNetwork pNtwk : pNtwks) { + // skip my own network and networks that don't have vnet range set + if ((pNtwk.getVnet() == null || pNtwk.getVnet().isEmpty()) || (pNtwkIdToSkip != null && pNtwkIdToSkip == pNtwk.getId())) { + continue; + } + String[] existingRange = pNtwk.getVnet().split("-"); + int startVnet = Integer.parseInt(existingRange[0]); + int endVnet = Integer.parseInt(existingRange[1]); + if ((newStartVnet >= startVnet && newStartVnet <= endVnet) + || (newEndVnet <= endVnet && newEndVnet >= startVnet)) { + throw new InvalidParameterValueException("Vnet range for physical network conflicts with another " + + "physical network's vnet in the zone"); + } + } + } + + private boolean physicalNetworkHasAllocatedVnets(long zoneId, long physicalNetworkId) { + return !_dcDao.listAllocatedVnets(physicalNetworkId).isEmpty(); + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_DELETE, eventDescription = "deleting physical network", async = true) + @DB + public boolean deletePhysicalNetwork(Long physicalNetworkId) { + + // verify input parameters + PhysicalNetworkVO pNetwork = _physicalNetworkDao.findById(physicalNetworkId); + if (pNetwork == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); + ex.addProxyObject(pNetwork, physicalNetworkId, "physicalNetworkId"); + throw ex; + } + + checkIfPhysicalNetworkIsDeletable(physicalNetworkId); + + Transaction txn = Transaction.currentTxn(); + txn.start(); + // delete vlans for this zone + List vlans = _vlanDao.listVlansByPhysicalNetworkId(physicalNetworkId); + for (VlanVO vlan : vlans) { + _vlanDao.remove(vlan.getId()); + } + + // Delete networks + List networks = _networksDao.listByPhysicalNetwork(physicalNetworkId); + if (networks != null && !networks.isEmpty()) { + for (NetworkVO network : networks) { + _networksDao.remove(network.getId()); + } + } + + // delete vnets + _dcDao.deleteVnet(physicalNetworkId); + + // delete service providers + List providers = _pNSPDao.listBy(physicalNetworkId); + + for(PhysicalNetworkServiceProviderVO provider : providers){ + try { + deleteNetworkServiceProvider(provider.getId()); + }catch (ResourceUnavailableException e) { + s_logger.warn("Unable to complete destroy of the physical network provider: " + provider.getProviderName() + ", id: "+ provider.getId(), e); + return false; + } catch (ConcurrentOperationException e) { + s_logger.warn("Unable to complete destroy of the physical network provider: " + provider.getProviderName() + ", id: "+ provider.getId(), e); + return false; + } + } + + // delete traffic types + _pNTrafficTypeDao.deleteTrafficTypes(physicalNetworkId); + + boolean success = _physicalNetworkDao.remove(physicalNetworkId); + + txn.commit(); + + return success; + } + + @DB + protected void checkIfPhysicalNetworkIsDeletable(Long physicalNetworkId) { + List> tablesToCheck = new ArrayList>(); + + List vnet = new ArrayList(); + vnet.add(0, "op_dc_vnet_alloc"); + vnet.add(1, "physical_network_id"); + vnet.add(2, "there are allocated vnets for this physical network"); + tablesToCheck.add(vnet); + + List networks = new ArrayList(); + networks.add(0, "networks"); + networks.add(1, "physical_network_id"); + networks.add(2, "there are networks associated to this physical network"); + tablesToCheck.add(networks); + + /* + * List privateIP = new ArrayList(); + * privateIP.add(0, "op_dc_ip_address_alloc"); + * privateIP.add(1, "data_center_id"); + * privateIP.add(2, "there are private IP addresses allocated for this zone"); + * tablesToCheck.add(privateIP); + */ + + List publicIP = new ArrayList(); + publicIP.add(0, "user_ip_address"); + publicIP.add(1, "physical_network_id"); + publicIP.add(2, "there are public IP addresses allocated for this physical network"); + tablesToCheck.add(publicIP); + + for (List table : tablesToCheck) { + String tableName = table.get(0); + String column = table.get(1); + String errorMsg = table.get(2); + + String dbName = "cloud"; + + String selectSql = "SELECT * FROM `" + dbName + "`.`" + tableName + "` WHERE " + column + " = ?"; + + if (tableName.equals("networks")) { + selectSql += " AND removed is NULL"; + } + + if (tableName.equals("op_dc_vnet_alloc")) { + selectSql += " AND taken IS NOT NULL"; + } + + if (tableName.equals("user_ip_address")) { + selectSql += " AND state!='Free'"; + } + + if (tableName.equals("op_dc_ip_address_alloc")) { + selectSql += " AND taken IS NOT NULL"; + } + + Transaction txn = Transaction.currentTxn(); + try { + PreparedStatement stmt = txn.prepareAutoCloseStatement(selectSql); + stmt.setLong(1, physicalNetworkId); + ResultSet rs = stmt.executeQuery(); + if (rs != null && rs.next()) { + throw new CloudRuntimeException("The Physical Network is not deletable because " + errorMsg); + } + } catch (SQLException ex) { + throw new CloudRuntimeException("The Management Server failed to detect if physical network is deletable. Please contact Cloud Support."); + } + } + + } + + @Override + public List listNetworkServices(String providerName) { + + Provider provider = null; + if (providerName != null) { + provider = Network.Provider.getProvider(providerName); + if (provider == null) { + throw new InvalidParameterValueException("Invalid Network Service Provider=" + providerName); + } + } + + if (provider != null) { + NetworkElement element = _networkModel.getElementImplementingProvider(providerName); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + providerName + "'"); + } + return new ArrayList(element.getCapabilities().keySet()); + } else { + return Service.listAllServices(); + } + } + + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_CREATE, eventDescription = "Creating Physical Network ServiceProvider", create = true) + public PhysicalNetworkServiceProvider addProviderToPhysicalNetwork(Long physicalNetworkId, String providerName, Long destinationPhysicalNetworkId, List enabledServices) { + + // verify input parameters + PhysicalNetworkVO network = _physicalNetworkDao.findById(physicalNetworkId); + if (network == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); + ex.addProxyObject(network, physicalNetworkId, "physicalNetworkId"); + throw ex; + } + + // verify input parameters + if (destinationPhysicalNetworkId != null) { + PhysicalNetworkVO destNetwork = _physicalNetworkDao.findById(destinationPhysicalNetworkId); + if (destNetwork == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Destination Physical Network with specified id doesn't exist in the system"); + ex.addProxyObject(destNetwork, destinationPhysicalNetworkId, "destinationPhysicalNetworkId"); + throw ex; + } + } + + if (providerName != null) { + Provider provider = Network.Provider.getProvider(providerName); + if (provider == null) { + throw new InvalidParameterValueException("Invalid Network Service Provider=" + providerName); + } + } + + if (_pNSPDao.findByServiceProvider(physicalNetworkId, providerName) != null) { + // TBD: send uuid instead of physicalNetworkId. + throw new CloudRuntimeException("The '" + providerName + "' provider already exists on physical network : " + physicalNetworkId); + } + + // check if services can be turned off + NetworkElement element = _networkModel.getElementImplementingProvider(providerName); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + providerName + "'"); + } + List services = new ArrayList(); + + if (enabledServices != null) { + if (!element.canEnableIndividualServices()) { + if (enabledServices.size() != element.getCapabilities().keySet().size()) { + throw new InvalidParameterValueException("Cannot enable subset of Services, Please specify the complete list of Services for this Service Provider '" + providerName + "'"); + } + } + + // validate Services + boolean addGatewayService = false; + for (String serviceName : enabledServices) { + Network.Service service = Network.Service.getService(serviceName); + if (service == null || service == Service.Gateway) { + throw new InvalidParameterValueException("Invalid Network Service specified=" + serviceName); + } else if (service == Service.SourceNat) { + addGatewayService = true; + } + + // check if the service is provided by this Provider + if (!element.getCapabilities().containsKey(service)) { + throw new InvalidParameterValueException(providerName + " Provider cannot provide this Service specified=" + serviceName); + } + services.add(service); + } + + if (addGatewayService) { + services.add(Service.Gateway); + } + } else { + // enable all the default services supported by this element. + services = new ArrayList(element.getCapabilities().keySet()); + } + + Transaction txn = Transaction.currentTxn(); + try { + txn.start(); + // Create the new physical network in the database + PhysicalNetworkServiceProviderVO nsp = new PhysicalNetworkServiceProviderVO(physicalNetworkId, providerName); + // set enabled services + nsp.setEnabledServices(services); + + if (destinationPhysicalNetworkId != null) { + nsp.setDestinationPhysicalNetworkId(destinationPhysicalNetworkId); + } + nsp = _pNSPDao.persist(nsp); + + txn.commit(); + return nsp; + } catch (Exception ex) { + s_logger.warn("Exception: ", ex); + throw new CloudRuntimeException("Fail to add a provider to physical network"); + } + + } + + @Override + public Pair, Integer> listNetworkServiceProviders(Long physicalNetworkId, + String name, String state, Long startIndex, Long pageSize) { + + Filter searchFilter = new Filter(PhysicalNetworkServiceProviderVO.class, "id", false, startIndex, pageSize); + SearchBuilder sb = _pNSPDao.createSearchBuilder(); + SearchCriteria sc = sb.create(); + + if (physicalNetworkId != null) { + sc.addAnd("physicalNetworkId", Op.EQ, physicalNetworkId); + } + + if (name != null) { + sc.addAnd("providerName", Op.EQ, name); + } + + if (state != null) { + sc.addAnd("state", Op.EQ, state); + } + + Pair, Integer> result = _pNSPDao.searchAndCount(sc, searchFilter); + return new Pair, Integer>(result.first(), result.second()); + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_UPDATE, eventDescription = "Updating physical network ServiceProvider", async = true) + public PhysicalNetworkServiceProvider updateNetworkServiceProvider(Long id, String stateStr, List enabledServices) { + + PhysicalNetworkServiceProviderVO provider = _pNSPDao.findById(id); + if (provider == null) { + throw new InvalidParameterValueException("Network Service Provider id=" + id + "doesn't exist in the system"); + } + + NetworkElement element = _networkModel.getElementImplementingProvider(provider.getProviderName()); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getProviderName() + "'"); + } + + PhysicalNetworkServiceProvider.State state = null; + if (stateStr != null && !stateStr.isEmpty()) { + try { + state = PhysicalNetworkServiceProvider.State.valueOf(stateStr); + } catch (IllegalArgumentException ex) { + throw new InvalidParameterValueException("Unable to resolve state '" + stateStr + "' to a supported value {Enabled or Disabled}"); + } + } + + boolean update = false; + + if (state != null) { + if (state == PhysicalNetworkServiceProvider.State.Shutdown) { + throw new InvalidParameterValueException("Updating the provider state to 'Shutdown' is not supported"); + } + + if (s_logger.isDebugEnabled()) { + s_logger.debug("updating state of the service provider id=" + id + " on physical network: " + provider.getPhysicalNetworkId() + " to state: " + stateStr); + } + switch (state) { + case Enabled: + if (element != null && element.isReady(provider)) { + provider.setState(PhysicalNetworkServiceProvider.State.Enabled); + update = true; + } else { + throw new CloudRuntimeException("Provider is not ready, cannot Enable the provider, please configure the provider first"); + } + break; + case Disabled: + // do we need to do anything for the provider instances before disabling? + provider.setState(PhysicalNetworkServiceProvider.State.Disabled); + update = true; + break; + } + } + + if (enabledServices != null) { + // check if services can be turned of + if (!element.canEnableIndividualServices()) { + throw new InvalidParameterValueException("Cannot update set of Services for this Service Provider '" + provider.getProviderName() + "'"); + } + + // validate Services + List services = new ArrayList(); + for (String serviceName : enabledServices) { + Network.Service service = Network.Service.getService(serviceName); + if (service == null) { + throw new InvalidParameterValueException("Invalid Network Service specified=" + serviceName); + } + services.add(service); + } + // set enabled services + provider.setEnabledServices(services); + update = true; + } + + if (update) { + _pNSPDao.update(id, provider); + } + return provider; + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_DELETE, eventDescription = "Deleting physical network ServiceProvider", async = true) + public boolean deleteNetworkServiceProvider(Long id) throws ConcurrentOperationException, ResourceUnavailableException { + PhysicalNetworkServiceProviderVO provider = _pNSPDao.findById(id); + + if (provider == null) { + throw new InvalidParameterValueException("Network Service Provider id=" + id + "doesn't exist in the system"); + } + + // check if there are networks using this provider + List networks = _networksDao.listByPhysicalNetworkAndProvider(provider.getPhysicalNetworkId(), provider.getProviderName()); + if (networks != null && !networks.isEmpty()) { + throw new CloudRuntimeException("Provider is not deletable because there are active networks using this provider, please upgrade these networks to new network offerings"); + } + + User callerUser = _accountMgr.getActiveUser(UserContext.current().getCallerUserId()); + Account callerAccount = _accountMgr.getActiveAccountById(callerUser.getAccountId()); + // shutdown the provider instances + ReservationContext context = new ReservationContextImpl(null, null, callerUser, callerAccount); + if (s_logger.isDebugEnabled()) { + s_logger.debug("Shutting down the service provider id=" + id + " on physical network: " + provider.getPhysicalNetworkId()); + } + NetworkElement element = _networkModel.getElementImplementingProvider(provider.getProviderName()); + if (element == null) { + throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getProviderName() + "'"); + } + + if (element != null && element.shutdownProviderInstances(provider, context)) { + provider.setState(PhysicalNetworkServiceProvider.State.Shutdown); + } + + return _pNSPDao.remove(id); + } + + @Override + public PhysicalNetwork getPhysicalNetwork(Long physicalNetworkId) { + return _physicalNetworkDao.findById(physicalNetworkId); + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_PHYSICAL_NETWORK_CREATE, eventDescription = "Creating Physical Network", async = true) + public PhysicalNetwork getCreatedPhysicalNetwork(Long physicalNetworkId) { + return getPhysicalNetwork(physicalNetworkId); + } + + @Override + public PhysicalNetworkServiceProvider getPhysicalNetworkServiceProvider(Long providerId) { + return _pNSPDao.findById(providerId); + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_SERVICE_PROVIDER_CREATE, eventDescription = "Creating Physical Network ServiceProvider", async = true) + public PhysicalNetworkServiceProvider getCreatedPhysicalNetworkServiceProvider(Long providerId) { + return getPhysicalNetworkServiceProvider(providerId); + } + + @Override + public long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType) { + List pNtwks = new ArrayList(); + if (trafficType != null) { + pNtwks = _physicalNetworkDao.listByZoneAndTrafficType(zoneId, trafficType); + } else { + pNtwks = _physicalNetworkDao.listByZone(zoneId); + } + + if (pNtwks.isEmpty()) { + throw new InvalidParameterValueException("Unable to find physical network in zone id=" + zoneId); + } + + if (pNtwks.size() > 1) { + if (tag == null) { + throw new InvalidParameterValueException("More than one physical networks exist in zone id=" + zoneId + " and no tags are specified in order to make a choice"); + } + + Long pNtwkId = null; + for (PhysicalNetwork pNtwk : pNtwks) { + if (pNtwk.getTags().contains(tag)) { + s_logger.debug("Found physical network id=" + pNtwk.getId() + " based on requested tags " + tag); + pNtwkId = pNtwk.getId(); + break; + } + } + if (pNtwkId == null) { + throw new InvalidParameterValueException("Unable to find physical network which match the tags " + tag); + } + return pNtwkId; + } else { + return pNtwks.get(0).getId(); + } + } + + + + @Override + @DB + @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_CREATE, eventDescription = "Creating Physical Network TrafficType", create = true) + public PhysicalNetworkTrafficType addTrafficTypeToPhysicalNetwork(Long physicalNetworkId, String trafficTypeStr, String xenLabel, String kvmLabel, String vmwareLabel, String simulatorLabel, String vlan) { + + // verify input parameters + PhysicalNetworkVO network = _physicalNetworkDao.findById(physicalNetworkId); + if (network == null) { + throw new InvalidParameterValueException("Physical Network id=" + physicalNetworkId + "doesn't exist in the system"); + } + + Networks.TrafficType trafficType = null; + if (trafficTypeStr != null && !trafficTypeStr.isEmpty()) { + try { + trafficType = Networks.TrafficType.valueOf(trafficTypeStr); + } catch (IllegalArgumentException ex) { + throw new InvalidParameterValueException("Unable to resolve trafficType '" + trafficTypeStr + "' to a supported value"); + } + } + + if (_pNTrafficTypeDao.isTrafficTypeSupported(physicalNetworkId, trafficType)) { + throw new CloudRuntimeException("This physical network already supports the traffic type: " + trafficType); + } + // For Storage, Control, Management, Public check if the zone has any other physical network with this + // traffictype already present + // If yes, we cant add these traffics to one more physical network in the zone. + + if (TrafficType.isSystemNetwork(trafficType) || TrafficType.Public.equals(trafficType) || TrafficType.Storage.equals(trafficType)) { + if (!_physicalNetworkDao.listByZoneAndTrafficType(network.getDataCenterId(), trafficType).isEmpty()) { + throw new CloudRuntimeException("Fail to add the traffic type to physical network because Zone already has a physical network with this traffic type: " + trafficType); + } + } + + if (TrafficType.Storage.equals(trafficType)) { + List ssvms = _stnwMgr.getSSVMWithNoStorageNetwork(network.getDataCenterId()); + if (!ssvms.isEmpty()) { + StringBuilder sb = new StringBuilder( + "Cannot add " + + trafficType + + " traffic type as there are below secondary storage vm still running. Please stop them all and add Storage traffic type again, then destory them all to allow CloudStack recreate them with storage network(If you have added storage network ip range)"); + sb.append("SSVMs:"); + for (SecondaryStorageVmVO ssvm : ssvms) { + sb.append(ssvm.getInstanceName()).append(":").append(ssvm.getState()); + } + throw new CloudRuntimeException(sb.toString()); + } + } + + Transaction txn = Transaction.currentTxn(); + try { + txn.start(); + // Create the new traffic type in the database + if (xenLabel == null) { + xenLabel = getDefaultXenNetworkLabel(trafficType); + } + PhysicalNetworkTrafficTypeVO pNetworktrafficType = new PhysicalNetworkTrafficTypeVO(physicalNetworkId, trafficType, xenLabel, kvmLabel, vmwareLabel, simulatorLabel, vlan); + pNetworktrafficType = _pNTrafficTypeDao.persist(pNetworktrafficType); + + txn.commit(); + return pNetworktrafficType; + } catch (Exception ex) { + s_logger.warn("Exception: ", ex); + throw new CloudRuntimeException("Fail to add a traffic type to physical network"); + } + + } + + private String getDefaultXenNetworkLabel(TrafficType trafficType) { + String xenLabel = null; + switch (trafficType) { + case Public: + xenLabel = _configDao.getValue(Config.XenPublicNetwork.key()); + break; + case Guest: + xenLabel = _configDao.getValue(Config.XenGuestNetwork.key()); + break; + case Storage: + xenLabel = _configDao.getValue(Config.XenStorageNetwork1.key()); + break; + case Management: + xenLabel = _configDao.getValue(Config.XenPrivateNetwork.key()); + break; + case Control: + xenLabel = "cloud_link_local_network"; + break; + } + return xenLabel; + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_CREATE, eventDescription = "Creating Physical Network TrafficType", async = true) + public PhysicalNetworkTrafficType getPhysicalNetworkTrafficType(Long id) { + return _pNTrafficTypeDao.findById(id); + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_UPDATE, eventDescription = "Updating physical network TrafficType", async = true) + public PhysicalNetworkTrafficType updatePhysicalNetworkTrafficType(Long id, String xenLabel, String kvmLabel, String vmwareLabel) { + + PhysicalNetworkTrafficTypeVO trafficType = _pNTrafficTypeDao.findById(id); + + if (trafficType == null) { + throw new InvalidParameterValueException("Traffic Type with id=" + id + "doesn't exist in the system"); + } + + if (xenLabel != null) { + if("".equals(xenLabel)){ + xenLabel = null; + } + trafficType.setXenNetworkLabel(xenLabel); + } + if (kvmLabel != null) { + if("".equals(kvmLabel)){ + kvmLabel = null; + } + trafficType.setKvmNetworkLabel(kvmLabel); + } + if (vmwareLabel != null) { + if("".equals(vmwareLabel)){ + vmwareLabel = null; + } + trafficType.setVmwareNetworkLabel(vmwareLabel); + } + _pNTrafficTypeDao.update(id, trafficType); + + return trafficType; + } + + @Override + @ActionEvent(eventType = EventTypes.EVENT_TRAFFIC_TYPE_DELETE, eventDescription = "Deleting physical network TrafficType", async = true) + public boolean deletePhysicalNetworkTrafficType(Long id) { + PhysicalNetworkTrafficTypeVO trafficType = _pNTrafficTypeDao.findById(id); + + if (trafficType == null) { + throw new InvalidParameterValueException("Traffic Type with id=" + id + "doesn't exist in the system"); + } + + // check if there are any networks associated to this physical network with this traffic type + if (TrafficType.Guest.equals(trafficType.getTrafficType())) { + if (!_networksDao.listByPhysicalNetworkTrafficType(trafficType.getPhysicalNetworkId(), trafficType.getTrafficType()).isEmpty()) { + throw new CloudRuntimeException("The Traffic Type is not deletable because there are existing networks with this traffic type:" + trafficType.getTrafficType()); + } + } else if (TrafficType.Storage.equals(trafficType.getTrafficType())) { + PhysicalNetworkVO pn = _physicalNetworkDao.findById(trafficType.getPhysicalNetworkId()); + if (_stnwMgr.isAnyStorageIpInUseInZone(pn.getDataCenterId())) { + throw new CloudRuntimeException("The Traffic Type is not deletable because there are still some storage network ip addresses in use:" + trafficType.getTrafficType()); + } + } + return _pNTrafficTypeDao.remove(id); + } + + @Override + public Pair, Integer> listTrafficTypes(Long physicalNetworkId) { + PhysicalNetworkVO network = _physicalNetworkDao.findById(physicalNetworkId); + if (network == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Physical Network with specified id doesn't exist in the system"); + ex.addProxyObject(network, physicalNetworkId, "physicalNetworkId"); + throw ex; + } + + Pair, Integer> result = _pNTrafficTypeDao.listAndCountBy(physicalNetworkId); + return new Pair, Integer>(result.first(), result.second()); + } + + + + + + @Override //TODO: duplicated in NetworkModel + public NetworkVO getExclusiveGuestNetwork(long zoneId) { + List networks = _networksDao.listBy(Account.ACCOUNT_ID_SYSTEM, zoneId, GuestType.Shared, TrafficType.Guest); + if (networks == null || networks.isEmpty()) { + throw new InvalidParameterValueException("Unable to find network with trafficType " + TrafficType.Guest + " and guestType " + GuestType.Shared + " in zone " + zoneId); + } + + if (networks.size() > 1) { + throw new InvalidParameterValueException("Found more than 1 network with trafficType " + TrafficType.Guest + " and guestType " + GuestType.Shared + " in zone " + zoneId); + + } + + return networks.get(0); + } + + protected PhysicalNetworkServiceProvider addDefaultVirtualRouterToPhysicalNetwork(long physicalNetworkId) { + + PhysicalNetworkServiceProvider nsp = addProviderToPhysicalNetwork(physicalNetworkId, Network.Provider.VirtualRouter.getName(), null, null); + // add instance of the provider + VirtualRouterElement element = (VirtualRouterElement) _networkModel.getElementImplementingProvider(Network.Provider.VirtualRouter.getName()); + if (element == null) { + throw new CloudRuntimeException("Unable to find the Network Element implementing the VirtualRouter Provider"); + } + element.addElement(nsp.getId(), VirtualRouterProviderType.VirtualRouter); + + return nsp; + } + + protected PhysicalNetworkServiceProvider addDefaultVpcVirtualRouterToPhysicalNetwork(long physicalNetworkId) { + + PhysicalNetworkServiceProvider nsp = addProviderToPhysicalNetwork(physicalNetworkId, + Network.Provider.VPCVirtualRouter.getName(), null, null); + // add instance of the provider + VpcVirtualRouterElement element = (VpcVirtualRouterElement) _networkModel.getElementImplementingProvider(Network.Provider.VPCVirtualRouter.getName()); + if (element == null) { + throw new CloudRuntimeException("Unable to find the Network Element implementing the VPCVirtualRouter Provider"); + } + element.addElement(nsp.getId(), VirtualRouterProviderType.VPCVirtualRouter); + + return nsp; + } + + protected PhysicalNetworkServiceProvider addDefaultSecurityGroupProviderToPhysicalNetwork(long physicalNetworkId) { + + PhysicalNetworkServiceProvider nsp = addProviderToPhysicalNetwork(physicalNetworkId, + Network.Provider.SecurityGroupProvider.getName(), null, null); + + return nsp; + } + + + protected boolean isNetworkSystem(Network network) { + NetworkOffering no = _networkOfferingDao.findByIdIncludingRemoved(network.getNetworkOfferingId()); + if (no.isSystemOnly()) { + return true; + } else { + return false; + } + } + + + + private boolean getAllowSubdomainAccessGlobal() { + return _allowSubdomainNetworkAccess; + } + + + + @Override + public List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd) { + String type = cmd.getTrafficType(); + List> results = new ArrayList>(); + if (type != null) { + for (NetworkGuru guru : _networkGurus) { + if (guru.isMyTrafficType(TrafficType.getTrafficType(type))) { + results.add(new Pair(TrafficType.getTrafficType(type), guru.getName())); + break; + } + } + } else { + for (NetworkGuru guru : _networkGurus) { + TrafficType[] allTypes = guru.getSupportedTrafficType(); + for (TrafficType t : allTypes) { + results.add(new Pair(t, guru.getName())); + } + } + } + + return results; + } + + + @Override + @ActionEvent(eventType = EventTypes.EVENT_NET_IP_ASSIGN, eventDescription = "associating Ip", async = true) + public IpAddress associateIPToNetwork(long ipId, long networkId) throws InsufficientAddressCapacityException, + ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException { + + Network network = _networksDao.findById(networkId); + if (network == null) { + throw new InvalidParameterValueException("Invalid network id is given"); + } + + if (network.getVpcId() != null) { + throw new InvalidParameterValueException("Can't assign ip to the network directly when network belongs" + + " to VPC.Specify vpcId to associate ip address to VPC"); + } + return _networkMgr.associateIPToGuestNetwork(ipId, networkId, true); + + } + + + @Override @DB + public Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, + String vlan, String startIp, String endIp, String gateway, String netmask, long networkOwnerId, Long vpcId) + throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { + + Account owner = _accountMgr.getAccount(networkOwnerId); + + // Get system network offeirng + NetworkOfferingVO ntwkOff = findSystemNetworkOffering(NetworkOffering.SystemPrivateGatewayNetworkOffering); + + // Validate physical network + PhysicalNetwork pNtwk = _physicalNetworkDao.findById(physicalNetworkId); + if (pNtwk == null) { + InvalidParameterValueException ex = new InvalidParameterValueException("Unable to find a physical network" + + " having the given id"); + ex.addProxyObject("physical_network", physicalNetworkId, "physicalNetworkId"); + throw ex; + } + + // VALIDATE IP INFO + // if end ip is not specified, default it to startIp + if (!NetUtils.isValidIp(startIp)) { + throw new InvalidParameterValueException("Invalid format for the startIp parameter"); + } + if (endIp == null) { + endIp = startIp; + } else if (!NetUtils.isValidIp(endIp)) { + throw new InvalidParameterValueException("Invalid format for the endIp parameter"); + } + + String cidr = null; + if (!NetUtils.isValidIp(gateway)) { + throw new InvalidParameterValueException("Invalid gateway"); + } + if (!NetUtils.isValidNetmask(netmask)) { + throw new InvalidParameterValueException("Invalid netmask"); + } + + cidr = NetUtils.ipAndNetMaskToCidr(gateway, netmask); + + + Transaction txn = Transaction.currentTxn(); + txn.start(); + + //lock datacenter as we need to get mac address seq from there + DataCenterVO dc = _dcDao.lockRow(pNtwk.getDataCenterId(), true); + + //check if we need to create guest network + Network privateNetwork = _networksDao.getPrivateNetwork(BroadcastDomainType.Vlan.toUri(vlan).toString(), cidr, + networkOwnerId, pNtwk.getDataCenterId()); + if (privateNetwork == null) { + //create Guest network + privateNetwork = _networkMgr.createGuestNetwork(ntwkOff.getId(), networkName, displayText, gateway, cidr, vlan, + null, owner, null, pNtwk, pNtwk.getDataCenterId(), ACLType.Account, null, null); + s_logger.debug("Created private network " + privateNetwork); + } else { + s_logger.debug("Private network already exists: " + privateNetwork); + } + + //add entry to private_ip_address table + PrivateIpVO privateIp = _privateIpDao.findByIpAndSourceNetworkId(privateNetwork.getId(), startIp); + if (privateIp != null) { + throw new InvalidParameterValueException("Private ip address " + startIp + " already used for private gateway" + + " in zone " + _configMgr.getZone(pNtwk.getDataCenterId()).getName()); + } + + Long mac = dc.getMacAddress(); + Long nextMac = mac + 1; + dc.setMacAddress(nextMac); + + privateIp = new PrivateIpVO(startIp, privateNetwork.getId(), nextMac, vpcId); + _privateIpDao.persist(privateIp); + + _dcDao.update(dc.getId(), dc); + + txn.commit(); + s_logger.debug("Private network " + privateNetwork + " is created"); + + return privateNetwork; + } + + + private NetworkOfferingVO findSystemNetworkOffering(String offeringName) { + List allOfferings = _networkOfferingDao.listSystemNetworkOfferings(); + for (NetworkOfferingVO offer: allOfferings){ + if (offer.getName().equals(offeringName)) { + return offer; + } + } + return null; + } + + + @Override + public Network getNetwork(String networkUuid) { + return _networksDao.findByUuid(networkUuid); + } + +} diff --git a/server/src/com/cloud/network/element/CloudZonesNetworkElement.java b/server/src/com/cloud/network/element/CloudZonesNetworkElement.java index ae8be0d3317..67597261e00 100644 --- a/server/src/com/cloud/network/element/CloudZonesNetworkElement.java +++ b/server/src/com/cloud/network/element/CloudZonesNetworkElement.java @@ -44,7 +44,7 @@ import com.cloud.network.Network; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks.TrafficType; import com.cloud.network.PhysicalNetworkServiceProvider; import com.cloud.network.dao.NetworkDao; @@ -72,7 +72,7 @@ public class CloudZonesNetworkElement extends AdapterBase implements NetworkElem @Inject NetworkDao _networkConfigDao; @Inject - NetworkManager _networkMgr; + NetworkModel _networkMgr; @Inject UserVmManager _userVmMgr; @Inject diff --git a/server/src/com/cloud/network/element/VirtualRouterElement.java b/server/src/com/cloud/network/element/VirtualRouterElement.java index 02a239e72d9..2b54ae0fe36 100755 --- a/server/src/com/cloud/network/element/VirtualRouterElement.java +++ b/server/src/com/cloud/network/element/VirtualRouterElement.java @@ -45,7 +45,7 @@ import com.cloud.network.Network; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks.TrafficType; import com.cloud.network.PhysicalNetworkServiceProvider; import com.cloud.network.PublicIpAddress; @@ -82,7 +82,6 @@ import com.cloud.utils.exception.CloudRuntimeException; import com.cloud.vm.DomainRouterVO; import com.cloud.vm.NicProfile; import com.cloud.vm.ReservationContext; -import com.cloud.vm.UserVmManager; import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachine.State; import com.cloud.vm.VirtualMachineProfile; @@ -90,7 +89,10 @@ import com.cloud.vm.dao.DomainRouterDao; import com.cloud.vm.dao.UserVmDao; import com.google.gson.Gson; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class, FirewallServiceProvider.class, + DhcpServiceProvider.class, UserDataServiceProvider.class, + StaticNatServiceProvider.class, LoadBalancingServiceProvider.class, + PortForwardingServiceProvider.class, IpDeployer.class, RemoteAccessVPNServiceProvider.class} ) public class VirtualRouterElement extends AdapterBase implements VirtualRouterElementService, DhcpServiceProvider, UserDataServiceProvider, SourceNatServiceProvider, StaticNatServiceProvider, FirewallServiceProvider, LoadBalancingServiceProvider, PortForwardingServiceProvider, RemoteAccessVPNServiceProvider, IpDeployer { @@ -101,7 +103,7 @@ public class VirtualRouterElement extends AdapterBase implements VirtualRouterEl @Inject NetworkDao _networksDao; @Inject - NetworkManager _networkMgr; + NetworkModel _networkMgr; @Inject LoadBalancingRulesManager _lbMgr; @Inject @@ -112,8 +114,7 @@ public class VirtualRouterElement extends AdapterBase implements VirtualRouterEl ConfigurationManager _configMgr; @Inject RulesManager _rulesMgr; - @Inject - UserVmManager _userVmMgr; + @Inject UserVmDao _userVmDao; @Inject diff --git a/server/src/com/cloud/network/element/VpcVirtualRouterElement.java b/server/src/com/cloud/network/element/VpcVirtualRouterElement.java index 0acc47d7d88..f923ae1f924 100644 --- a/server/src/com/cloud/network/element/VpcVirtualRouterElement.java +++ b/server/src/com/cloud/network/element/VpcVirtualRouterElement.java @@ -36,7 +36,6 @@ import com.cloud.network.Network; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkService; import com.cloud.network.PublicIpAddress; import com.cloud.network.Site2SiteVpnConnection; import com.cloud.network.Site2SiteVpnGateway; @@ -61,11 +60,13 @@ import com.cloud.vm.ReservationContext; import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachine.Type; import com.cloud.vm.VirtualMachineProfile; -@Local(value = NetworkElement.class) +@Local(value = {NetworkElement.class, FirewallServiceProvider.class, + DhcpServiceProvider.class, UserDataServiceProvider.class, + StaticNatServiceProvider.class, LoadBalancingServiceProvider.class, + PortForwardingServiceProvider.class, IpDeployer.class, VpcProvider.class, + Site2SiteVpnServiceProvider.class, NetworkACLServiceProvider.class}) public class VpcVirtualRouterElement extends VirtualRouterElement implements VpcProvider, Site2SiteVpnServiceProvider, NetworkACLServiceProvider{ private static final Logger s_logger = Logger.getLogger(VpcVirtualRouterElement.class); - @Inject - NetworkService _ntwkService; @Inject VpcManager _vpcMgr; @Inject @@ -234,7 +235,7 @@ public class VpcVirtualRouterElement extends VirtualRouterElement implements Vpc List routers = _routerDao.listByVpcId(vpcId); for (VirtualRouter router : routers) { //1) Check if router is already a part of the network - if (!_ntwkService.isVmPartOfNetwork(router.getId(), network.getId())) { + if (!_networkMgr.isVmPartOfNetwork(router.getId(), network.getId())) { s_logger.debug("Router " + router + " is not a part the network " + network); continue; } @@ -262,7 +263,7 @@ public class VpcVirtualRouterElement extends VirtualRouterElement implements Vpc List routers = _routerDao.listByVpcId(vpcId); for (VirtualRouter router : routers) { //1) Check if router is already a part of the network - if (!_ntwkService.isVmPartOfNetwork(router.getId(), config.getId())) { + if (!_networkMgr.isVmPartOfNetwork(router.getId(), config.getId())) { s_logger.debug("Router " + router + " is not a part the network " + config); continue; } diff --git a/server/src/com/cloud/network/firewall/FirewallManagerImpl.java b/server/src/com/cloud/network/firewall/FirewallManagerImpl.java index 340e872a9de..7bab1bad7a5 100644 --- a/server/src/com/cloud/network/firewall/FirewallManagerImpl.java +++ b/server/src/com/cloud/network/firewall/FirewallManagerImpl.java @@ -46,16 +46,25 @@ import com.cloud.network.Network; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; +import com.cloud.network.NetworkRuleApplier; import com.cloud.network.dao.FirewallRulesCidrsDao; import com.cloud.network.dao.FirewallRulesDao; import com.cloud.network.dao.IPAddressDao; +import com.cloud.network.element.FirewallServiceProvider; +import com.cloud.network.element.NetworkACLServiceProvider; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.PortForwardingServiceProvider; +import com.cloud.network.element.StaticNatServiceProvider; import com.cloud.network.rules.FirewallManager; import com.cloud.network.rules.FirewallRule; import com.cloud.network.rules.FirewallRule.FirewallRuleType; import com.cloud.network.rules.FirewallRule.Purpose; import com.cloud.network.rules.FirewallRule.State; import com.cloud.network.rules.FirewallRuleVO; +import com.cloud.network.rules.PortForwardingRule; import com.cloud.network.rules.PortForwardingRuleVO; +import com.cloud.network.rules.StaticNat; import com.cloud.network.rules.dao.PortForwardingRulesDao; import com.cloud.network.vpc.VpcManager; import com.cloud.projects.Project.ListProjectResourcesCriteria; @@ -68,6 +77,7 @@ import com.cloud.user.DomainManager; import com.cloud.user.UserContext; import com.cloud.utils.Pair; import com.cloud.utils.Ternary; +import com.cloud.utils.component.Adapters; import com.cloud.utils.component.Inject; import com.cloud.utils.component.Manager; import com.cloud.utils.db.DB; @@ -83,7 +93,7 @@ import com.cloud.vm.UserVmVO; import com.cloud.vm.dao.UserVmDao; @Local(value = { FirewallService.class, FirewallManager.class}) -public class FirewallManagerImpl implements FirewallService, FirewallManager, Manager { +public class FirewallManagerImpl implements FirewallService, FirewallManager, NetworkRuleApplier, Manager { private static final Logger s_logger = Logger.getLogger(FirewallManagerImpl.class); String _name; @@ -102,6 +112,8 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma @Inject NetworkManager _networkMgr; @Inject + NetworkModel _networkModel; + @Inject UsageEventDao _usageEventDao; @Inject ConfigurationDao _configDao; @@ -115,6 +127,17 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma ResourceTagDao _resourceTagDao; @Inject VpcManager _vpcMgr; + @Inject(adapter = FirewallServiceProvider.class) + Adapters _firewallElements; + + @Inject(adapter = PortForwardingServiceProvider.class) + Adapters _pfElements; + + @Inject(adapter = StaticNatServiceProvider.class) + Adapters _staticNatElements; + + @Inject(adapter = NetworkACLServiceProvider.class) + Adapters _networkAclElements; private boolean _elbEnabled = false; @@ -138,6 +161,7 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma _name = name; String elbEnabledString = _configDao.getValue(Config.ElasticLoadBalancerEnabled.key()); _elbEnabled = Boolean.parseBoolean(elbEnabledString); + s_logger.info("Firewall provider list is " + _firewallElements.iterator().next()); return true; } @@ -164,7 +188,7 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma " doesn't exist in the system"); } - _networkMgr.checkIpForService(ipAddress, Service.Firewall, null); + _networkModel.checkIpForService(ipAddress, Service.Firewall, null); validateFirewallRule(caller, ipAddress, portStart, portEnd, protocol, Purpose.Firewall, type); @@ -399,7 +423,7 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma networkId = ipAddress.getAssociatedWithNetworkId(); } - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); assert network != null : "Can't create port forwarding rule as network associated with public ip address is null?"; // Verify that the network guru supports the protocol specified @@ -407,10 +431,10 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma if (purpose == Purpose.LoadBalancing) { if (!_elbEnabled) { - caps = _networkMgr.getNetworkServiceCapabilities(network.getId(), Service.Lb); + caps = _networkModel.getNetworkServiceCapabilities(network.getId(), Service.Lb); } } else if (purpose == Purpose.PortForwarding) { - caps = _networkMgr.getNetworkServiceCapabilities(network.getId(), Service.PortForwarding); + caps = _networkModel.getNetworkServiceCapabilities(network.getId(), Service.PortForwarding); } if (caps != null) { @@ -427,7 +451,12 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma public boolean applyRules(List rules, boolean continueOnError, boolean updateRulesInDB) throws ResourceUnavailableException { boolean success = true; - if (!_networkMgr.applyRules(rules, continueOnError)) { + if (rules == null || rules.size() == 0) { + s_logger.debug("There are no rules to forward to the network elements"); + return true; + } + Purpose purpose = rules.get(0).getPurpose(); + if (!_networkMgr.applyRules(rules, purpose, this, continueOnError)) { s_logger.warn("Rules are not completely applied"); return false; } else { @@ -459,6 +488,46 @@ public class FirewallManagerImpl implements FirewallService, FirewallManager, Ma return success; } + @Override + public boolean applyRules(Network network, Purpose purpose, List rules) + throws ResourceUnavailableException { + boolean handled = false; + switch (purpose){ + case Firewall: + for (FirewallServiceProvider fwElement: _firewallElements) { + handled = fwElement.applyFWRules(network, rules); + if (handled) + break; + } + case PortForwarding: + for (PortForwardingServiceProvider element: _pfElements) { + handled = element.applyPFRules(network, (List) rules); + if (handled) + break; + } + break; + case StaticNat: + for (StaticNatServiceProvider element: _staticNatElements) { + handled = element.applyStaticNats(network, (List) rules); + if (handled) + break; + } + break; + case NetworkACL: + for (NetworkACLServiceProvider element: _networkAclElements) { + handled = element.applyNetworkACLs(network, (List) rules); + if (handled) + break; + } + break; + default: + assert(false): "Unexpected fall through in applying rules to the network elements"; + s_logger.error("FirewallManager cannot process rules of type " + purpose); + throw new CloudRuntimeException("FirewallManager cannot process rules of type " + purpose); + } + return handled; + } + @Override public void removeRule(FirewallRule rule) { diff --git a/server/src/com/cloud/network/guru/ControlNetworkGuru.java b/server/src/com/cloud/network/guru/ControlNetworkGuru.java index 934cd70864e..ef8052221fa 100755 --- a/server/src/com/cloud/network/guru/ControlNetworkGuru.java +++ b/server/src/com/cloud/network/guru/ControlNetworkGuru.java @@ -35,7 +35,7 @@ import com.cloud.exception.InsufficientAddressCapacityException; import com.cloud.exception.InsufficientVirtualNetworkCapcityException; import com.cloud.hypervisor.Hypervisor.HypervisorType; import com.cloud.network.Network; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.AddressFormat; @@ -58,7 +58,7 @@ import com.cloud.vm.VirtualMachineProfile; public class ControlNetworkGuru extends PodBasedNetworkGuru implements NetworkGuru { private static final Logger s_logger = Logger.getLogger(ControlNetworkGuru.class); @Inject DataCenterDao _dcDao; - @Inject NetworkManager _networkMgr; + @Inject NetworkModel _networkMgr; String _cidr; String _gateway; diff --git a/server/src/com/cloud/network/guru/DirectNetworkGuru.java b/server/src/com/cloud/network/guru/DirectNetworkGuru.java index ee824af5aef..b290c1da3ef 100755 --- a/server/src/com/cloud/network/guru/DirectNetworkGuru.java +++ b/server/src/com/cloud/network/guru/DirectNetworkGuru.java @@ -36,6 +36,7 @@ import com.cloud.network.Network.GuestType; import com.cloud.network.Network.Service; import com.cloud.network.Network.State; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.BroadcastDomainType; @@ -64,6 +65,8 @@ public class DirectNetworkGuru extends AdapterBase implements NetworkGuru { @Inject VlanDao _vlanDao; @Inject + NetworkModel _networkModel; + @Inject NetworkManager _networkMgr; @Inject IPAddressDao _ipAddressDao; @@ -132,7 +135,7 @@ public class DirectNetworkGuru extends AdapterBase implements NetworkGuru { } } - boolean isSecurityGroupEnabled = _networkMgr.areServicesSupportedByNetworkOffering(offering.getId(), Service.SecurityGroup); + boolean isSecurityGroupEnabled = _networkModel.areServicesSupportedByNetworkOffering(offering.getId(), Service.SecurityGroup); if (isSecurityGroupEnabled) { config.setName("SecurityGroupEnabledNetwork"); config.setDisplayText("SecurityGroupEnabledNetwork"); diff --git a/server/src/com/cloud/network/guru/DirectPodBasedNetworkGuru.java b/server/src/com/cloud/network/guru/DirectPodBasedNetworkGuru.java index 354d7ed2714..8ca4547d686 100755 --- a/server/src/com/cloud/network/guru/DirectPodBasedNetworkGuru.java +++ b/server/src/com/cloud/network/guru/DirectPodBasedNetworkGuru.java @@ -109,7 +109,7 @@ public class DirectPodBasedNetworkGuru extends DirectNetworkGuru { } if (rsStrategy == ReservationStrategy.Create) { - String mac = _networkMgr.getNextAvailableMacAddressInNetwork(network.getId()); + String mac = _networkModel.getNextAvailableMacAddressInNetwork(network.getId()); nic.setMacAddress(mac); } return nic; diff --git a/server/src/com/cloud/network/guru/ExternalGuestNetworkGuru.java b/server/src/com/cloud/network/guru/ExternalGuestNetworkGuru.java index 24d24f85521..f8a8a95ec05 100644 --- a/server/src/com/cloud/network/guru/ExternalGuestNetworkGuru.java +++ b/server/src/com/cloud/network/guru/ExternalGuestNetworkGuru.java @@ -106,7 +106,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { NetworkVO config = (NetworkVO) super.design(offering, plan, userSpecified, owner); if (config == null) { return null; - } else if (_networkMgr.networkIsConfiguredForExternalNetworking(plan.getDataCenterId(), config.getId())) { + } else if (_networkModel.networkIsConfiguredForExternalNetworking(plan.getDataCenterId(), config.getId())) { /* In order to revert userSpecified network setup */ config.setState(State.Allocated); } @@ -122,7 +122,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { return null; } - if (!_networkMgr.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { + if (!_networkModel.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { return super.implement(config, offering, dest, context); } @@ -195,7 +195,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { public NicProfile allocate(Network config, NicProfile nic, VirtualMachineProfile vm) throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException { - if (_networkMgr.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId()) && nic != null && nic.getRequestedIp() != null) { + if (_networkModel.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId()) && nic != null && nic.getRequestedIp() != null) { throw new CloudRuntimeException("Does not support custom ip allocation at this time: " + nic); } @@ -206,7 +206,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { return null; } - if (_networkMgr.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { + if (_networkModel.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { profile.setStrategy(ReservationStrategy.Start); /* We won't clear IP address, because router may set gateway as it IP, and it would be updated properly later */ //profile.setIp4Address(null); @@ -225,7 +225,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { return; } - if (_networkMgr.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { + if (_networkModel.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { nic.setIp4Address(null); nic.setGateway(null); nic.setNetmask(null); @@ -245,7 +245,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { DataCenter dc = _dcDao.findById(config.getDataCenterId()); - if (_networkMgr.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { + if (_networkModel.networkIsConfiguredForExternalNetworking(config.getDataCenterId(), config.getId())) { nic.setBroadcastUri(config.getBroadcastUri()); nic.setIsolationUri(config.getBroadcastUri()); nic.setDns1(dc.getDns1()); @@ -280,7 +280,7 @@ public class ExternalGuestNetworkGuru extends GuestNetworkGuru { NetworkVO network = _networkDao.findById(nic.getNetworkId()); - if (network != null && _networkMgr.networkIsConfiguredForExternalNetworking(network.getDataCenterId(), network.getId())) { + if (network != null && _networkModel.networkIsConfiguredForExternalNetworking(network.getDataCenterId(), network.getId())) { return true; } else { return super.release(nic, vm, reservationId); diff --git a/server/src/com/cloud/network/guru/GuestNetworkGuru.java b/server/src/com/cloud/network/guru/GuestNetworkGuru.java index 91b95f953cc..95878859598 100755 --- a/server/src/com/cloud/network/guru/GuestNetworkGuru.java +++ b/server/src/com/cloud/network/guru/GuestNetworkGuru.java @@ -45,6 +45,7 @@ import com.cloud.network.IPAddressVO; import com.cloud.network.Network; import com.cloud.network.Network.State; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.AddressFormat; @@ -82,6 +83,8 @@ public abstract class GuestNetworkGuru extends AdapterBase implements NetworkGur @Inject protected NetworkManager _networkMgr; @Inject + protected NetworkModel _networkModel; + @Inject protected DataCenterDao _dcDao; @Inject protected VlanDao _vlanDao; @@ -310,7 +313,7 @@ public abstract class GuestNetworkGuru extends AdapterBase implements NetworkGur long dcId = dest.getDataCenter().getId(); //get physical network id - long physicalNetworkId = _networkMgr.findPhysicalNetworkId(dcId, offering.getTags(), offering.getTrafficType()); + long physicalNetworkId = _networkModel.findPhysicalNetworkId(dcId, offering.getTags(), offering.getTrafficType()); NetworkVO implemented = new NetworkVO(network.getTrafficType(), network.getMode(), network.getBroadcastDomainType(), network.getNetworkOfferingId(), State.Allocated, @@ -355,11 +358,11 @@ public abstract class GuestNetworkGuru extends AdapterBase implements NetworkGur boolean isGateway = false; if (vm.getVirtualMachine().getType() == VirtualMachine.Type.DomainRouter) { if (network.getVpcId() != null) { - if (_networkMgr.isProviderSupportServiceInNetwork(network.getId(), Service.SourceNat, Provider.VPCVirtualRouter)) { + if (_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.SourceNat, Provider.VPCVirtualRouter)) { isGateway = true; } } else { - if (_networkMgr.isProviderSupportServiceInNetwork(network.getId(), Service.SourceNat, Provider.VirtualRouter)) { + if (_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.SourceNat, Provider.VirtualRouter)) { isGateway = true; } } @@ -387,7 +390,7 @@ public abstract class GuestNetworkGuru extends AdapterBase implements NetworkGur nic.setStrategy(ReservationStrategy.Start); if (nic.getMacAddress() == null) { - nic.setMacAddress(_networkMgr.getNextAvailableMacAddressInNetwork(network.getId())); + nic.setMacAddress(_networkModel.getNextAvailableMacAddressInNetwork(network.getId())); if (nic.getMacAddress() == null) { throw new InsufficientAddressCapacityException("Unable to allocate more mac addresses", Network.class, network.getId()); } diff --git a/server/src/com/cloud/network/guru/PrivateNetworkGuru.java b/server/src/com/cloud/network/guru/PrivateNetworkGuru.java index 9d4c9c327ff..b50e342b4c3 100644 --- a/server/src/com/cloud/network/guru/PrivateNetworkGuru.java +++ b/server/src/com/cloud/network/guru/PrivateNetworkGuru.java @@ -31,7 +31,7 @@ import com.cloud.exception.InvalidParameterValueException; import com.cloud.network.Network; import com.cloud.network.Network.GuestType; import com.cloud.network.Network.State; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkProfile; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.AddressFormat; @@ -62,7 +62,7 @@ public class PrivateNetworkGuru extends AdapterBase implements NetworkGuru { @Inject protected PrivateIpDao _privateIpDao; @Inject - protected NetworkManager _networkMgr; + protected NetworkModel _networkMgr; private static final TrafficType[] _trafficTypes = {TrafficType.Guest}; diff --git a/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java b/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java index 9b48f2ce401..dfd5232ddab 100755 --- a/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java +++ b/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java @@ -66,6 +66,8 @@ import com.cloud.network.Network.Capability; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; +import com.cloud.network.NetworkRuleApplier; import com.cloud.network.NetworkVO; import com.cloud.network.as.AutoScalePolicy; import com.cloud.network.as.AutoScalePolicyConditionMapVO; @@ -90,6 +92,8 @@ import com.cloud.network.dao.LoadBalancerDao; import com.cloud.network.dao.LoadBalancerVMMapDao; import com.cloud.network.dao.NetworkDao; import com.cloud.network.dao.NetworkServiceMapDao; +import com.cloud.network.element.LoadBalancingServiceProvider; +import com.cloud.network.element.NetworkElement; import com.cloud.network.lb.LoadBalancingRule.LbAutoScalePolicy; import com.cloud.network.lb.LoadBalancingRule.LbAutoScaleVmGroup; import com.cloud.network.lb.LoadBalancingRule.LbAutoScaleVmProfile; @@ -114,7 +118,6 @@ import com.cloud.service.dao.ServiceOfferingDao; import com.cloud.storage.dao.VMTemplateDao; import com.cloud.tags.ResourceTagVO; import com.cloud.tags.dao.ResourceTagDao; -import com.cloud.template.TemplateManager; import com.cloud.user.Account; import com.cloud.user.AccountManager; import com.cloud.user.DomainService; @@ -125,6 +128,7 @@ import com.cloud.user.dao.UserDao; import com.cloud.uservm.UserVm; import com.cloud.utils.Pair; import com.cloud.utils.Ternary; +import com.cloud.utils.component.Adapters; import com.cloud.utils.component.Inject; import com.cloud.utils.component.Manager; import com.cloud.utils.db.DB; @@ -144,7 +148,7 @@ import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; @Local(value = { LoadBalancingRulesManager.class, LoadBalancingRulesService.class }) -public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesManager, LoadBalancingRulesService, Manager { +public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesManager, LoadBalancingRulesService, NetworkRuleApplier, Manager { private static final Logger s_logger = Logger.getLogger(LoadBalancingRulesManagerImpl.class); String _name; @@ -152,6 +156,8 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa @Inject NetworkManager _networkMgr; @Inject + NetworkModel _networkModel; + @Inject RulesManager _rulesMgr; @Inject AccountManager _accountMgr; @@ -189,8 +195,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa DomainService _domainMgr; @Inject ConfigurationManager _configMgr; - @Inject - TemplateManager _templateMgr; + @Inject ExternalLoadBalancerUsageManager _externalLBUsageMgr; @Inject @@ -223,12 +228,13 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa DataCenterDao _dcDao = null; @Inject UserDao _userDao; - + @Inject(adapter = LoadBalancingServiceProvider.class) + Adapters _lbProviders; // Will return a string. For LB Stickiness this will be a json, for autoscale this will be "," separated values @Override public String getLBCapability(long networkid, String capabilityName) { - Map> serviceCapabilitiesMap = _networkMgr.getNetworkCapabilities(networkid); + Map> serviceCapabilitiesMap = _networkModel.getNetworkCapabilities(networkid); if (serviceCapabilitiesMap != null) { for (Service service : serviceCapabilitiesMap.keySet()) { ServiceResponse serviceResponse = new ServiceResponse(); @@ -321,7 +327,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa List rules = Arrays.asList(rule); - if (!_networkMgr.applyRules(rules, false)) { + if (!_networkMgr.applyRules(rules, FirewallRule.Purpose.LoadBalancing, this, false)) { s_logger.debug("LB rules' autoscale config are not completely applied"); return false; } @@ -480,7 +486,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa List policyList = new ArrayList(); policyList.add(new LbStickinessPolicy(cmd.getStickinessMethodName(), lbpolicy.getParams())); LoadBalancingRule lbRule = new LoadBalancingRule(loadBalancer, getExistingDestinations(lbpolicy.getId()), policyList); - if (!_networkMgr.validateRule(lbRule)) { + if (!validateRule(lbRule)) { throw new InvalidParameterValueException("Failed to create Stickiness policy: Validation Failed " + cmd.getLbRuleId()); } @@ -491,6 +497,22 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa return policy; } + + private boolean validateRule(LoadBalancingRule lbRule) { + Network network = _networkDao.findById(lbRule.getNetworkId()); + Purpose purpose = lbRule.getPurpose(); + if (purpose != Purpose.LoadBalancing) { + s_logger.debug("Unable to validate network rules for purpose: " + purpose.toString()); + return false; + } + for (LoadBalancingServiceProvider ne : _lbProviders) { + boolean validated = ne.validateLBRule(network, lbRule); + if (!validated) + return false; + } + return true; + } + @Override @DB @ActionEvent(eventType = EventTypes.EVENT_LB_STICKINESSPOLICY_CREATE, eventDescription = "Apply Stickinesspolicy to load balancer ", async = true) @@ -624,7 +646,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa } // Let's check to make sure the vm has a nic in the same network as the load balancing rule. - List nics = _networkMgr.getNics(vm.getId()); + List nics = _networkModel.getNics(vm.getId()); Nic nicInSameNetwork = null; for (Nic nic : nics) { if (nic.getNetworkId() == loadBalancer.getNetworkId()) { @@ -858,7 +880,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa // gather external network usage stats for this lb rule NetworkVO network = _networkDao.findById(lb.getNetworkId()); if (network != null) { - if (_networkMgr.networkIsConfiguredForExternalNetworking(network.getDataCenterId(), network.getId())) { + if (_networkModel.networkIsConfiguredForExternalNetworking(network.getDataCenterId(), network.getId())) { _externalLBUsageMgr.updateExternalLoadBalancerNetworkUsageStats(loadBalancerId); } } @@ -939,7 +961,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa ipVO = _ipAddressDao.findById(ipAddrId); } - Network network = _networkMgr.getNetwork(lb.getNetworkId()); + Network network = _networkModel.getNetwork(lb.getNetworkId()); // FIXME: breaking the dependency on ELB manager. This breaks functionality of ELB using virtual router // Bug CS-15411 opened to document this @@ -968,14 +990,14 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa && ipVO.getVpcId() != null && ipVO.getVpcId().longValue() == network.getVpcId(); if (assignToVpcNtwk) { //set networkId just for verification purposes - _networkMgr.checkIpForService(ipVO, Service.Lb, lb.getNetworkId()); + _networkModel.checkIpForService(ipVO, Service.Lb, lb.getNetworkId()); s_logger.debug("The ip is not associated with the VPC network id="+ lb.getNetworkId() + " so assigning"); ipVO = _networkMgr.associateIPToGuestNetwork(ipAddrId, lb.getNetworkId(), false); performedIpAssoc = true; } } else { - _networkMgr.checkIpForService(ipVO, Service.Lb, null); + _networkModel.checkIpForService(ipVO, Service.Lb, null); } if (ipVO.getAssociatedWithNetworkId() == null) { @@ -1047,7 +1069,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa _accountMgr.checkAccess(caller.getCaller(), null, true, ipAddr); // verify that lb service is supported by the network - if (!_networkMgr.areServicesSupportedInNetwork(network.getId(), Service.Lb)) { + if (!_networkModel.areServicesSupportedInNetwork(network.getId(), Service.Lb)) { InvalidParameterValueException ex = new InvalidParameterValueException("LB service is not supported in specified network id"); ex.addProxyObject(network, networkId, "networkId"); throw ex; @@ -1061,7 +1083,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa // verify rule is supported by Lb provider of the network LoadBalancingRule loadBalancing = new LoadBalancingRule(newRule, new ArrayList(), new ArrayList()); - if (!_networkMgr.validateRule(loadBalancing)) { + if (!validateRule(loadBalancing)) { throw new InvalidParameterValueException("LB service provider cannot support this rule"); } @@ -1128,6 +1150,19 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa return true; } } + + @Override + public boolean applyRules(Network network, Purpose purpose, List rules) + throws ResourceUnavailableException { + assert(purpose == Purpose.LoadBalancing): "LB Manager asked to handle non-LB rules"; + boolean handled = false; + for (LoadBalancingServiceProvider lbElement: _lbProviders) { + handled = lbElement.applyLBRules(network, (List) rules); + if (handled) + break; + } + return handled; + } @DB protected boolean applyLoadBalancerRules(List lbs, boolean updateRulesInDB) throws ResourceUnavailableException { @@ -1141,7 +1176,7 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa rules.add(loadBalancing); } - if (!_networkMgr.applyRules(rules, false)) { + if (!_networkMgr.applyRules(rules, FirewallRule.Purpose.LoadBalancing, this, false)) { s_logger.debug("LB rules are not completely applied"); return false; } @@ -1578,4 +1613,6 @@ public class LoadBalancingRulesManagerImpl implements LoadBalancingRulesMa //remove the rule _lbDao.remove(rule.getId()); } + + } diff --git a/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java b/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java index 717da054ac5..e1c78e1a4e7 100755 --- a/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java +++ b/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java @@ -132,6 +132,7 @@ import com.cloud.network.Network.GuestType; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.BroadcastDomainType; import com.cloud.network.Networks.IsolationType; @@ -176,8 +177,8 @@ import com.cloud.network.rules.StaticNatImpl; import com.cloud.network.rules.StaticNatRule; import com.cloud.network.rules.dao.PortForwardingRulesDao; import com.cloud.network.vpn.Site2SiteVpnManager; +import com.cloud.offering.NetworkOffering; import com.cloud.offering.ServiceOffering; -import com.cloud.offerings.NetworkOfferingVO; import com.cloud.offerings.dao.NetworkOfferingDao; import com.cloud.resource.ResourceManager; import com.cloud.service.ServiceOfferingVO; @@ -292,6 +293,8 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian @Inject NetworkManager _networkMgr; @Inject + NetworkModel _networkModel; + @Inject VirtualMachineManager _itMgr; @Inject VpnUserDao _vpnUsersDao; @@ -826,7 +829,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian boolean forVpc = router.getVpcId() != null; List routerNics = _nicDao.listByVmId(router.getId()); for (Nic routerNic : routerNics) { - Network network = _networkMgr.getNetwork(routerNic.getNetworkId()); + Network network = _networkModel.getNetwork(routerNic.getNetworkId()); //Send network usage command for public nic in VPC VR //Send network usage command for isolated guest nic of non VPC VR if ((forVpc && network.getTrafficType() == TrafficType.Public) || (!forVpc && network.getTrafficType() == TrafficType.Guest && network.getGuestType() == Network.GuestType.Isolated)) { @@ -1381,7 +1384,9 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian assert guestNetwork.getTrafficType() == TrafficType.Guest; // 1) Get deployment plan and find out the list of routers - boolean isPodBased = (dest.getDataCenter().getNetworkType() == NetworkType.Basic); + boolean isPodBased = (dest.getDataCenter().getNetworkType() == NetworkType.Basic || + _networkModel.areServicesSupportedInNetwork(guestNetwork.getId(), Service.SecurityGroup)) + && guestNetwork.getTrafficType() == TrafficType.Guest; // dest has pod=null, for Basic Zone findOrDeployVRs for all Pods List destinations = new ArrayList(); @@ -1440,7 +1445,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian // Check if providers are supported in the physical networks VirtualRouterProviderType type = VirtualRouterProviderType.VirtualRouter; - Long physicalNetworkId = _networkMgr.getPhysicalNetworkId(guestNetwork); + Long physicalNetworkId = _networkModel.getPhysicalNetworkId(guestNetwork); PhysicalNetworkServiceProvider provider = _physicalProviderDao.findByServiceProvider(physicalNetworkId, type.toString()); if (provider == null) { throw new CloudRuntimeException("Cannot find service provider " + type.toString() + " in physical network " + physicalNetworkId); @@ -1450,13 +1455,13 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian throw new CloudRuntimeException("Cannot find virtual router provider " + type.toString() + " as service provider " + provider.getId()); } - if (_networkMgr.isNetworkSystem(guestNetwork) || guestNetwork.getGuestType() == Network.GuestType.Shared) { + if (_networkModel.isNetworkSystem(guestNetwork) || guestNetwork.getGuestType() == Network.GuestType.Shared) { owner = _accountMgr.getAccount(Account.ACCOUNT_ID_SYSTEM); } // Check if public network has to be set on VR boolean publicNetwork = false; - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetwork.getId(), Service.SourceNat, Provider.VirtualRouter)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetwork.getId(), Service.SourceNat, Provider.VirtualRouter)) { publicNetwork = true; } if (isRedundant && !publicNetwork) { @@ -1642,7 +1647,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian s_logger.debug("Adding nic for Virtual Router in Guest network " + guestNetwork); String defaultNetworkStartIp = null; if (guestNetwork.getCidr() != null && !setupPublicNetwork) { - String startIp = _networkMgr.getStartIpAddress(guestNetwork.getId()); + String startIp = _networkModel.getStartIpAddress(guestNetwork.getId()); if (startIp != null && _ipAddressDao.findByIpAndSourceNetworkId(guestNetwork.getId(), startIp).getAllocatedTime() == null) { defaultNetworkStartIp = startIp; } else if (s_logger.isDebugEnabled()){ @@ -1674,8 +1679,8 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian //2) Control network s_logger.debug("Adding nic for Virtual Router in Control network "); - List offerings = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemControlNetwork); - NetworkOfferingVO controlOffering = offerings.get(0); + List offerings = _networkModel.getSystemAccountNetworkOfferings(NetworkOffering.SystemControlNetwork); + NetworkOffering controlOffering = offerings.get(0); NetworkVO controlConfig = _networkMgr.setupNetwork(_systemAcct, controlOffering, plan, null, null, false).get(0); networks.add(new Pair(controlConfig, null)); @@ -1697,7 +1702,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (hasGuestNetwork) { defaultNic.setDeviceId(2); } - NetworkOfferingVO publicOffering = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemPublicNetwork).get(0); + NetworkOffering publicOffering = _networkModel.getSystemAccountNetworkOfferings(NetworkOffering.SystemPublicNetwork).get(0); List publicNetworks = _networkMgr.setupNetwork(_systemAcct, publicOffering, plan, null, null, false); String publicIp = defaultNic.getIp4Address(); // We want to use the identical MAC address for RvR on public interface if possible @@ -1922,8 +1927,8 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian } } else if (nic.getTrafficType() == TrafficType.Guest) { - dnsProvided = _networkMgr.isProviderSupportServiceInNetwork(nic.getNetworkId(), Service.Dns, Provider.VirtualRouter); - dhcpProvided = _networkMgr.isProviderSupportServiceInNetwork(nic.getNetworkId(), Service.Dhcp, Provider.VirtualRouter); + dnsProvided = _networkModel.isProviderSupportServiceInNetwork(nic.getNetworkId(), Service.Dns, Provider.VirtualRouter); + dhcpProvided = _networkModel.isProviderSupportServiceInNetwork(nic.getNetworkId(), Service.Dhcp, Provider.VirtualRouter); //build bootloader parameter for the guest buf.append(createGuestBootLoadArgs(nic, defaultDns1, defaultDns2, router)); } else if (nic.getTrafficType() == TrafficType.Public) { @@ -2024,7 +2029,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian s_logger.error("Failed to get update priority!", e); throw new CloudRuntimeException("Failed to get update priority!"); } - Network net = _networkMgr.getNetwork(guestNic.getNetworkId()); + Network net = _networkModel.getNetwork(guestNic.getNetworkId()); buf.append(" guestgw=").append(net.getGateway()); String brd = NetUtils.long2Ip(NetUtils.ip2Long(guestNic.getIp4Address()) | ~NetUtils.ip2Long(guestNic.getNetmask())); buf.append(" guestbrd=").append(brd); @@ -2180,13 +2185,13 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian } protected void finalizeUserDataAndDhcpOnStart(Commands cmds, DomainRouterVO router, Provider provider, Long guestNetworkId) { - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.Dhcp, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.Dhcp, provider)) { // Resend dhcp s_logger.debug("Reapplying dhcp entries as a part of domR " + router + " start..."); createDhcpEntryCommandsForVMs(router, cmds, guestNetworkId); } - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.UserData, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.UserData, provider)) { // Resend user data s_logger.debug("Reapplying vm data (userData and metaData) entries as a part of domR " + router + " start..."); createVmDataCommandForVMs(router, cmds, guestNetworkId); @@ -2207,26 +2212,26 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian //Get information about all the rules (StaticNats and StaticNatRules; PFVPN to reapply on domR start) for (PublicIpAddress ip : publicIps) { - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.PortForwarding, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.PortForwarding, provider)) { pfRules.addAll(_pfRulesDao.listForApplication(ip.getId())); } - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.StaticNat, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.StaticNat, provider)) { staticNatFirewallRules.addAll(_rulesDao.listByIpAndPurpose(ip.getId(), Purpose.StaticNat)); } - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.Firewall, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.Firewall, provider)) { firewallRules.addAll(_rulesDao.listByIpAndPurpose(ip.getId(), Purpose.Firewall)); } - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.Vpn, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.Vpn, provider)) { RemoteAccessVpn vpn = _vpnDao.findById(ip.getId()); if (vpn != null) { vpns.add(vpn); } } - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.StaticNat, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.StaticNat, provider)) { if (ip.isOneToOneNat()) { - String dstIp = _networkMgr.getIpInNetwork(ip.getAssociatedWithVmId(), guestNetworkId); + String dstIp = _networkModel.getIpInNetwork(ip.getAssociatedWithVmId(), guestNetworkId); StaticNatImpl staticNat = new StaticNatImpl(ip.getAccountId(), ip.getDomainId(), guestNetworkId, ip.getId(), dstIp, false); staticNats.add(staticNat); } @@ -2271,7 +2276,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian List lbs = _loadBalancerDao.listByNetworkId(guestNetworkId); List lbRules = new ArrayList(); - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.Lb, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.Lb, provider)) { // Re-apply load balancing rules for (LoadBalancerVO lb : lbs) { List dstList = _lbMgr.getExistingDestinations(lb.getId()); @@ -2296,7 +2301,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (publicIps != null && !publicIps.isEmpty()) { s_logger.debug("Found " + publicIps.size() + " ip(s) to apply as a part of domR " + router + " start."); // Re-apply public ip addresses - should come before PF/LB/VPN - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.Firewall, provider)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.Firewall, provider)) { createAssociateIPCommands(router, publicIps, cmds, 0); } } @@ -2305,11 +2310,11 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian protected ArrayList getPublicIpsToApply(VirtualRouter router, Provider provider, Long guestNetworkId, com.cloud.network.IpAddress.State... skipInStates) { long ownerId = router.getAccountId(); - final List userIps = _networkMgr.listPublicIpsAssignedToGuestNtwk(ownerId, guestNetworkId, null); + final List userIps = _networkModel.listPublicIpsAssignedToGuestNtwk(ownerId, guestNetworkId, null); List allPublicIps = new ArrayList(); if (userIps != null && !userIps.isEmpty()) { boolean addIp = true; - for (IPAddressVO userIp : userIps) { + for (IpAddress userIp : userIps) { if (skipInStates != null) { for (IpAddress.State stateToSkip : skipInStates) { if (userIp.getState() == stateToSkip) { @@ -2321,8 +2326,9 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian } if (addIp) { - PublicIp publicIp = new PublicIp(userIp, _vlanDao.findById(userIp.getVlanId()), - NetUtils.createSequenceBasedMacAddress(userIp.getMacAddress())); + IPAddressVO ipVO = _ipAddressDao.findById(userIp.getId()); + PublicIp publicIp = new PublicIp(ipVO, _vlanDao.findById(userIp.getVlanId()), + NetUtils.createSequenceBasedMacAddress(ipVO.getMacAddress())); allPublicIps.add(publicIp); } } @@ -2330,11 +2336,11 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian //Get public Ips that should be handled by router Network network = _networkDao.findById(guestNetworkId); - Map> ipToServices = _networkMgr.getIpToServices(allPublicIps, false, true); - Map> providerToIpList = _networkMgr.getProviderToIpList(network, ipToServices); + Map> ipToServices = _networkModel.getIpToServices(allPublicIps, false, true); + Map> providerToIpList = _networkModel.getProviderToIpList(network, ipToServices); // Only cover virtual router for now, if ELB use it this need to be modified - ArrayList publicIps = providerToIpList.get(provider); + ArrayList publicIps = providerToIpList.get(provider); return publicIps; } @@ -2364,7 +2370,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian List routerNics = _nicDao.listByVmId(profile.getId()); for (Nic routerNic : routerNics) { - Network network = _networkMgr.getNetwork(routerNic.getNetworkId()); + Network network = _networkModel.getNetwork(routerNic.getNetworkId()); if (network.getTrafficType() == TrafficType.Guest) { guestNetworks.add(network); } @@ -2464,7 +2470,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian for (VirtualRouter router : routers) { if (router.getState() == State.Running) { Commands cmds = new Commands(OnError.Continue); - IpAddress ip = _networkMgr.getIp(vpn.getServerAddressId()); + IpAddress ip = _networkModel.getIp(vpn.getServerAddressId()); RemoteAccessVpnCfgCommand removeVpnCmd = new RemoteAccessVpnCfgCommand(false, ip.getAddress().addr(), vpn.getLocalIp(), vpn.getIpRange(), vpn.getIpsecPresharedKey()); @@ -2564,16 +2570,16 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian NicVO defaultNic = _nicDao.findDefaultNicForVM(userVmId); //check if DNS provider is the domR - if (!_networkMgr.isProviderSupportServiceInNetwork(defaultNic.getNetworkId(), Service.Dns, Provider.VirtualRouter)) { + if (!_networkModel.isProviderSupportServiceInNetwork(defaultNic.getNetworkId(), Service.Dns, Provider.VirtualRouter)) { return null; } - NetworkOfferingVO offering = _networkOfferingDao.findById(_networkDao.findById(defaultNic.getNetworkId()).getNetworkOfferingId()); + NetworkOffering offering = _networkOfferingDao.findById(_networkDao.findById(defaultNic.getNetworkId()).getNetworkOfferingId()); if (offering.getRedundantRouter()) { return findGatewayIp(userVmId); } - DataCenter dc = _dcDao.findById(_networkMgr.getNetwork(defaultNic.getNetworkId()).getDataCenterId()); + DataCenter dc = _dcDao.findById(_networkModel.getNetwork(defaultNic.getNetworkId()).getDataCenterId()); boolean isZoneBasic = (dc.getNetworkType() == NetworkType.Basic); //find domR's nic in the network @@ -2792,8 +2798,8 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian }); // Get network rate - required for IpAssoc - Integer networkRate = _networkMgr.getNetworkRate(ipAddrList.get(0).getNetworkId(), router.getId()); - Network network = _networkMgr.getNetwork(ipAddrList.get(0).getNetworkId()); + Integer networkRate = _networkModel.getNetworkRate(ipAddrList.get(0).getNetworkId(), router.getId()); + Network network = _networkModel.getNetwork(ipAddrList.get(0).getNetworkId()); IpAddressTO[] ipsToSend = new IpAddressTO[ipAddrList.size()]; int i = 0; @@ -2816,7 +2822,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian sourceNat, vlanId, vlanGateway, vlanNetmask, vifMacAddress, networkRate, ipAddr.isOneToOneNat()); ip.setTrafficType(network.getTrafficType()); - ip.setNetworkName(_networkMgr.getNetworkTag(router.getHypervisorType(), network)); + ip.setNetworkName(_networkModel.getNetworkTag(router.getHypervisorType(), network)); ipsToSend[i++] = ip; /* send the firstIP = true for the first Add, this is to create primary on interface*/ if (!firstIP || add) { @@ -2839,7 +2845,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (rules != null) { rulesTO = new ArrayList(); for (PortForwardingRule rule : rules) { - IpAddress sourceIp = _networkMgr.getIp(rule.getSourceIpAddressId()); + IpAddress sourceIp = _networkModel.getIp(rule.getSourceIpAddressId()); PortForwardingRuleTO ruleTO = new PortForwardingRuleTO(rule, null, sourceIp.getAddress().addr()); rulesTO.add(ruleTO); } @@ -2867,7 +2873,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (rules != null) { rulesTO = new ArrayList(); for (StaticNatRule rule : rules) { - IpAddress sourceIp = _networkMgr.getIp(rule.getSourceIpAddressId()); + IpAddress sourceIp = _networkModel.getIp(rule.getSourceIpAddressId()); StaticNatRuleTO ruleTO = new StaticNatRuleTO(rule, null, sourceIp.getAddress().addr(), rule.getDestIpAddress()); rulesTO.add(ruleTO); } @@ -2894,7 +2900,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian String algorithm = rule.getAlgorithm(); String uuid = rule.getUuid(); - String srcIp = _networkMgr.getIp(rule.getSourceIpAddressId()).getAddress().addr(); + String srcIp = _networkModel.getIp(rule.getSourceIpAddressId()).getAddress().addr(); int srcPort = rule.getSourcePortStart(); List destinations = rule.getDestinations(); List stickinessPolicies = rule.getStickinessPolicies(); @@ -2908,12 +2914,12 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian routerPublicIp = domr.getPublicIpAddress(); } - Network guestNetwork = _networkMgr.getNetwork(guestNetworkId); + Network guestNetwork = _networkModel.getNetwork(guestNetworkId); Nic nic = _nicDao.findByInstanceIdAndNetworkId(guestNetwork.getId(), router.getId()); NicProfile nicProfile = new NicProfile(nic, guestNetwork, nic.getBroadcastUri(), nic.getIsolationUri(), - _networkMgr.getNetworkRate(guestNetwork.getId(), router.getId()), - _networkMgr.isSecurityGroupSupportedInNetwork(guestNetwork), - _networkMgr.getNetworkTag(router.getHypervisorType(), guestNetwork)); + _networkModel.getNetworkRate(guestNetwork.getId(), router.getId()), + _networkModel.isSecurityGroupSupportedInNetwork(guestNetwork), + _networkModel.getNetworkTag(router.getHypervisorType(), guestNetwork)); LoadBalancerConfigCommand cmd = new LoadBalancerConfigCommand(lbs,routerPublicIp, getRouterIpInNetwork(guestNetworkId, router.getId()),router.getPrivateIpAddress(), @@ -2951,7 +2957,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian addUsersCmd.setAccessDetail(NetworkElementCommand.ROUTER_GUEST_IP, getRouterIpInNetwork(vpn.getNetworkId(), router.getId())); addUsersCmd.setAccessDetail(NetworkElementCommand.ROUTER_NAME, router.getInstanceName()); - IpAddress ip = _networkMgr.getIp(vpn.getServerAddressId()); + IpAddress ip = _networkModel.getIp(vpn.getServerAddressId()); RemoteAccessVpnCfgCommand startVpnCmd = new RemoteAccessVpnCfgCommand(true, ip.getAddress().addr(), vpn.getLocalIp(), vpn.getIpRange(), vpn.getIpsecPresharedKey()); @@ -3226,7 +3232,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (rules != null) { rulesTO = new ArrayList(); for (FirewallRule rule : rules) { - IpAddress sourceIp = _networkMgr.getIp(rule.getSourceIpAddressId()); + IpAddress sourceIp = _networkModel.getIp(rule.getSourceIpAddressId()); FirewallRuleTO ruleTO = new FirewallRuleTO(rule, null, sourceIp.getAddress().addr()); rulesTO.add(ruleTO); } @@ -3370,7 +3376,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (rules != null) { rulesTO = new ArrayList(); for (StaticNat rule : rules) { - IpAddress sourceIp = _networkMgr.getIp(rule.getSourceIpAddressId()); + IpAddress sourceIp = _networkModel.getIp(rule.getSourceIpAddressId()); StaticNatRuleTO ruleTO = new StaticNatRuleTO(0, sourceIp.getAddress().addr(), null, null, rule.getDestIpAddress(), null, null, null, rule.isForRevoke(), false); rulesTO.add(ruleTO); @@ -3503,7 +3509,7 @@ public class VirtualNetworkApplianceManagerImpl implements VirtualNetworkApplian if (privateIP != null) { List routerNics = _nicDao.listByVmId(router.getId()); for (Nic routerNic : routerNics) { - Network network = _networkMgr.getNetwork(routerNic.getNetworkId()); + Network network = _networkModel.getNetwork(routerNic.getNetworkId()); if (network.getTrafficType() == TrafficType.Public) { boolean forVpc = router.getVpcId() != null; final NetworkUsageCommand usageCmd = new NetworkUsageCommand(privateIP, router.getHostName(), diff --git a/server/src/com/cloud/network/router/VpcVirtualNetworkApplianceManagerImpl.java b/server/src/com/cloud/network/router/VpcVirtualNetworkApplianceManagerImpl.java index 1fd710dc23d..155aeb512e0 100644 --- a/server/src/com/cloud/network/router/VpcVirtualNetworkApplianceManagerImpl.java +++ b/server/src/com/cloud/network/router/VpcVirtualNetworkApplianceManagerImpl.java @@ -30,7 +30,6 @@ import org.apache.log4j.Logger; import com.cloud.agent.AgentManager.OnError; import com.cloud.agent.api.Command; -import com.cloud.agent.api.GetDomRVersionCmd; import com.cloud.agent.api.NetworkUsageCommand; import com.cloud.agent.api.PlugNicAnswer; import com.cloud.agent.api.PlugNicCommand; @@ -105,7 +104,7 @@ import com.cloud.network.vpc.dao.StaticRouteDao; import com.cloud.network.vpc.dao.VpcDao; import com.cloud.network.vpc.dao.VpcOfferingDao; import com.cloud.network.vpn.Site2SiteVpnManager; -import com.cloud.offerings.NetworkOfferingVO; +import com.cloud.offering.NetworkOffering; import com.cloud.user.Account; import com.cloud.user.UserStatisticsVO; import com.cloud.utils.Pair; @@ -287,12 +286,12 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian } //Check if router is a part of the Guest network - if (!_networkMgr.isVmPartOfNetwork(router.getId(), network.getId())) { + if (!_networkModel.isVmPartOfNetwork(router.getId(), network.getId())) { s_logger.debug("Router " + router + " is not a part of the Guest network " + network); return true; } - boolean result = setupVpcGuestNetwork(network, router, false, _networkMgr.getNicProfile(router, network.getId(), null)); + boolean result = setupVpcGuestNetwork(network, router, false, _networkModel.getNicProfile(router, network.getId(), null)); if (!result) { s_logger.warn("Failed to destroy guest network config " + network + " on router " + router); return false; @@ -421,13 +420,13 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian } protected SetupGuestNetworkCommand createSetupGuestNetworkCommand(VirtualRouter router, boolean add, NicProfile guestNic) { - Network network = _networkMgr.getNetwork(guestNic.getNetworkId()); + Network network = _networkModel.getNetwork(guestNic.getNetworkId()); String defaultDns1 = null; String defaultDns2 = null; - boolean dnsProvided = _networkMgr.isProviderSupportServiceInNetwork(network.getId(), Service.Dns, Provider.VPCVirtualRouter); - boolean dhcpProvided = _networkMgr.isProviderSupportServiceInNetwork(network.getId(), Service.Dhcp, + boolean dnsProvided = _networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.Dns, Provider.VPCVirtualRouter); + boolean dhcpProvided = _networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.Dhcp, Provider.VPCVirtualRouter); boolean setupDns = dnsProvided || dhcpProvided; @@ -441,7 +440,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian String networkDomain = network.getNetworkDomain(); String dhcpRange = getGuestDhcpRange(guestNic, network, _configMgr.getZone(network.getDataCenterId())); - NicProfile nicProfile = _networkMgr.getNicProfile(router, nic.getNetworkId(), null); + NicProfile nicProfile = _networkModel.getNicProfile(router, nic.getNetworkId(), null); SetupGuestNetworkCommand setupCmd = new SetupGuestNetworkCommand(dhcpRange, networkDomain, false, null, defaultDns1, defaultDns2, add, _itMgr.toNicTO(nicProfile, router.getHypervisorType())); @@ -482,8 +481,8 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian List ipAddrList = vlanAndIp.getValue(); // Get network rate - required for IpAssoc - Integer networkRate = _networkMgr.getNetworkRate(ipAddrList.get(0).getNetworkId(), router.getId()); - Network network = _networkMgr.getNetwork(ipAddrList.get(0).getNetworkId()); + Integer networkRate = _networkModel.getNetworkRate(ipAddrList.get(0).getNetworkId(), router.getId()); + Network network = _networkModel.getNetwork(ipAddrList.get(0).getNetworkId()); IpAddressTO[] ipsToSend = new IpAddressTO[ipAddrList.size()]; int i = 0; @@ -498,7 +497,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian networkRate, ipAddr.isOneToOneNat()); ip.setTrafficType(network.getTrafficType()); - ip.setNetworkName(_networkMgr.getNetworkTag(router.getHypervisorType(), network)); + ip.setNetworkName(_networkModel.getNetworkTag(router.getHypervisorType(), network)); ipsToSend[i++] = ip; if (ipAddr.isSourceNat()) { sourceNatIpAdd = new Pair(ip, ipAddr.getNetworkId()); @@ -528,7 +527,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian } protected NicTO getNicTO(final VirtualRouter router, Long networkId, String broadcastUri) { - NicProfile nicProfile = _networkMgr.getNicProfile(router, networkId, broadcastUri); + NicProfile nicProfile = _networkModel.getNicProfile(router, networkId, broadcastUri); return _itMgr.toNicTO(nicProfile, router.getHypervisorType()); } @@ -557,7 +556,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian for (String vlanTag : nicsToUnplug.keySet()) { Network publicNtwk = null; try { - publicNtwk = _networkMgr.getNetwork(nicsToUnplug.get(vlanTag).getNetworkId()); + publicNtwk = _networkModel.getNetwork(nicsToUnplug.get(vlanTag).getNetworkId()); URI broadcastUri = BroadcastDomainType.Vlan.toUri(vlanTag); _itMgr.removeVmFromNetwork(router, publicNtwk, broadcastUri); } catch (ConcurrentOperationException e) { @@ -589,7 +588,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian NicProfile publicNic = null; Network publicNtwk = null; try { - publicNtwk = _networkMgr.getNetwork(ip.getNetworkId()); + publicNtwk = _networkModel.getNetwork(ip.getNetworkId()); publicNic = _itMgr.addVmToNetwork(router, publicNtwk, defaultNic); } catch (ConcurrentOperationException e) { s_logger.warn("Failed to add router " + router + " to vlan " + vlanTag + @@ -772,7 +771,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian List routerNics = _nicDao.listByVmId(profile.getId()); for (Nic routerNic : routerNics) { - Network network = _networkMgr.getNetwork(routerNic.getNetworkId()); + Network network = _networkModel.getNetwork(routerNic.getNetworkId()); if (network.getTrafficType() == TrafficType.Guest) { Pair guestNic = new Pair(routerNic, network); guestNics.add(guestNic); @@ -835,10 +834,10 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian PlugNicCommand plugNicCmd = new PlugNicCommand(getNicTO(router, guestNic.getNetworkId(), null), router.getInstanceName()); cmds.addCommand(plugNicCmd); - if (!_networkMgr.isPrivateGateway(guestNic)) { + if (!_networkModel.isPrivateGateway(guestNic)) { //set guest network VirtualMachine vm = _vmDao.findById(router.getId()); - NicProfile nicProfile = _networkMgr.getNicProfile(vm, guestNic.getNetworkId(), null); + NicProfile nicProfile = _networkModel.getNicProfile(vm, guestNic.getNetworkId(), null); SetupGuestNetworkCommand setupCmd = createSetupGuestNetworkCommand(router, true, nicProfile); cmds.addCommand(setupCmd); } else { @@ -918,7 +917,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian super.finalizeNetworkRulesForNetwork(cmds, router, provider, guestNetworkId); if (router.getVpcId() != null) { - if (_networkMgr.isProviderSupportServiceInNetwork(guestNetworkId, Service.NetworkACL, Provider.VPCVirtualRouter)) { + if (_networkModel.isProviderSupportServiceInNetwork(guestNetworkId, Service.NetworkACL, Provider.VPCVirtualRouter)) { List networkACLs = _networkACLMgr.listNetworkACLs(guestNetworkId); s_logger.debug("Found " + networkACLs.size() + " network ACLs to apply as a part of VPC VR " + router + " start for guest network id=" + guestNetworkId); @@ -933,7 +932,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian public boolean setupPrivateGateway(PrivateGateway gateway, VirtualRouter router) throws ConcurrentOperationException, ResourceUnavailableException { boolean result = true; try { - Network network = _networkMgr.getNetwork(gateway.getNetworkId()); + Network network = _networkModel.getNetwork(gateway.getNetworkId()); NicProfile requested = createPrivateNicProfileForGateway(gateway); NicProfile guestNic = _itMgr.addVmToNetwork(router, network, requested); @@ -1006,15 +1005,15 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian public boolean destroyPrivateGateway(PrivateGateway gateway, VirtualRouter router) throws ConcurrentOperationException, ResourceUnavailableException { - if (!_networkMgr.isVmPartOfNetwork(router.getId(), gateway.getNetworkId())) { + if (!_networkModel.isVmPartOfNetwork(router.getId(), gateway.getNetworkId())) { s_logger.debug("Router doesn't have nic for gateway " + gateway + " so no need to removed it"); return true; } - Network privateNetwork = _networkMgr.getNetwork(gateway.getNetworkId()); + Network privateNetwork = _networkModel.getNetwork(gateway.getNetworkId()); s_logger.debug("Releasing private ip for gateway " + gateway + " from " + router); - boolean result = setupVpcPrivateNetwork(router, false, _networkMgr.getNicProfile(router, privateNetwork.getId(), null)); + boolean result = setupVpcPrivateNetwork(router, false, _networkModel.getNicProfile(router, privateNetwork.getId(), null)); if (!result) { s_logger.warn("Failed to release private ip for gateway " + gateway + " on router " + router); return false; @@ -1167,13 +1166,13 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian int i = 0; for (final PrivateIpAddress ipAddr : ipAddrList) { - Network network = _networkMgr.getNetwork(ipAddr.getNetworkId()); + Network network = _networkModel.getNetwork(ipAddr.getNetworkId()); IpAddressTO ip = new IpAddressTO(Account.ACCOUNT_ID_SYSTEM, ipAddr.getIpAddress(), add, false, false, ipAddr.getVlanTag(), ipAddr.getGateway(), ipAddr.getNetmask(), ipAddr.getMacAddress(), null, false); ip.setTrafficType(network.getTrafficType()); - ip.setNetworkName(_networkMgr.getNetworkTag(router.getHypervisorType(), network)); + ip.setNetworkName(_networkModel.getNetworkTag(router.getHypervisorType(), network)); ipsToSend[i++] = ip; } @@ -1205,7 +1204,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian VpcGateway privateGateway = _vpcMgr.getPrivateGatewayForVpc(vpcId); if (privateGateway != null) { NicProfile privateNic = createPrivateNicProfileForGateway(privateGateway); - Network privateNetwork = _networkMgr.getNetwork(privateGateway.getNetworkId()); + Network privateNetwork = _networkModel.getNetwork(privateGateway.getNetworkId()); networks.add(new Pair((NetworkVO) privateNetwork, privateNic)); } @@ -1235,7 +1234,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian publicNic.setBroadcastType(BroadcastDomainType.Vlan); publicNic.setBroadcastUri(BroadcastDomainType.Vlan.toUri(publicIp.getVlanTag())); publicNic.setIsolationUri(IsolationType.Vlan.toUri(publicIp.getVlanTag())); - NetworkOfferingVO publicOffering = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemPublicNetwork).get(0); + NetworkOffering publicOffering = _networkModel.getSystemAccountNetworkOfferings(NetworkOffering.SystemPublicNetwork).get(0); List publicNetworks = _networkMgr.setupNetwork(_systemAcct, publicOffering, plan, null, null, false); networks.add(new Pair(publicNetworks.get(0), publicNic)); publicVlans.add(publicIp.getVlanTag()); @@ -1247,7 +1246,7 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian @DB protected NicProfile createPrivateNicProfileForGateway(VpcGateway privateGateway) { - Network privateNetwork = _networkMgr.getNetwork(privateGateway.getNetworkId()); + Network privateNetwork = _networkModel.getNetwork(privateGateway.getNetworkId()); PrivateIpVO ipVO = _privateIpDao.allocateIpAddress(privateNetwork.getDataCenterId(), privateNetwork.getId(), privateGateway.getIp4Address()); Nic privateNic = _nicDao.findByIp4AddressAndNetworkId(ipVO.getIpAddress(), privateNetwork.getId()); @@ -1256,9 +1255,9 @@ public class VpcVirtualNetworkApplianceManagerImpl extends VirtualNetworkApplian if (privateNic != null) { VirtualMachine vm = _vmDao.findById(privateNic.getId()); privateNicProfile = new NicProfile(privateNic, privateNetwork, privateNic.getBroadcastUri(), privateNic.getIsolationUri(), - _networkMgr.getNetworkRate(privateNetwork.getId(), vm.getId()), - _networkMgr.isSecurityGroupSupportedInNetwork(privateNetwork), - _networkMgr.getNetworkTag(vm.getHypervisorType(), privateNetwork)); + _networkModel.getNetworkRate(privateNetwork.getId(), vm.getId()), + _networkModel.isSecurityGroupSupportedInNetwork(privateNetwork), + _networkModel.getNetworkTag(vm.getHypervisorType(), privateNetwork)); } else { String vlanTag = privateNetwork.getBroadcastUri().getHost(); String netmask = NetUtils.getCidrNetmask(privateNetwork.getCidr()); diff --git a/server/src/com/cloud/network/rules/RulesManagerImpl.java b/server/src/com/cloud/network/rules/RulesManagerImpl.java index a75aca3a522..fc12660638f 100755 --- a/server/src/com/cloud/network/rules/RulesManagerImpl.java +++ b/server/src/com/cloud/network/rules/RulesManagerImpl.java @@ -32,6 +32,7 @@ import com.cloud.network.IpAddress; import com.cloud.network.Network; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.dao.FirewallRulesCidrsDao; import com.cloud.network.dao.FirewallRulesDao; import com.cloud.network.dao.IPAddressDao; @@ -90,6 +91,8 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { @Inject NetworkManager _networkMgr; @Inject + NetworkModel _networkModel; + @Inject EventDao _eventDao; @Inject UsageEventDao _usageEventDao; @@ -173,14 +176,14 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { } Long networkId = rule.getNetworkId(); - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); //associate ip address to network (if needed) boolean performedIpAssoc = false; if (ipAddress.getAssociatedWithNetworkId() == null) { boolean assignToVpcNtwk = network.getVpcId() != null && ipAddress.getVpcId() != null && ipAddress.getVpcId().longValue() == network.getVpcId(); if (assignToVpcNtwk) { - _networkMgr.checkIpForService(ipAddress, Service.PortForwarding, networkId); + _networkModel.checkIpForService(ipAddress, Service.PortForwarding, networkId); s_logger.debug("The ip is not associated with the VPC network id="+ networkId + ", so assigning"); try { @@ -192,7 +195,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { } } } else { - _networkMgr.checkIpForService(ipAddress, Service.PortForwarding, null); + _networkModel.checkIpForService(ipAddress, Service.PortForwarding, null); } if (ipAddress.getAssociatedWithNetworkId() == null) { @@ -228,7 +231,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { // Verify that vm has nic in the network Ip dstIp = rule.getDestinationIpAddress(); - Nic guestNic = _networkMgr.getNicInNetwork(vmId, networkId); + Nic guestNic = _networkModel.getNicInNetwork(vmId, networkId); if (guestNic == null || guestNic.getIp4Address() == null) { throw new InvalidParameterValueException("Vm doesn't belong to network associated with ipAddress"); } else { @@ -326,15 +329,15 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { Long accountId = ipAddress.getAllocatedToAccountId(); Long domainId = ipAddress.getAllocatedInDomainId(); - _networkMgr.checkIpForService(ipAddress, Service.StaticNat, null); + _networkModel.checkIpForService(ipAddress, Service.StaticNat, null); - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); NetworkOffering off = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); if (off.getElasticIp()) { throw new InvalidParameterValueException("Can't create ip forwarding rules for the network where elasticIP service is enabled"); } - String dstIp = _networkMgr.getIpInNetwork(ipAddress.getAssociatedWithVmId(), networkId); + String dstIp = _networkModel.getIpInNetwork(ipAddress.getAssociatedWithVmId(), networkId); Transaction txn = Transaction.currentTxn(); txn.start(); @@ -398,19 +401,19 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { boolean performedIpAssoc = false; boolean result = false; try { - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); if (network == null) { throw new InvalidParameterValueException("Unable to find network by id"); } // Check that vm has a nic in the network - Nic guestNic = _networkMgr.getNicInNetwork(vmId, networkId); + Nic guestNic = _networkModel.getNicInNetwork(vmId, networkId); if (guestNic == null) { throw new InvalidParameterValueException("Vm doesn't belong to the network with specified id"); } - if (!_networkMgr.areServicesSupportedInNetwork(network.getId(), Service.StaticNat)) { + if (!_networkModel.areServicesSupportedInNetwork(network.getId(), Service.StaticNat)) { throw new InvalidParameterValueException("Unable to create static nat rule; StaticNat service is not " + "supported in network with specified id"); } @@ -426,7 +429,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { boolean assignToVpcNtwk = network.getVpcId() != null && ipAddress.getVpcId() != null && ipAddress.getVpcId().longValue() == network.getVpcId(); if (assignToVpcNtwk) { - _networkMgr.checkIpForService(ipAddress, Service.StaticNat, networkId); + _networkModel.checkIpForService(ipAddress, Service.StaticNat, networkId); s_logger.debug("The ip is not associated with the VPC network id="+ networkId + ", so assigning"); try { @@ -439,7 +442,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { performedIpAssoc = true; } } else { - _networkMgr.checkIpForService(ipAddress, Service.StaticNat, null); + _networkModel.checkIpForService(ipAddress, Service.StaticNat, null); } if (ipAddress.getAssociatedWithNetworkId() == null) { @@ -512,7 +515,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { Long networkId = oldIP.getAssociatedWithNetworkId(); boolean reassignStaticNat = false; if (networkId != null) { - Network guestNetwork = _networkMgr.getNetwork(networkId); + Network guestNetwork = _networkModel.getNetwork(networkId); NetworkOffering offering = _configMgr.getNetworkOffering(guestNetwork.getNetworkOfferingId()); if (offering.getElasticIp()) { reassignStaticNat = true; @@ -875,7 +878,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { List staticNats = new ArrayList(); for (IPAddressVO ip : ips) { // Get nic IP4 address - String dstIp = _networkMgr.getIpInNetwork(ip.getAssociatedWithVmId(), networkId); + String dstIp = _networkModel.getIpInNetwork(ip.getAssociatedWithVmId(), networkId); StaticNatImpl staticNat = new StaticNatImpl(ip.getAllocatedToAccountId(), ip.getAllocatedInDomainId(), networkId, ip.getId(), dstIp, false); staticNats.add(staticNat); } @@ -1170,7 +1173,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { // if network has elastic IP functionality supported, we first have to disable static nat on old ip in order to // re-enable it on the new one enable static nat takes care of that - Network guestNetwork = _networkMgr.getNetwork(ipAddress.getAssociatedWithNetworkId()); + Network guestNetwork = _networkModel.getNetwork(ipAddress.getAssociatedWithNetworkId()); NetworkOffering offering = _configMgr.getNetworkOffering(guestNetwork.getNetworkOfferingId()); if (offering.getElasticIp()) { getSystemIpAndEnableStaticNatForVm(_vmDao.findById(vmId), true); @@ -1256,9 +1259,9 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { String dstIp; if (forRevoke) { - dstIp = _networkMgr.getIpInNetworkIncludingRemoved(ip.getAssociatedWithVmId(), rule.getNetworkId()); + dstIp = _networkModel.getIpInNetworkIncludingRemoved(ip.getAssociatedWithVmId(), rule.getNetworkId()); } else { - dstIp = _networkMgr.getIpInNetwork(ip.getAssociatedWithVmId(), rule.getNetworkId()); + dstIp = _networkModel.getIpInNetwork(ip.getAssociatedWithVmId(), rule.getNetworkId()); } return new StaticNatRuleImpl(ruleVO, dstIp); @@ -1326,7 +1329,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { } UserVmVO vm = _vmDao.findById(sourceIp.getAssociatedWithVmId()); - Network network = _networkMgr.getNetwork(networkId); + Network network = _networkModel.getNetwork(networkId); if (network == null) { CloudRuntimeException ex = new CloudRuntimeException("Unable to find an ip address to map to specified vm id"); ex.addProxyObject(vm, vm.getId(), "vmId"); @@ -1342,9 +1345,9 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { String dstIp; if (forRevoke) { - dstIp = _networkMgr.getIpInNetworkIncludingRemoved(sourceIp.getAssociatedWithVmId(), networkId); + dstIp = _networkModel.getIpInNetworkIncludingRemoved(sourceIp.getAssociatedWithVmId(), networkId); } else { - dstIp = _networkMgr.getIpInNetwork(sourceIp.getAssociatedWithVmId(), networkId); + dstIp = _networkModel.getIpInNetwork(sourceIp.getAssociatedWithVmId(), networkId); } StaticNatImpl staticNat = new StaticNatImpl(sourceIp.getAllocatedToAccountId(), sourceIp.getAllocatedInDomainId(), @@ -1360,7 +1363,7 @@ public class RulesManagerImpl implements RulesManager, RulesService, Manager { // enable static nat if eIp capability is supported List nics = _nicDao.listByVmId(vm.getId()); for (Nic nic : nics) { - Network guestNetwork = _networkMgr.getNetwork(nic.getNetworkId()); + Network guestNetwork = _networkModel.getNetwork(nic.getNetworkId()); NetworkOffering offering = _configMgr.getNetworkOffering(guestNetwork.getNetworkOfferingId()); if (offering.getElasticIp()) { // check if there is already static nat enabled diff --git a/server/src/com/cloud/network/security/SecurityGroupManagerImpl.java b/server/src/com/cloud/network/security/SecurityGroupManagerImpl.java index 8e458999fb5..b564e3d5759 100755 --- a/server/src/com/cloud/network/security/SecurityGroupManagerImpl.java +++ b/server/src/com/cloud/network/security/SecurityGroupManagerImpl.java @@ -64,6 +64,7 @@ import com.cloud.exception.ResourceInUseException; import com.cloud.hypervisor.Hypervisor.HypervisorType; import com.cloud.network.Network; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.security.SecurityGroupWork.Step; import com.cloud.network.security.SecurityRule.SecurityRuleType; import com.cloud.network.security.dao.SecurityGroupDao; @@ -150,6 +151,8 @@ public class SecurityGroupManagerImpl implements SecurityGroupManager, SecurityG @Inject NetworkManager _networkMgr; @Inject + NetworkModel _networkModel; + @Inject AccountManager _accountMgr; @Inject DomainManager _domainMgr; @@ -351,7 +354,7 @@ public class SecurityGroupManagerImpl implements SecurityGroupManager, SecurityG if (rule.getAllowedNetworkId() != null) { List allowedInstances = _securityGroupVMMapDao.listBySecurityGroup(rule.getAllowedNetworkId(), State.Running); for (SecurityGroupVMMapVO ngmapVO : allowedInstances) { - Nic defaultNic = _networkMgr.getDefaultNic(ngmapVO.getInstanceId()); + Nic defaultNic = _networkModel.getDefaultNic(ngmapVO.getInstanceId()); if (defaultNic != null) { String cidr = defaultNic.getIp4Address(); cidr = cidr + "/32"; @@ -1248,8 +1251,8 @@ public class SecurityGroupManagerImpl implements SecurityGroupManager, SecurityG VirtualMachine vm = _vmDao.findByIdIncludingRemoved(vmId); List nics = _networkMgr.getNicProfiles(vm); for (NicProfile nic : nics) { - Network network = _networkMgr.getNetwork(nic.getNetworkId()); - if (_networkMgr.isSecurityGroupSupportedInNetwork(network) && vm.getHypervisorType() != HypervisorType.VMware) { + Network network = _networkModel.getNetwork(nic.getNetworkId()); + if (_networkModel.isSecurityGroupSupportedInNetwork(network) && vm.getHypervisorType() != HypervisorType.VMware) { return true; } } diff --git a/server/src/com/cloud/network/vpc/NetworkACLManagerImpl.java b/server/src/com/cloud/network/vpc/NetworkACLManagerImpl.java index 4697acb17ac..5e5b4baff80 100644 --- a/server/src/com/cloud/network/vpc/NetworkACLManagerImpl.java +++ b/server/src/com/cloud/network/vpc/NetworkACLManagerImpl.java @@ -35,7 +35,7 @@ import com.cloud.exception.ResourceUnavailableException; import com.cloud.network.Network; import com.cloud.network.Network.Capability; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.Networks; import com.cloud.network.dao.FirewallRulesDao; import com.cloud.network.firewall.NetworkACLService; @@ -78,7 +78,7 @@ public class NetworkACLManagerImpl implements Manager,NetworkACLManager{ @Inject FirewallRulesDao _firewallDao; @Inject - NetworkManager _networkMgr; + NetworkModel _networkMgr; @Inject VpcManager _vpcMgr; @Inject diff --git a/server/src/com/cloud/network/vpc/VpcManagerImpl.java b/server/src/com/cloud/network/vpc/VpcManagerImpl.java index 7448cc3cadc..fa6bd30f980 100644 --- a/server/src/com/cloud/network/vpc/VpcManagerImpl.java +++ b/server/src/com/cloud/network/vpc/VpcManagerImpl.java @@ -62,6 +62,8 @@ import com.cloud.network.Network.GuestType; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; +import com.cloud.network.NetworkService; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.BroadcastDomainType; import com.cloud.network.Networks.TrafficType; @@ -137,6 +139,10 @@ public class VpcManagerImpl implements VpcManager, Manager{ @Inject NetworkManager _ntwkMgr; @Inject + NetworkModel _ntwkModel; + @Inject + NetworkService _ntwkSvc; + @Inject IPAddressDao _ipAddressDao; @Inject DomainRouterDao _routerDao; @@ -544,12 +550,12 @@ public class VpcManagerImpl implements VpcManager, Manager{ if (networkDomain == null) { // 1) Get networkDomain from the corresponding account - networkDomain = _ntwkMgr.getAccountNetworkDomain(owner.getId(), zoneId); + networkDomain = _ntwkModel.getAccountNetworkDomain(owner.getId(), zoneId); // 2) If null, generate networkDomain using domain suffix from the global config variables if (networkDomain == null) { - networkDomain = "cs" + Long.toHexString(owner.getId()) + _ntwkMgr.getDefaultNetworkDomain(); + networkDomain = "cs" + Long.toHexString(owner.getId()) + _ntwkModel.getDefaultNetworkDomain(); } } @@ -561,7 +567,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ { //the provider has to be enabled at least in one network in the zone for (PhysicalNetwork pNtwk : _pNtwkDao.listByZone(zoneId)) { - if (_ntwkMgr.isProviderEnabledInPhysicalNetwork(pNtwk.getId(), Provider.VPCVirtualRouter.getName())) { + if (_ntwkModel.isProviderEnabledInPhysicalNetwork(pNtwk.getId(), Provider.VPCVirtualRouter.getName())) { return true; } } @@ -958,7 +964,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ } //2) validate network offering attributes - List svcs = _ntwkMgr.listNetworkOfferingServices(guestNtwkOff.getId()); + List svcs = _ntwkModel.listNetworkOfferingServices(guestNtwkOff.getId()); validateNtwkOffForVpc(guestNtwkOff, svcs); //3) Check services/providers against VPC providers @@ -974,14 +980,14 @@ public class VpcManagerImpl implements VpcManager, Manager{ } //4) Only one network in the VPC can support LB - if (_ntwkMgr.areServicesSupportedByNetworkOffering(guestNtwkOff.getId(), Service.Lb)) { + if (_ntwkModel.areServicesSupportedByNetworkOffering(guestNtwkOff.getId(), Service.Lb)) { List networks = getVpcNetworks(vpc.getId()); for (Network network : networks) { if (networkId != null && network.getId() == networkId.longValue()) { //skip my own network continue; } else { - if (_ntwkMgr.areServicesSupportedInNetwork(network.getId(), Service.Lb)) { + if (_ntwkModel.areServicesSupportedInNetwork(network.getId(), Service.Lb)) { throw new InvalidParameterValueException("LB service is already supported " + "by network " + network + " in VPC " + vpc); } @@ -993,7 +999,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ @Override public void validateNtwkOffForVpc(NetworkOffering guestNtwkOff, List supportedSvcs) { //1) in current release, only vpc provider is supported by Vpc offering - List providers = _ntwkMgr.getNtwkOffDistinctProviders(guestNtwkOff.getId()); + List providers = _ntwkModel.getNtwkOffDistinctProviders(guestNtwkOff.getId()); for (Provider provider : providers) { if (provider != Provider.VPCVirtualRouter) { throw new InvalidParameterValueException("Only provider of type " + Provider.VPCVirtualRouter.getName() @@ -1088,7 +1094,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ protected VpcProvider getVpcElement() { if (vpcElement == null) { - vpcElement = ((VpcProvider)_ntwkMgr.getElementImplementingProvider(Provider.VPCVirtualRouter.getName())); + vpcElement = ((VpcProvider)_ntwkModel.getElementImplementingProvider(Provider.VPCVirtualRouter.getName())); } if (vpcElement == null) { @@ -1216,7 +1222,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ } protected PrivateGateway getPrivateGatewayProfile(VpcGateway gateway) { - Network network = _ntwkMgr.getNetwork(gateway.getNetworkId()); + Network network = _ntwkModel.getNetwork(gateway.getNetworkId()); return new PrivateGatewayProfile(gateway, network.getPhysicalNetworkId()); } @@ -1243,7 +1249,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ //Validate physical network if (physicalNetworkId == null) { - List pNtwks = _ntwkMgr.getPhysicalNtwksSupportingTrafficType(vpc.getZoneId(), TrafficType.Guest); + List pNtwks = _ntwkModel.getPhysicalNtwksSupportingTrafficType(vpc.getZoneId(), TrafficType.Guest); if (pNtwks.isEmpty() || pNtwks.size() != 1) { throw new InvalidParameterValueException("Physical network can't be determined; pass physical network id"); } @@ -1255,7 +1261,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ s_logger.debug("Creating Private gateway for VPC " + vpc); //1) create private network String networkName = "vpc-" + vpc.getName() + "-privateNetwork"; - Network privateNtwk = _ntwkMgr.createPrivateNetwork(networkName, networkName, physicalNetworkId, + Network privateNtwk = _ntwkSvc.createPrivateNetwork(networkName, networkName, physicalNetworkId, vlan, ipAddress, null, gateway, netmask, gatewayOwnerId, vpcId); //2) create gateway entry @@ -1767,7 +1773,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ Account caller = UserContext.current().getCaller(); Account owner = null; - IpAddress ipToAssoc = _ntwkMgr.getIp(ipId); + IpAddress ipToAssoc = _ntwkModel.getIp(ipId); if (ipToAssoc != null) { _accountMgr.checkAccess(caller, null, true, ipToAssoc); owner = _accountMgr.getAccount(ipToAssoc.getAllocatedToAccountId()); @@ -1826,7 +1832,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ boolean success = false; try { //unassign ip from the VPC router - success = _ntwkMgr.applyIpAssociations(_ntwkMgr.getNetwork(networkId), true); + success = _ntwkMgr.applyIpAssociations(_ntwkModel.getNetwork(networkId), true); } catch (ResourceUnavailableException ex) { throw new CloudRuntimeException("Failed to apply ip associations for network id=" + networkId + " as a part of unassigning ip " + ipId + " from vpc", ex); @@ -1953,7 +1959,7 @@ public class VpcManagerImpl implements VpcManager, Manager{ validateNtkwOffForVpc(ntwkOffId, null, null, null, vpc, networkId, null); } - return _ntwkMgr.updateGuestNetwork(networkId, name, displayText, callerAccount, callerUser, domainSuffix, + return _ntwkSvc.updateGuestNetwork(networkId, name, displayText, callerAccount, callerUser, domainSuffix, ntwkOffId, changeCidr); } diff --git a/server/src/com/cloud/network/vpn/RemoteAccessVpnManagerImpl.java b/server/src/com/cloud/network/vpn/RemoteAccessVpnManagerImpl.java index 67d6b8ccbf3..81721ea4992 100755 --- a/server/src/com/cloud/network/vpn/RemoteAccessVpnManagerImpl.java +++ b/server/src/com/cloud/network/vpn/RemoteAccessVpnManagerImpl.java @@ -17,6 +17,7 @@ package com.cloud.network.vpn; import java.util.ArrayList; +import java.util.Enumeration; import java.util.List; import java.util.Map; @@ -41,7 +42,7 @@ import com.cloud.exception.ResourceUnavailableException; import com.cloud.network.IPAddressVO; import com.cloud.network.Network; import com.cloud.network.Network.Service; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.PublicIpAddress; import com.cloud.network.RemoteAccessVpn; import com.cloud.network.RemoteAccessVpnVO; @@ -52,6 +53,7 @@ import com.cloud.network.dao.FirewallRulesDao; import com.cloud.network.dao.IPAddressDao; import com.cloud.network.dao.RemoteAccessVpnDao; import com.cloud.network.dao.VpnUserDao; +import com.cloud.network.element.NetworkElement; import com.cloud.network.element.RemoteAccessVPNServiceProvider; import com.cloud.network.rules.FirewallManager; import com.cloud.network.rules.FirewallRule; @@ -68,6 +70,7 @@ import com.cloud.utils.NumbersUtil; import com.cloud.utils.Pair; import com.cloud.utils.PasswordGenerator; import com.cloud.utils.Ternary; +import com.cloud.utils.component.Adapters; import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.Inject; import com.cloud.utils.component.Manager; @@ -91,12 +94,15 @@ public class RemoteAccessVpnManagerImpl implements RemoteAccessVpnService, Manag @Inject IPAddressDao _ipAddressDao; @Inject AccountManager _accountMgr; @Inject DomainManager _domainMgr; - @Inject NetworkManager _networkMgr; + @Inject NetworkModel _networkMgr; @Inject RulesManager _rulesMgr; @Inject DomainDao _domainDao; @Inject FirewallRulesDao _rulesDao; @Inject FirewallManager _firewallMgr; @Inject UsageEventDao _usageEventDao; + @Inject(adapter = RemoteAccessVPNServiceProvider.class) + Adapters _vpnServiceProviders; + int _userLimit; int _pskLength; @@ -227,10 +233,9 @@ public class RemoteAccessVpnManagerImpl implements RemoteAccessVpnService, Manag _remoteAccessVpnDao.update(vpn.getServerAddressId(), vpn); - List elements = _networkMgr.getRemoteAccessVpnElements(); boolean success = false; try { - for (RemoteAccessVPNServiceProvider element : elements) { + for (RemoteAccessVPNServiceProvider element : _vpnServiceProviders) { if (element.stopVpn(network, vpn)) { success = true; break; @@ -374,7 +379,6 @@ public class RemoteAccessVpnManagerImpl implements RemoteAccessVpnService, Manag Network network = _networkMgr.getNetwork(vpn.getNetworkId()); - List elements = _networkMgr.getRemoteAccessVpnElements(); boolean started = false; try { boolean firewallOpened = true; @@ -383,7 +387,7 @@ public class RemoteAccessVpnManagerImpl implements RemoteAccessVpnService, Manag } if (firewallOpened) { - for (RemoteAccessVPNServiceProvider element : elements) { + for (RemoteAccessVPNServiceProvider element : _vpnServiceProviders) { if (element.startVpn(network, vpn)) { started = true; break; @@ -432,12 +436,10 @@ public class RemoteAccessVpnManagerImpl implements RemoteAccessVpnService, Manag } } - List elements = _networkMgr.getRemoteAccessVpnElements(); - boolean success = true; boolean[] finals = new boolean[users.size()]; - for (RemoteAccessVPNServiceProvider element : elements) { + for (RemoteAccessVPNServiceProvider element : _vpnServiceProviders) { s_logger.debug("Applying vpn access to " + element.getName()); for (RemoteAccessVpnVO vpn : vpns) { try { @@ -630,4 +632,12 @@ public class RemoteAccessVpnManagerImpl implements RemoteAccessVpnService, Manag return _remoteAccessVpnDao.findById(vpnId); } + public List getRemoteAccessVPNServiceProviders() { + List result = new ArrayList(); + for (Enumeration e = _vpnServiceProviders.enumeration(); e.hasMoreElements();) { + result.add(e.nextElement()); + } + + return result; + } } diff --git a/server/src/com/cloud/network/vpn/Site2SiteVpnManagerImpl.java b/server/src/com/cloud/network/vpn/Site2SiteVpnManagerImpl.java index 5416db7e075..44baf99b0c0 100644 --- a/server/src/com/cloud/network/vpn/Site2SiteVpnManagerImpl.java +++ b/server/src/com/cloud/network/vpn/Site2SiteVpnManagerImpl.java @@ -44,7 +44,6 @@ import com.cloud.exception.InvalidParameterValueException; import com.cloud.exception.NetworkRuleConflictException; import com.cloud.exception.ResourceUnavailableException; import com.cloud.network.IPAddressVO; -import com.cloud.network.NetworkManager; import com.cloud.network.Site2SiteCustomerGateway; import com.cloud.network.Site2SiteCustomerGatewayVO; import com.cloud.network.Site2SiteVpnConnection; @@ -68,6 +67,7 @@ import com.cloud.user.dao.AccountDao; import com.cloud.utils.NumbersUtil; import com.cloud.utils.Pair; import com.cloud.utils.Ternary; +import com.cloud.utils.component.Adapters; import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.Inject; import com.cloud.utils.component.Manager; @@ -84,10 +84,11 @@ import com.cloud.vm.DomainRouterVO; public class Site2SiteVpnManagerImpl implements Site2SiteVpnManager, Manager { private static final Logger s_logger = Logger.getLogger(Site2SiteVpnManagerImpl.class); + @Inject (adapter = Site2SiteVpnServiceProvider.class) + Adapters _s2sProviders; @Inject Site2SiteCustomerGatewayDao _customerGatewayDao; @Inject Site2SiteVpnGatewayDao _vpnGatewayDao; @Inject Site2SiteVpnConnectionDao _vpnConnectionDao; - @Inject NetworkManager _networkMgr; @Inject VpcDao _vpcDao; @Inject IPAddressDao _ipAddressDao; @Inject AccountDao _accountDao; @@ -107,6 +108,7 @@ public class Site2SiteVpnManagerImpl implements Site2SiteVpnManager, Manager { Map configs = configDao.getConfiguration(params); _connLimit = NumbersUtil.parseInt(configs.get(Config.Site2SiteVpnConnectionPerVpnGatewayLimit.key()), 4); _subnetsLimit = NumbersUtil.parseInt(configs.get(Config.Site2SiteVpnSubnetsPerCustomerGatewayLimit.key()), 10); + assert (_s2sProviders.enumeration().hasMoreElements()): "Did not get injected with a list of S2S providers!"; return true; } @@ -327,9 +329,8 @@ public class Site2SiteVpnManagerImpl implements Site2SiteVpnManager, Manager { conn.setState(State.Pending); _vpnConnectionDao.persist(conn); - List elements = _networkMgr.getSite2SiteVpnElements(); boolean result = true; - for (Site2SiteVpnServiceProvider element : elements) { + for (Site2SiteVpnServiceProvider element : _s2sProviders) { result = result & element.startSite2SiteVpn(conn); } @@ -527,9 +528,8 @@ public class Site2SiteVpnManagerImpl implements Site2SiteVpnManager, Manager { conn.setState(State.Disconnected); _vpnConnectionDao.persist(conn); - List elements = _networkMgr.getSite2SiteVpnElements(); boolean result = true; - for (Site2SiteVpnServiceProvider element : elements) { + for (Site2SiteVpnServiceProvider element : _s2sProviders) { result = result & element.stopSite2SiteVpn(conn); } diff --git a/server/src/com/cloud/resource/DiscovererBase.java b/server/src/com/cloud/resource/DiscovererBase.java index b5896530958..64dfa399a14 100644 --- a/server/src/com/cloud/resource/DiscovererBase.java +++ b/server/src/com/cloud/resource/DiscovererBase.java @@ -32,7 +32,7 @@ import com.cloud.dc.ClusterVO; import com.cloud.dc.dao.ClusterDao; import com.cloud.host.HostVO; import com.cloud.host.dao.HostDao; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.Inject; import com.cloud.utils.net.UrlUtil; @@ -43,7 +43,7 @@ public abstract class DiscovererBase implements Discoverer { private static final Logger s_logger = Logger.getLogger(DiscovererBase.class); @Inject protected ClusterDao _clusterDao; @Inject protected ConfigurationDao _configDao; - @Inject protected NetworkManager _networkMgr; + @Inject protected NetworkModel _networkMgr; @Inject protected HostDao _hostDao; @Override diff --git a/server/src/com/cloud/resource/DummyHostServerResource.java b/server/src/com/cloud/resource/DummyHostServerResource.java index 5144a91a3ec..d300f6b71ea 100644 --- a/server/src/com/cloud/resource/DummyHostServerResource.java +++ b/server/src/com/cloud/resource/DummyHostServerResource.java @@ -91,7 +91,7 @@ public class DummyHostServerResource extends ServerResourceBase { cmd.setPublicIpAddress(getHostStoragePrivateIp()); cmd.setPublicMacAddress(getHostStorageMacAddress().toString()); cmd.setPublicNetmask("255.255.0.0"); - cmd.setVersion("1.0"); + cmd.setVersion(DummyHostServerResource.class.getPackage().getImplementationVersion()); return new StartupCommand[] {cmd}; } diff --git a/server/src/com/cloud/resource/ResourceManagerImpl.java b/server/src/com/cloud/resource/ResourceManagerImpl.java index ffc09f0effe..b6ee747bee9 100755 --- a/server/src/com/cloud/resource/ResourceManagerImpl.java +++ b/server/src/com/cloud/resource/ResourceManagerImpl.java @@ -1772,6 +1772,7 @@ public class ResourceManagerImpl implements ResourceManager, ResourceService, Ma host.setTotalMemory(ssCmd.getMemory()); host.setSpeed(ssCmd.getSpeed()); host.setHypervisorType(hyType); + host.setHypervisorVersion(ssCmd.getHypervisorVersion()); return host; } diff --git a/server/src/com/cloud/server/ManagementServerImpl.java b/server/src/com/cloud/server/ManagementServerImpl.java index 4efae630f36..bad834dde5a 100755 --- a/server/src/com/cloud/server/ManagementServerImpl.java +++ b/server/src/com/cloud/server/ManagementServerImpl.java @@ -89,6 +89,7 @@ import org.apache.cloudstack.api.command.admin.vlan.ListVlanIpRangesCmd; import org.apache.cloudstack.api.command.admin.systemvm.RebootSystemVmCmd; import org.apache.cloudstack.api.command.admin.systemvm.StopSystemVmCmd; import org.apache.cloudstack.api.command.admin.domain.UpdateDomainCmd; +import org.apache.cloudstack.api.command.admin.host.ListHostsCmd; import org.apache.cloudstack.api.command.admin.host.UpdateHostPasswordCmd; import com.cloud.api.query.dao.DomainRouterJoinDao; import com.cloud.api.query.dao.InstanceGroupJoinDao; @@ -219,6 +220,7 @@ import com.cloud.user.UserVO; import com.cloud.user.dao.AccountDao; import com.cloud.user.dao.SSHKeyPairDao; import com.cloud.user.dao.UserDao; +import com.cloud.uservm.UserVm; import com.cloud.utils.EnumUtils; import com.cloud.utils.NumbersUtil; import com.cloud.utils.Pair; @@ -915,9 +917,26 @@ public class ManagementServerImpl implements ManagementServer { return new Pair, Integer>(result.first(), result.second()); } + @Override + public Pair, Integer> searchForServers(ListHostsCmd cmd) { + + Long zoneId = _accountMgr.checkAccessAndSpecifyAuthority(UserContext.current().getCaller(), cmd.getZoneId()); + Object name = cmd.getHostName(); + Object type = cmd.getType(); + Object state = cmd.getState(); + Object pod = cmd.getPodId(); + Object cluster = cmd.getClusterId(); + Object id = cmd.getId(); + Object keyword = cmd.getKeyword(); + Object resourceState = cmd.getResourceState(); + Object haHosts = cmd.getHaHost(); + + Pair, Integer> result = searchForServers(cmd.getStartIndex(), cmd.getPageSizeVal(), name, type, state, zoneId, pod, cluster, id, keyword, resourceState, haHosts); + return new Pair, Integer>(result.first(), result.second()); + } @Override - public Pair, List> listHostsForMigrationOfVM(Long vmId, Long startIndex, Long pageSize) { + public Pair, Integer>, List> listHostsForMigrationOfVM(Long vmId, Long startIndex, Long pageSize) { // access check - only root admin can migrate VM Account caller = UserContext.current().getCaller(); if (caller.getType() != Account.ACCOUNT_TYPE_ADMIN) { @@ -976,10 +995,12 @@ public class ManagementServerImpl implements ManagementServer { s_logger.debug("Searching for all hosts in cluster: " + cluster + " for migrating VM " + vm); } - List allHostsInCluster = searchForServers(startIndex, pageSize, null, hostType, null, null, null, cluster, null, null, null, - null); - // filter out the current host + Pair, Integer> allHostsInClusterPair = searchForServers(startIndex, pageSize, null, hostType, null, null, null, cluster, null, null, null, null); + + // filter out the current host + List allHostsInCluster = allHostsInClusterPair.first(); allHostsInCluster.remove(srcHost); + Pair, Integer> otherHostsInCluster = new Pair, Integer>(allHostsInCluster, new Integer(allHostsInClusterPair.second().intValue()-1)); if (s_logger.isDebugEnabled()) { s_logger.debug("Other Hosts in this cluster: " + allHostsInCluster); @@ -1013,11 +1034,11 @@ public class ManagementServerImpl implements ManagementServer { } } - return new Pair, List>(allHostsInCluster, suitableHosts); + return new Pair, Integer>, List>(otherHostsInCluster, suitableHosts); } - private List searchForServers(Long startIndex, Long pageSize, Object name, Object type, Object state, Object zone, Object pod, - Object cluster, Object id, Object keyword, Object resourceState, Object haHosts) { + private Pair, Integer> searchForServers(Long startIndex, Long pageSize, Object name, Object type, Object state, Object zone, Object pod, Object cluster, Object id, Object keyword, + Object resourceState, Object haHosts) { Filter searchFilter = new Filter(HostVO.class, "id", Boolean.TRUE, startIndex, pageSize); SearchBuilder sb = _hostDao.createSearchBuilder(); @@ -1087,7 +1108,7 @@ public class ManagementServerImpl implements ManagementServer { sc.setJoinParameters("hostTagSearch", "tag", haTag); } - return _hostDao.search(sc, searchFilter); + return _hostDao.searchAndCount(sc, searchFilter); } @Override diff --git a/server/src/com/cloud/storage/StorageManagerImpl.java b/server/src/com/cloud/storage/StorageManagerImpl.java index 55b1342bbd2..07f4d8ac7cb 100755 --- a/server/src/com/cloud/storage/StorageManagerImpl.java +++ b/server/src/com/cloud/storage/StorageManagerImpl.java @@ -125,7 +125,7 @@ import com.cloud.host.Status; import com.cloud.host.dao.HostDao; import com.cloud.hypervisor.Hypervisor.HypervisorType; import com.cloud.hypervisor.HypervisorGuruManager; -import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.offering.ServiceOffering; import com.cloud.org.Grouping; import com.cloud.org.Grouping.AllocationState; @@ -235,7 +235,7 @@ public class StorageManagerImpl implements StorageManager, Manager, ClusterManag @Inject protected SecondaryStorageVmManager _secStorageMgr; @Inject - protected NetworkManager _networkMgr; + protected NetworkModel _networkMgr; @Inject protected VolumeDao _volsDao; @Inject diff --git a/server/src/com/cloud/storage/secondary/SecondaryStorageManagerImpl.java b/server/src/com/cloud/storage/secondary/SecondaryStorageManagerImpl.java index 7a94001c405..e4208811f23 100755 --- a/server/src/com/cloud/storage/secondary/SecondaryStorageManagerImpl.java +++ b/server/src/com/cloud/storage/secondary/SecondaryStorageManagerImpl.java @@ -77,11 +77,13 @@ import com.cloud.keystore.KeystoreManager; import com.cloud.network.IPAddressVO; import com.cloud.network.Network; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; import com.cloud.network.dao.IPAddressDao; import com.cloud.network.dao.NetworkDao; import com.cloud.network.rules.RulesManager; +import com.cloud.offering.NetworkOffering; import com.cloud.offering.ServiceOffering; import com.cloud.offerings.NetworkOfferingVO; import com.cloud.offerings.dao.NetworkOfferingDao; @@ -193,7 +195,9 @@ public class SecondaryStorageManagerImpl implements SecondaryStorageVmManager, V @Inject protected SwiftManager _swiftMgr; @Inject - private NetworkManager _networkMgr; + protected NetworkManager _networkMgr; + @Inject + protected NetworkModel _networkModel; @Inject protected SnapshotDao _snapshotDao; @@ -380,7 +384,7 @@ public class SecondaryStorageManagerImpl implements SecondaryStorageVmManager, V allowedCidrs.add(cidr); } } - List nics = _networkMgr.getNicsForTraffic(secStorageVm.getId(), TrafficType.Management); + List nics = _networkModel.getNicsForTraffic(secStorageVm.getId(), TrafficType.Management); setupCmd.setAllowedInternalSites(allowedCidrs.toArray(new String[allowedCidrs.size()])); } String copyPasswd = _configDao.getValue("secstorage.copy.password"); @@ -547,14 +551,14 @@ public class SecondaryStorageManagerImpl implements SecondaryStorageVmManager, V NetworkVO defaultNetwork = defaultNetworks.get(0); - List offerings = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemControlNetwork, NetworkOfferingVO.SystemManagementNetwork, NetworkOfferingVO.SystemStorageNetwork); + List offerings = _networkModel.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemControlNetwork, NetworkOfferingVO.SystemManagementNetwork, NetworkOfferingVO.SystemStorageNetwork); List> networks = new ArrayList>(offerings.size() + 1); NicProfile defaultNic = new NicProfile(); defaultNic.setDefaultNic(true); defaultNic.setDeviceId(2); try { networks.add(new Pair(_networkMgr.setupNetwork(systemAcct, _networkOfferingDao.findById(defaultNetwork.getNetworkOfferingId()), plan, null, null, false).get(0), defaultNic)); - for (NetworkOfferingVO offering : offerings) { + for (NetworkOffering offering : offerings) { networks.add(new Pair(_networkMgr.setupNetwork(systemAcct, offering, plan, null, null, false).get(0), null)); } } catch (ConcurrentOperationException e) { diff --git a/server/src/com/cloud/vm/UserVmManagerImpl.java b/server/src/com/cloud/vm/UserVmManagerImpl.java old mode 100755 new mode 100644 index 81008eeeb05..0414d9262e2 --- a/server/src/com/cloud/vm/UserVmManagerImpl.java +++ b/server/src/com/cloud/vm/UserVmManagerImpl.java @@ -184,6 +184,8 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager @Inject protected HostPodDao _podDao = null; @Inject + protected NetworkModel _networkModel = null; + @Inject protected NetworkManager _networkMgr = null; @Inject protected StorageManager _storageMgr = null; @@ -354,14 +356,14 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager VMTemplateVO template = _templateDao.findByIdIncludingRemoved(vmInstance.getTemplateId()); if (template.getEnablePassword()) { - Nic defaultNic = _networkMgr.getDefaultNic(vmId); + Nic defaultNic = _networkModel.getDefaultNic(vmId); if (defaultNic == null) { s_logger.error("Unable to reset password for vm " + vmInstance + " as the instance doesn't have default nic"); return false; } Network defaultNetwork = _networkDao.findById(defaultNic.getNetworkId()); - NicProfile defaultNicProfile = new NicProfile(defaultNic, defaultNetwork, null, null, null, _networkMgr.isSecurityGroupSupportedInNetwork(defaultNetwork), _networkMgr.getNetworkTag(template.getHypervisorType(), defaultNetwork)); + NicProfile defaultNicProfile = new NicProfile(defaultNic, defaultNetwork, null, null, null, _networkModel.isSecurityGroupSupportedInNetwork(defaultNetwork), _networkModel.getNetworkTag(template.getHypervisorType(), defaultNetwork)); VirtualMachineProfile vmProfile = new VirtualMachineProfileImpl(vmInstance); vmProfile.setParameter(VirtualMachineProfile.Param.VmPassword, password); @@ -1990,7 +1992,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager private boolean updateUserDataInternal(UserVm vm) throws ResourceUnavailableException, InsufficientCapacityException { VMTemplateVO template = _templateDao.findByIdIncludingRemoved(vm.getTemplateId()); - Nic defaultNic = _networkMgr.getDefaultNic(vm.getId()); + Nic defaultNic = _networkModel.getDefaultNic(vm.getId()); if (defaultNic == null) { s_logger.error("Unable to update userdata for vm id=" + vm.getId() + " as the instance doesn't have default nic"); return false; @@ -1998,12 +2000,12 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager Network defaultNetwork = _networkDao.findById(defaultNic.getNetworkId()); NicProfile defaultNicProfile = new NicProfile(defaultNic, defaultNetwork, null, null, null, - _networkMgr.isSecurityGroupSupportedInNetwork(defaultNetwork), - _networkMgr.getNetworkTag(template.getHypervisorType(), defaultNetwork)); + _networkModel.isSecurityGroupSupportedInNetwork(defaultNetwork), + _networkModel.getNetworkTag(template.getHypervisorType(), defaultNetwork)); VirtualMachineProfile vmProfile = new VirtualMachineProfileImpl((VMInstanceVO)vm); - UserDataServiceProvider element = _networkMgr.getUserDataUpdateProvider(defaultNetwork); + UserDataServiceProvider element = _networkModel.getUserDataUpdateProvider(defaultNetwork); if (element == null) { throw new CloudRuntimeException("Can't find network element for " + Service.UserData.getName() + " provider needed for UserData update"); } @@ -2228,7 +2230,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager _accountMgr.checkAccess(caller, null, true, owner); // Get default guest network in Basic zone - Network defaultNetwork = _networkMgr.getExclusiveGuestNetwork(zone.getId()); + Network defaultNetwork = _networkModel.getExclusiveGuestNetwork(zone.getId()); if (defaultNetwork == null) { throw new InvalidParameterValueException("Unable to find a default network to start a vm"); @@ -2240,7 +2242,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager if (securityGroupIdList != null && isVmWare) { throw new InvalidParameterValueException("Security group feature is not supported for vmWare hypervisor"); - } else if (!isVmWare && _networkMgr.isSecurityGroupSupportedInNetwork(defaultNetwork) && _networkMgr.canAddDefaultSecurityGroup()) { + } else if (!isVmWare && _networkModel.isSecurityGroupSupportedInNetwork(defaultNetwork) && _networkModel.canAddDefaultSecurityGroup()) { //add the default securityGroup only if no security group is specified if(securityGroupIdList == null || securityGroupIdList.isEmpty()){ if (securityGroupIdList == null) { @@ -2280,12 +2282,12 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager // If no network is specified, find system security group enabled network if (networkIdList == null || networkIdList.isEmpty()) { - NetworkVO networkWithSecurityGroup = _networkMgr.getNetworkWithSecurityGroupEnabled(zone.getId()); + Network networkWithSecurityGroup = _networkModel.getNetworkWithSecurityGroupEnabled(zone.getId()); if (networkWithSecurityGroup == null) { throw new InvalidParameterValueException("No network with security enabled is found in zone id=" + zone.getId()); } - networkList.add(networkWithSecurityGroup); + networkList.add(_networkDao.findById(networkWithSecurityGroup.getId())); isSecurityGroupEnabledNetworkUsed = true; } else if (securityGroupIdList != null && !securityGroupIdList.isEmpty()) { @@ -2303,7 +2305,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager throw new InvalidParameterValueException("Unable to find network by id " + networkIdList.get(0).longValue()); } - if (!_networkMgr.isSecurityGroupSupportedInNetwork(network)) { + if (!_networkModel.isSecurityGroupSupportedInNetwork(network)) { throw new InvalidParameterValueException("Network is not security group enabled: " + network.getId()); } @@ -2319,7 +2321,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager throw new InvalidParameterValueException("Unable to find network by id " + networkIdList.get(0).longValue()); } - boolean isSecurityGroupEnabled = _networkMgr.isSecurityGroupSupportedInNetwork(network); + boolean isSecurityGroupEnabled = _networkModel.isSecurityGroupSupportedInNetwork(network); if (isSecurityGroupEnabled) { if (networkIdList.size() > 1) { throw new InvalidParameterValueException("Can't create a vm with multiple networks one of" + @@ -2343,8 +2345,8 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager } // if network is security group enabled, and no security group is specified, then add the default security group automatically - if (isSecurityGroupEnabledNetworkUsed && !isVmWare && _networkMgr.canAddDefaultSecurityGroup()) { - + if (isSecurityGroupEnabledNetworkUsed && !isVmWare && _networkModel.canAddDefaultSecurityGroup()) { + //add the default securityGroup only if no security group is specified if(securityGroupIdList == null || securityGroupIdList.isEmpty()){ if (securityGroupIdList == null) { @@ -2397,9 +2399,9 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager if (requiredOfferings.get(0).getState() == NetworkOffering.State.Enabled) { // get Virtual networks - List virtualNetworks = _networkMgr.listNetworksForAccount(owner.getId(), zone.getId(), Network.GuestType.Isolated); + List virtualNetworks = _networkModel.listNetworksForAccount(owner.getId(), zone.getId(), Network.GuestType.Isolated); if (virtualNetworks.isEmpty()) { - long physicalNetworkId = _networkMgr.findPhysicalNetworkId(zone.getId(), requiredOfferings.get(0).getTags(), requiredOfferings.get(0).getTrafficType()); + long physicalNetworkId = _networkModel.findPhysicalNetworkId(zone.getId(), requiredOfferings.get(0).getTags(), requiredOfferings.get(0).getTrafficType()); // Validate physical network PhysicalNetwork physicalNetwork = _physicalNetworkDao.findById(physicalNetworkId); if (physicalNetwork == null) { @@ -2440,8 +2442,8 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager } } - - _networkMgr.checkNetworkPermissions(owner, network); + + _networkModel.checkNetworkPermissions(owner, network); //don't allow to use system networks NetworkOffering networkOffering = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); @@ -2610,7 +2612,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager networks.add(new Pair(network, profile)); - if (_networkMgr.isSecurityGroupSupportedInNetwork(network)) { + if (_networkModel.isSecurityGroupSupportedInNetwork(network)) { securityGroupEnabled = true; } @@ -2673,8 +2675,8 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager //* verify that there are no duplicates if (hostNames.contains(hostName)) { throw new InvalidParameterValueException("The vm with hostName " + hostName - + " already exists in the network domain: " + ntwkDomain + "; network=" - + _networkMgr.getNetwork(ntwkId)); + + " already exists in the network domain: " + ntwkDomain + "; network=" + + _networkModel.getNetwork(ntwkId)); } } } @@ -3044,7 +3046,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager } //check if vm is security group enabled - if (_securityGroupMgr.isVmSecurityGroupEnabled(vmId) && _securityGroupMgr.getSecurityGroupsForVm(vmId).isEmpty() && !_securityGroupMgr.isVmMappedToDefaultSecurityGroup(vmId) && _networkMgr.canAddDefaultSecurityGroup()) { + if (_securityGroupMgr.isVmSecurityGroupEnabled(vmId) && _securityGroupMgr.getSecurityGroupsForVm(vmId).isEmpty() && !_securityGroupMgr.isVmMappedToDefaultSecurityGroup(vmId) && _networkModel.canAddDefaultSecurityGroup()) { //if vm is not mapped to security group, create a mapping if (s_logger.isDebugEnabled()) { s_logger.debug("Vm " + vm + " is security group enabled, but not mapped to default security group; creating the mapping automatically"); @@ -3657,7 +3659,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager List networkList = new ArrayList(); // Get default guest network in Basic zone - Network defaultNetwork = _networkMgr.getExclusiveGuestNetwork(zone.getId()); + Network defaultNetwork = _networkModel.getExclusiveGuestNetwork(zone.getId()); if (defaultNetwork == null) { throw new InvalidParameterValueException("Unable to find a default network to start a vm"); @@ -3669,7 +3671,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager if (securityGroupIdList != null && isVmWare) { throw new InvalidParameterValueException("Security group feature is not supported for vmWare hypervisor"); - } else if (!isVmWare && _networkMgr.isSecurityGroupSupportedInNetwork(defaultNetwork) && _networkMgr.canAddDefaultSecurityGroup()) { + } else if (!isVmWare && _networkModel.isSecurityGroupSupportedInNetwork(defaultNetwork) && _networkModel.canAddDefaultSecurityGroup()) { if (securityGroupIdList == null) { securityGroupIdList = new ArrayList(); } @@ -3734,7 +3736,7 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager throw ex; } - _networkMgr.checkNetworkPermissions(newAccount, network); + _networkModel.checkNetworkPermissions(newAccount, network); //don't allow to use system networks NetworkOffering networkOffering = _configMgr.getNetworkOffering(network.getNetworkOfferingId()); @@ -3755,9 +3757,9 @@ public class UserVmManagerImpl implements UserVmManager, UserVmService, Manager } if (requiredOfferings.get(0).getState() == NetworkOffering.State.Enabled) { // get Virtual networks - List virtualNetworks = _networkMgr.listNetworksForAccount(newAccount.getId(), zone.getId(), Network.GuestType.Isolated); + List virtualNetworks = _networkModel.listNetworksForAccount(newAccount.getId(), zone.getId(), Network.GuestType.Isolated); if (virtualNetworks.isEmpty()) { - long physicalNetworkId = _networkMgr.findPhysicalNetworkId(zone.getId(), requiredOfferings.get(0).getTags(), requiredOfferings.get(0).getTrafficType()); + long physicalNetworkId = _networkModel.findPhysicalNetworkId(zone.getId(), requiredOfferings.get(0).getTags(), requiredOfferings.get(0).getTrafficType()); // Validate physical network PhysicalNetwork physicalNetwork = _physicalNetworkDao.findById(physicalNetworkId); if (physicalNetwork == null) { diff --git a/server/src/com/cloud/vm/VirtualMachineManagerImpl.java b/server/src/com/cloud/vm/VirtualMachineManagerImpl.java index c1a9b3a478c..626bbb4eab9 100755 --- a/server/src/com/cloud/vm/VirtualMachineManagerImpl.java +++ b/server/src/com/cloud/vm/VirtualMachineManagerImpl.java @@ -109,6 +109,7 @@ import com.cloud.hypervisor.HypervisorGuru; import com.cloud.hypervisor.HypervisorGuruManager; import com.cloud.network.Network; import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkModel; import com.cloud.network.NetworkVO; import com.cloud.network.dao.NetworkDao; import com.cloud.offering.ServiceOffering; @@ -170,6 +171,8 @@ public class VirtualMachineManagerImpl implements VirtualMachineManager, Listene @Inject protected NetworkManager _networkMgr; @Inject + protected NetworkModel _networkModel; + @Inject protected AgentManager _agentMgr; @Inject protected VMInstanceDao _vmDao; @@ -2153,9 +2156,9 @@ public class VirtualMachineManagerImpl implements VirtualMachineManager, Listene VirtualMachineProfile profile = new VirtualMachineProfileImpl(vm); List nics = _nicsDao.listByVmId(profile.getId()); for (NicVO nic : nics) { - Network network = _networkMgr.getNetwork(nic.getNetworkId()); + Network network = _networkModel.getNetwork(nic.getNetworkId()); NicProfile nicProfile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), null, - _networkMgr.isSecurityGroupSupportedInNetwork(network), _networkMgr.getNetworkTag(profile.getHypervisorType(), network)); + _networkModel.isSecurityGroupSupportedInNetwork(network), _networkModel.getNetworkTag(profile.getHypervisorType(), network)); profile.addNic(nicProfile); } @@ -2554,7 +2557,7 @@ public class VirtualMachineManagerImpl implements VirtualMachineManager, Listene if (broadcastUri != null) { nic = _nicsDao.findByNetworkIdInstanceIdAndBroadcastUri(network.getId(), vm.getId(), broadcastUri.toString()); } else { - nic = _networkMgr.getNicInNetwork(vm.getId(), network.getId()); + nic = _networkModel.getNicInNetwork(vm.getId(), network.getId()); } if (nic == null){ @@ -2569,9 +2572,9 @@ public class VirtualMachineManagerImpl implements VirtualMachineManager, Listene } NicProfile nicProfile = new NicProfile(nic, network, nic.getBroadcastUri(), nic.getIsolationUri(), - _networkMgr.getNetworkRate(network.getId(), vm.getId()), - _networkMgr.isSecurityGroupSupportedInNetwork(network), - _networkMgr.getNetworkTag(vmProfile.getVirtualMachine().getHypervisorType(), network)); + _networkModel.getNetworkRate(network.getId(), vm.getId()), + _networkModel.isSecurityGroupSupportedInNetwork(network), + _networkModel.getNetworkTag(vmProfile.getVirtualMachine().getHypervisorType(), network)); //1) Unplug the nic if (vm.getState() == State.Running) { diff --git a/server/test/com/cloud/alert/MockAlertManagerImpl.java b/server/test/com/cloud/alert/MockAlertManagerImpl.java new file mode 100644 index 00000000000..3f87193d2f1 --- /dev/null +++ b/server/test/com/cloud/alert/MockAlertManagerImpl.java @@ -0,0 +1,87 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.alert; + +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +@Local(value = {AlertManager.class}) +public class MockAlertManagerImpl implements AlertManager { + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#configure(java.lang.String, java.util.Map) + */ + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#start() + */ + @Override + public boolean start() { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#stop() + */ + @Override + public boolean stop() { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#getName() + */ + @Override + public String getName() { + return "MockAlertManagerImpl"; + } + + /* (non-Javadoc) + * @see com.cloud.alert.AlertManager#clearAlert(short, long, long) + */ + @Override + public void clearAlert(short alertType, long dataCenterId, long podId) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.alert.AlertManager#sendAlert(short, long, java.lang.Long, java.lang.String, java.lang.String) + */ + @Override + public void sendAlert(short alertType, long dataCenterId, Long podId, String subject, String body) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.alert.AlertManager#recalculateCapacity() + */ + @Override + public void recalculateCapacity() { + // TODO Auto-generated method stub + + } + +} diff --git a/server/test/com/cloud/api/APITest.java b/server/test/com/cloud/api/APITest.java index 69c488f5a10..0b040abc3f5 100644 --- a/server/test/com/cloud/api/APITest.java +++ b/server/test/com/cloud/api/APITest.java @@ -19,17 +19,17 @@ package com.cloud.api; import java.io.BufferedReader; import java.io.EOFException; import java.io.InputStreamReader; -import java.io.OutputStreamWriter; import java.math.BigInteger; import java.net.HttpURLConnection; import java.net.URL; -import java.net.URLConnection; import java.net.URLEncoder; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.HashMap; import java.util.Iterator; +import org.apache.cloudstack.api.response.SuccessResponse; + import com.cloud.utils.exception.CloudRuntimeException; import com.google.gson.Gson; @@ -147,17 +147,38 @@ public abstract class APITest { protected Object fromSerializedString(String result, Class repCls) { try { if (result != null && !result.isEmpty()) { - // get real content - int start = result.indexOf('{', result.indexOf('{') + 1); // find the second { - if ( start < 0 ){ + int start; + int end; + if (repCls == LoginResponse.class || repCls == SuccessResponse.class) { + + start = result.indexOf('{', result.indexOf('{') + 1); // find + // the + // second + // { + + end = result.lastIndexOf('}', result.lastIndexOf('}') - 1); // find + // the + // second + // } + // backwards + + } else { + // get real content + start = result.indexOf('{', result.indexOf('{', result.indexOf('{') + 1) + 1); // find + // the + // third + // { + end = result.lastIndexOf('}', result.lastIndexOf('}', result.lastIndexOf('}') - 1) - 1); // find + // the + // third + // } + // backwards + } + if (start < 0 || end < 0) { throw new CloudRuntimeException("Response format is wrong: " + result); } - int end = result.lastIndexOf('}', result.lastIndexOf('}')-1); // find the second } backwards - if ( end < 0 ){ - throw new CloudRuntimeException("Response format is wrong: " + result); - } - String content = result.substring(start, end+1); + String content = result.substring(start, end + 1); Gson gson = ApiGsonHelper.getBuilder().create(); return gson.fromJson(content, repCls); } diff --git a/server/test/com/cloud/api/ListPerfTest.java b/server/test/com/cloud/api/ListPerfTest.java index eb98d9187fe..b8cb97eb8f0 100644 --- a/server/test/com/cloud/api/ListPerfTest.java +++ b/server/test/com/cloud/api/ListPerfTest.java @@ -16,11 +16,18 @@ // under the License. package com.cloud.api; +import static org.junit.Assert.*; + import java.util.HashMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import org.junit.Before; import org.junit.Test; +import com.cloud.utils.exception.CloudRuntimeException; + /** * Test fixture to do performance test for list command @@ -163,6 +170,4 @@ public class ListPerfTest extends APITest { } - - } diff --git a/server/test/com/cloud/network/MockFirewallManagerImpl.java b/server/test/com/cloud/network/MockFirewallManagerImpl.java new file mode 100644 index 00000000000..1a79acf746b --- /dev/null +++ b/server/test/com/cloud/network/MockFirewallManagerImpl.java @@ -0,0 +1,202 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.network; + +import java.util.List; +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.api.command.user.firewall.ListFirewallRulesCmd; + +import com.cloud.exception.NetworkRuleConflictException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.firewall.FirewallService; +import com.cloud.network.rules.FirewallManager; +import com.cloud.network.rules.FirewallRule; +import com.cloud.network.rules.FirewallRuleVO; +import com.cloud.network.rules.FirewallRule.FirewallRuleType; +import com.cloud.network.rules.FirewallRule.Purpose; +import com.cloud.user.Account; +import com.cloud.utils.Pair; +import com.cloud.utils.component.Manager; + +@Local(value = {FirewallManager.class, FirewallService.class}) +public class MockFirewallManagerImpl implements FirewallManager, + FirewallService, Manager { + + @Override + public boolean configure(String name, Map params) + throws ConfigurationException { + return true; + } + + @Override + public boolean start() { + return true; + } + + @Override + public boolean stop() { + // TODO Auto-generated method stub + return false; + } + + @Override + public String getName() { + // TODO Auto-generated method stub + return null; + } + + @Override + public FirewallRule createFirewallRule(FirewallRule rule) + throws NetworkRuleConflictException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Pair, Integer> listFirewallRules( + ListFirewallRulesCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean revokeFirewallRule(long ruleId, boolean apply) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyFirewallRules(long ipId, Account caller) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public FirewallRule getFirewallRule(long ruleId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean revokeRelatedFirewallRule(long ruleId, boolean apply) { + // TODO Auto-generated method stub + return false; + } + + @Override + public void detectRulesConflict(FirewallRule newRule) + throws NetworkRuleConflictException { + // TODO Auto-generated method stub + + } + + @Override + public void validateFirewallRule(Account caller, IPAddressVO ipAddress, + Integer portStart, Integer portEnd, String proto, Purpose purpose, + FirewallRuleType type) { + // TODO Auto-generated method stub + + } + + @Override + public boolean applyRules(List rules, + boolean continueOnError, boolean updateRulesInDB) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyFirewallRules(List rules, + boolean continueOnError, Account caller) { + // TODO Auto-generated method stub + return false; + } + + @Override + public void revokeRule(FirewallRuleVO rule, Account caller, long userId, + boolean needUsageEvent) { + // TODO Auto-generated method stub + + } + + @Override + public boolean revokeFirewallRulesForIp(long ipId, long userId, + Account caller) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean revokeFirewallRule(long ruleId, boolean apply, + Account caller, long userId) { + // TODO Auto-generated method stub + return false; + } + + @Override + public FirewallRule createFirewallRule(long ipAddrId, Account caller, + String xId, Integer portStart, Integer portEnd, String protocol, + List sourceCidrList, Integer icmpCode, Integer icmpType, + Long relatedRuleId, FirewallRuleType type, long networkId) + throws NetworkRuleConflictException { + // TODO Auto-generated method stub + return null; + } + + @Override + public FirewallRule createRuleForAllCidrs(long ipAddrId, Account caller, + Integer startPort, Integer endPort, String protocol, + Integer icmpCode, Integer icmpType, Long relatedRuleId, + long networkId) throws NetworkRuleConflictException { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean revokeAllFirewallRulesForNetwork(long networkId, + long userId, Account caller) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean revokeFirewallRulesForVm(long vmId) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean addSystemFirewallRules(IPAddressVO ip, Account acct) { + // TODO Auto-generated method stub + return false; + } + + @Override + public void removeRule(FirewallRule rule) { + // TODO Auto-generated method stub + + } + + + +} diff --git a/server/test/com/cloud/network/MockNetworkManagerImpl.java b/server/test/com/cloud/network/MockNetworkManagerImpl.java index 28d1a604c44..ef5b9c9f9b7 100755 --- a/server/test/com/cloud/network/MockNetworkManagerImpl.java +++ b/server/test/com/cloud/network/MockNetworkManagerImpl.java @@ -16,29 +16,35 @@ // under the License. package com.cloud.network; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + import org.apache.cloudstack.acl.ControlledEntity.ACLType; import org.apache.cloudstack.api.command.admin.usage.ListTrafficTypeImplementorsCmd; import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd; import org.apache.cloudstack.api.command.user.network.ListNetworksCmd; import org.apache.cloudstack.api.command.user.network.RestartNetworkCmd; + import com.cloud.dc.DataCenter; -import com.cloud.dc.Vlan; import com.cloud.dc.Vlan.VlanType; import com.cloud.deploy.DataCenterDeployment; import com.cloud.deploy.DeployDestination; import com.cloud.deploy.DeploymentPlan; -import com.cloud.exception.*; -import com.cloud.hypervisor.Hypervisor.HypervisorType; -import com.cloud.network.Network.Capability; -import com.cloud.network.Network.GuestType; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.InsufficientVirtualNetworkCapcityException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; import com.cloud.network.Networks.TrafficType; import com.cloud.network.addr.PublicIp; import com.cloud.network.element.LoadBalancingServiceProvider; -import com.cloud.network.element.NetworkElement; -import com.cloud.network.element.RemoteAccessVPNServiceProvider; -import com.cloud.network.element.Site2SiteVpnServiceProvider; import com.cloud.network.element.StaticNatServiceProvider; import com.cloud.network.element.UserDataServiceProvider; import com.cloud.network.guru.NetworkGuru; @@ -52,14 +58,13 @@ import com.cloud.user.Account; import com.cloud.user.User; import com.cloud.utils.Pair; import com.cloud.utils.component.Manager; -import com.cloud.vm.*; - -import javax.ejb.Local; -import javax.naming.ConfigurationException; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Set; +import com.cloud.vm.Nic; +import com.cloud.vm.NicProfile; +import com.cloud.vm.ReservationContext; +import com.cloud.vm.VMInstanceVO; +import com.cloud.vm.VirtualMachine; +import com.cloud.vm.VirtualMachineProfile; +import com.cloud.vm.VirtualMachineProfileImpl; @Local(value = { NetworkManager.class, NetworkService.class }) public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkService { @@ -130,35 +135,6 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public Map> getNetworkCapabilities(long networkId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean isNetworkAvailableInDomain(long networkId, long domainId) { - // TODO Auto-generated method stub - return false; - } - - @Override - public Long getDedicatedNetworkDomain(long networkId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Integer getNetworkRate(long networkId, Long vmId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Network getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - // TODO Auto-generated method stub - return null; - } @Override public boolean configure(String name, Map params) throws ConfigurationException { @@ -189,31 +165,23 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return false; } - @Override - public List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat) { - // TODO Auto-generated method stub - return null; - } + @Override - public List setupNetwork(Account owner, NetworkOfferingVO offering, DeploymentPlan plan, String name, String displayText, boolean isDefault) + public List setupNetwork(Account owner, NetworkOffering offering, DeploymentPlan plan, String name, String displayText, boolean isDefault) throws ConcurrentOperationException { // TODO Auto-generated method stub return null; } @Override - public List setupNetwork(Account owner, NetworkOfferingVO offering, Network predefined, DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, + public List setupNetwork(Account owner, NetworkOffering offering, Network predefined, DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, ACLType aclType, Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException { // TODO Auto-generated method stub return null; } - @Override - public List getSystemAccountNetworkOfferings(String... offeringNames) { - // TODO Auto-generated method stub - return null; - } + @Override public void allocate(VirtualMachineProfile vm, List> networks) throws InsufficientCapacityException, ConcurrentOperationException { @@ -246,42 +214,17 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS } - @Override - public List getNics(long vmId) { - // TODO Auto-generated method stub - return null; - } - + @Override public List getNicProfiles(VirtualMachine vm) { // TODO Auto-generated method stub return null; } - @Override - public String getNextAvailableMacAddressInNetwork(long networkConfigurationId) throws InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean applyRules(List rules, boolean continueOnError) throws ResourceUnavailableException { - // TODO Auto-generated method stub - return false; - } - - @Override - public PublicIpAddress getPublicIpAddress(long ipAddressId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public List listPodVlans(long podId) { - // TODO Auto-generated method stub - return null; - } + + + @Override public Pair implementNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { @@ -289,11 +232,6 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public List listNetworksUsedByVm(long vmId, boolean isSystem) { - // TODO Auto-generated method stub - return null; - } @Override public void prepareNicForMigration(VirtualMachineProfile vm, DeployDestination dest) { @@ -321,29 +259,9 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return false; } - @Override - public Nic getNicInNetwork(long vmId, long networkId) { - // TODO Auto-generated method stub - return null; - } + - @Override - public List getNicsForTraffic(long vmId, TrafficType type) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Network getDefaultNetworkForVm(long vmId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Nic getDefaultNic(long vmId) { - // TODO Auto-generated method stub - return null; - } + @Override public boolean applyIpAssociations(Network network, boolean continueOnError) throws ResourceUnavailableException { @@ -351,17 +269,7 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return false; } - @Override - public boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) { - // TODO Auto-generated method stub - return false; - } - - @Override - public NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId) { - // TODO Auto-generated method stub - return null; - } + @Override public boolean startNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { @@ -369,12 +277,7 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return false; } - @Override - public String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId) { - // TODO Auto-generated method stub - return null; - } - + @Override public IPAddressVO markIpAsUnavailable(long addrId) { // TODO Auto-generated method stub @@ -387,50 +290,22 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public String getGlobalGuestDomainSuffix() { - // TODO Auto-generated method stub - return null; - } - - @Override - public String getStartIpAddress(long networkId) { - // TODO Auto-generated method stub - return null; - } - + @Override public boolean applyStaticNats(List staticNats, boolean continueOnError) throws ResourceUnavailableException { // TODO Auto-generated method stub return false; } - @Override - public String getIpInNetwork(long vmId, long networkId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public String getIpInNetworkIncludingRemoved(long vmId, long networkId) { - // TODO Auto-generated method stub - return null; - } + public Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId) { return null; } - @Override - public List getRemoteAccessVpnElements() { - return null; - } + - @Override - public boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider) { - // TODO Auto-generated method stub - return false; - } + @Override public PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, List isolationMethods, String broadcastDomainRange, Long domainId, List tags, String name) { @@ -462,11 +337,6 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public List listSupportedNetworkServiceProviders(String serviceName) { - // TODO Auto-generated method stub - return null; - } @Override public PhysicalNetworkServiceProvider addProviderToPhysicalNetwork(Long physicalNetworkId, String providerName, Long destinationPhysicalNetworkId, List enabledServices) { @@ -540,72 +410,16 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - // TODO Auto-generated method stub - return null; - } - + @Override public Network getExclusiveGuestNetwork(long zoneId) { // TODO Auto-generated method stub return null; } - @Override - public Long getPodIdForVlan(long vlanDbId) { - // TODO Auto-generated method stub - return null; - } + - @Override - public boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId) { - // TODO Auto-generated method stub - return false; - } - - @Override - public Map getNetworkServiceCapabilities(long networkId, Service service) { - // TODO Auto-generated method stub - return null; - } - - @Override - public List listNetworksForAccount(long accountId, long zoneId, GuestType type) { - // TODO Auto-generated method stub - return null; - } - - @Override - public List listNetworkOfferingsForUpgrade(long networkId) { - // TODO Auto-generated method stub - return null; - } - - - @Override - public boolean isSecurityGroupSupportedInNetwork(Network network) { - // TODO Auto-generated method stub - return false; - } - - @Override - public boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName) { - // TODO Auto-generated method stub - return false; - } - - @Override - public List getElementServices(Provider provider) { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean canElementEnableIndividualServices(Provider provider) { - // TODO Auto-generated method stub - return false; - } + @Override public UserDataServiceProvider getPasswordResetProvider(Network network) { @@ -613,12 +427,7 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public UserDataServiceProvider getUserDataUpdateProvider(Network network) { - // TODO Auto-generated method stub - return null; - } - + @Override public PhysicalNetworkServiceProvider updateNetworkServiceProvider(Long id, String state, List enabledServices) { // TODO Auto-generated method stub @@ -631,183 +440,139 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return null; } - @Override - public boolean areServicesSupportedInNetwork(long networkId, Service... services) { - // TODO Auto-generated method stub - return false; - } - - @Override - public boolean isNetworkSystem(Network network) { - // TODO Auto-generated method stub - return false; - } - - @Override - public Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean reallocate(VirtualMachineProfile vm, DataCenterDeployment dest) throws InsufficientCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - return false; - } - - @Override - public Long getPhysicalNetworkId(Network network) { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean getAllowSubdomainAccessGlobal() { - // TODO Auto-generated method stub - return false; - } - - @Override - public boolean isProviderForNetwork(Provider provider, long networkId) { - // TODO Auto-generated method stub - return false; - } - - @Override - public boolean restartNetwork(RestartNetworkCmd cmd, boolean cleanup) - throws ConcurrentOperationException, ResourceUnavailableException, - InsufficientCapacityException { - // TODO Auto-generated method stub - return false; - } - - @Override - public String getNetworkTag(HypervisorType hType, Network network) { - // TODO Auto-generated method stub - return null; - } - - @Override - public void canProviderSupportServices( - Map> providersMap) { - // TODO Auto-generated method stub - - } - - @Override - public boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId) { - // TODO Auto-generated method stub - return false; - } - - - @Override - public boolean canAddDefaultSecurityGroup() { - // TODO Auto-generated method stub - return false; - } - - @Override - public List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd) { - // TODO Auto-generated method stub - return null; - } - - @Override - public List listNetworkOfferingServices(long networkOfferingId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services) { - // TODO Auto-generated method stub - return false; - } - - @Override - public Map> getIpToServices(List publicIps, boolean rulesRevoked, boolean includingFirewall) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Map> getProviderToIpList(Network network, Map> ipToServices) { - // TODO Auto-generated method stub - return null; - } - - @Override - public boolean checkIpForService(IPAddressVO ip, Service service, Long networkId) { - // TODO Auto-generated method stub - return false; - } - - + /* (non-Javadoc) - * @see com.cloud.network.NetworkService#isVmPartOfNetwork(long, long) + * @see com.cloud.network.NetworkManager#applyRules(java.util.List, com.cloud.network.rules.FirewallRule.Purpose, com.cloud.network.NetworkRuleApplier, boolean) */ @Override - public boolean isVmPartOfNetwork(long vmId, long ntwkId) { + public boolean applyRules(List rules, Purpose purpose, NetworkRuleApplier applier, + boolean continueOnError) throws ResourceUnavailableException { // TODO Auto-generated method stub return false; } - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultNetworkDomain() + * @see com.cloud.network.NetworkManager#applyIpAssociations(com.cloud.network.Network, boolean, boolean, java.util.List) */ @Override - public String getDefaultNetworkDomain() { + public boolean applyIpAssociations(Network network, boolean rulesRevoked, boolean continueOnError, + List publicIps) throws ResourceUnavailableException { // TODO Auto-generated method stub - return null; + return false; } - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#allocateNic(com.cloud.vm.NicProfile, com.cloud.network.Network, java.lang.Boolean, int, com.cloud.vm.VirtualMachineProfile) + * @see com.cloud.network.NetworkManager#cleanupIpResources(long, long, com.cloud.user.Account) */ @Override - public Pair allocateNic(NicProfile requested, Network network, Boolean isDefaultNic, int deviceId, VirtualMachineProfile vm) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException { + public boolean cleanupIpResources(long addrId, long userId, Account caller) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#restartNetwork(java.lang.Long, com.cloud.user.Account, com.cloud.user.User, boolean) + */ + @Override + public boolean restartNetwork(Long networkId, Account callerAccount, User callerUser, boolean cleanup) + throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#shutdownNetworkElementsAndResources(com.cloud.vm.ReservationContext, boolean, com.cloud.network.NetworkVO) + */ + @Override + public boolean shutdownNetworkElementsAndResources(ReservationContext context, boolean b, NetworkVO network) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#implementNetworkElementsAndResources(com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext, com.cloud.network.NetworkVO, com.cloud.offerings.NetworkOfferingVO) + */ + @Override + public void implementNetworkElementsAndResources(DeployDestination dest, ReservationContext context, + NetworkVO network, NetworkOfferingVO findById) throws ConcurrentOperationException, + InsufficientAddressCapacityException, ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocateIp(com.cloud.user.Account, boolean, com.cloud.user.Account, com.cloud.dc.DataCenter) + */ + @Override + public IpAddress allocateIp(Account ipOwner, boolean isSystem, Account caller, long callerId, DataCenter zone) + throws ConcurrentOperationException, ResourceAllocationException, InsufficientAddressCapacityException { // TODO Auto-generated method stub return null; } /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#prepareNic(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext, long, com.cloud.network.NetworkVO) + * @see com.cloud.network.NetworkManager#finalizeServicesAndProvidersForNetwork(com.cloud.offering.NetworkOffering, java.lang.Long) */ @Override - public NicProfile prepareNic(VirtualMachineProfile vmProfile, DeployDestination dest, ReservationContext context, long nicId, NetworkVO network) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { + public Map finalizeServicesAndProvidersForNetwork(NetworkOffering offering, Long physicalNetworkId) { // TODO Auto-generated method stub return null; } /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listPublicIpsAssignedToAccount(long, long, java.lang.Boolean) + * @see com.cloud.network.NetworkManager#getNicProfileForVm(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachine) */ - @Override - public List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat) { - // TODO Auto-generated method stub + protected NicProfile getNicProfileForVm(Network network, NicProfile requested, VirtualMachine vm) { return null; } /* (non-Javadoc) - * @see com.cloud.network.NetworkService#allocateIP(com.cloud.user.Account, long, Long) + * @see com.cloud.network.NetworkManager#getOnePhysicalNetworkByZoneAndTrafficType(long, com.cloud.network.Networks.TrafficType) + */ + protected PhysicalNetwork getOnePhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#getZoneNetworkDomain(long) + */ + protected String getZoneNetworkDomain(long zoneId) { + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#getNicInNetworkIncludingRemoved(long, long) + */ + protected Nic getNicInNetworkIncludingRemoved(long vmId, long networkId) { + return null; + } + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#restartNetwork(com.cloud.api.commands.RestartNetworkCmd, boolean) */ @Override - public IpAddress allocateIP(Account ipOwner, boolean isSystem, long zoneId) throws ResourceAllocationException, InsufficientAddressCapacityException, ConcurrentOperationException { + public boolean restartNetwork(RestartNetworkCmd cmd, boolean cleanup) throws ConcurrentOperationException, + ResourceUnavailableException, InsufficientCapacityException { // TODO Auto-generated method stub - return null; + return false; } /* (non-Javadoc) * @see com.cloud.network.NetworkService#updateGuestNetwork(long, java.lang.String, java.lang.String, com.cloud.user.Account, com.cloud.user.User, java.lang.String, java.lang.Long, java.lang.Boolean) */ @Override - public Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, String vlan, String startIp, String endIP, String gateway, String netmask, long networkOwnerId, Long vpcId) - throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { + public Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, + User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#listTrafficTypeImplementor(com.cloud.api.commands.ListTrafficTypeImplementorsCmd) + */ + @Override + public List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd) { // TODO Auto-generated method stub return null; } @@ -816,27 +581,40 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS * @see com.cloud.network.NetworkService#getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long, com.cloud.user.Account) */ @Override - public IpAddress associateIPToNetwork(long ipId, long networkId) throws InsufficientAddressCapacityException, ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException { + public List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { // TODO Auto-generated method stub return null; } /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listNetworksByVpc(long) + * @see com.cloud.network.NetworkService#associateIPToNetwork(long, long) */ @Override - public List listNetworksByVpc(long vpcId) { + public IpAddress associateIPToNetwork(long ipId, long networkId) throws InsufficientAddressCapacityException, + ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException { // TODO Auto-generated method stub return null; } /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#validateRule(com.cloud.network.rules.FirewallRule) + * @see com.cloud.network.NetworkService#createPrivateNetwork(java.lang.String, java.lang.String, long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, long, java.lang.Long) */ @Override - public boolean validateRule(FirewallRule rule) { + public Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, String vlan, + String startIp, String endIP, String gateway, String netmask, long networkOwnerId, Long vpcId) + throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { // TODO Auto-generated method stub - return false; + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignPublicIpAddress(long, java.lang.Long, com.cloud.user.Account, com.cloud.dc.Vlan.VlanType, java.lang.Long, java.lang.String, boolean) + */ + @Override + public PublicIp assignPublicIpAddress(long dcId, Long podId, Account owner, VlanType type, Long networkId, + String requestedIp, boolean isSystem) throws InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return null; } /* (non-Javadoc) @@ -849,205 +627,25 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS } /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listAllNetworksInAllZonesByType(com.cloud.network.Network.GuestType) + * @see com.cloud.network.NetworkManager#reallocate(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DataCenterDeployment) */ @Override - public List listAllNetworksInAllZonesByType(GuestType type) { + public boolean reallocate(VirtualMachineProfile vm, DataCenterDeployment dest) + throws InsufficientCapacityException, ConcurrentOperationException { // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPhysicalNetworkInfo(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public List getPhysicalNetworkInfo(long dcId, HypervisorType hypervisorType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#checkCapabilityForProvider(java.util.Set, com.cloud.network.Network.Service, com.cloud.network.Network.Capability, java.lang.String) - */ - @Override - public void checkCapabilityForProvider(Set providers, Service service, Capability cap, String capValue) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultUniqueProviderForService(java.lang.String) - */ - @Override - public List getNtwkOffDistinctProviders(long ntwkOffId) { - // TODO Auto-generated method stub - return null; + return false; } /* (non-Javadoc) * @see com.cloud.network.NetworkManager#assignSystemIp(long, com.cloud.user.Account, boolean, boolean) */ @Override - public IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) throws InsufficientAddressCapacityException { + public IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) + throws InsufficientAddressCapacityException { // TODO Auto-generated method stub return null; } - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#checkNetworkPermissions(com.cloud.user.Account, com.cloud.network.Network) - */ - @Override - public void checkNetworkPermissions(Account owner, Network network) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#allocateDirectIp(com.cloud.vm.NicProfile, com.cloud.dc.DataCenter, com.cloud.vm.VirtualMachineProfile, com.cloud.network.Network, java.lang.String) - */ - @Override - public void releaseNic(VirtualMachineProfile vmProfile, Nic nic) throws ConcurrentOperationException, ResourceUnavailableException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getElementImplementingProvider(java.lang.String) - */ - @Override - public NetworkElement getElementImplementingProvider(String providerName) { - // TODO Auto-generated method stub - return null; - } - - - @Override - public boolean canUseForDeploy(Network network) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultStorageTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultPublicTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultPublicTrafficLabel(long dcId, HypervisorType vmware) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignSourceNatIpAddressToGuestNetwork(com.cloud.user.Account, com.cloud.network.Network) - */ - @Override - public PublicIp assignSourceNatIpAddressToGuestNetwork(Account owner, Network guestNetwork) throws InsufficientAddressCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#setupDns(com.cloud.network.Network, com.cloud.network.Network.Provider) - */ - @Override - public boolean setupDns(Network network, Provider provider) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPhysicalNtwksSupportingTrafficType(long, com.cloud.network.Networks.TrafficType) - */ - @Override - public List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignPublicIpAddress(long, java.lang.Long, com.cloud.user.Account, com.cloud.dc.Vlan.VlanType, java.lang.Long, java.lang.String, boolean) - */ - @Override - public PublicIp assignPublicIpAddress(long dcId, Long podId, Account owner, VlanType type, Long networkId, String requestedIp, boolean isSystem) throws InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getAccountNetworkDomain(long, long) - */ - @Override - public String getAccountNetworkDomain(long accountId, long zoneId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#updateGuestNetwork(long, java.lang.String, java.lang.String, com.cloud.user.Account, com.cloud.user.User, java.lang.String, java.lang.Long, java.lang.Boolean) - */ - @Override - public Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getSite2SiteVpnElements() - */ - @Override - public List getSite2SiteVpnElements() { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isPrivateGateway(com.cloud.vm.Nic) - */ - @Override - public boolean isPrivateGateway(Nic guestNic) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#allocateDirectIp(com.cloud.vm.NicProfile, com.cloud.dc.DataCenter, com.cloud.vm.VirtualMachineProfile, com.cloud.network.Network, java.lang.String) - */ - @Override - public void allocateDirectIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, Network network, String requestedIp) throws InsufficientVirtualNetworkCapcityException, - InsufficientAddressCapacityException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#createNicForVm(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.ReservationContext, com.cloud.vm.VirtualMachineProfileImpl, boolean) - */ - @Override - public NicProfile createNicForVm(Network network, NicProfile requested, ReservationContext context, VirtualMachineProfileImpl vmProfile, boolean prepare) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultManagementTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) * @see com.cloud.network.NetworkManager#handleSystemIpRelease(com.cloud.network.IpAddress) */ @@ -1057,6 +655,51 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS return false; } + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocateDirectIp(com.cloud.vm.NicProfile, com.cloud.dc.DataCenter, com.cloud.vm.VirtualMachineProfile, com.cloud.network.Network, java.lang.String) + */ + @Override + public void allocateDirectIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, + Network network, String requestedIp) throws InsufficientVirtualNetworkCapcityException, + InsufficientAddressCapacityException { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignSourceNatIpAddressToGuestNetwork(com.cloud.user.Account, com.cloud.network.Network) + */ + @Override + public PublicIp assignSourceNatIpAddressToGuestNetwork(Account owner, Network guestNetwork) + throws InsufficientAddressCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocateNic(com.cloud.vm.NicProfile, com.cloud.network.Network, java.lang.Boolean, int, com.cloud.vm.VirtualMachineProfile) + */ + @Override + public Pair allocateNic(NicProfile requested, Network network, Boolean isDefaultNic, + int deviceId, VirtualMachineProfile vm) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#prepareNic(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext, long, com.cloud.network.NetworkVO) + */ + @Override + public NicProfile prepareNic(VirtualMachineProfile vmProfile, DeployDestination dest, + ReservationContext context, long nicId, NetworkVO network) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + /* (non-Javadoc) * @see com.cloud.network.NetworkManager#removeNic(com.cloud.vm.VirtualMachineProfile, com.cloud.vm.Nic) */ @@ -1067,19 +710,32 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS } /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultGuestTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) + * @see com.cloud.network.NetworkManager#setupDns(com.cloud.network.Network, com.cloud.network.Network.Provider) */ @Override - public String getDefaultGuestTrafficLabel(long dcId, HypervisorType vmware) { + public boolean setupDns(Network network, Provider provider) { // TODO Auto-generated method stub - return null; + return false; } /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNicProfile(com.cloud.vm.VirtualMachine, long, java.lang.String) + * @see com.cloud.network.NetworkManager#releaseNic(com.cloud.vm.VirtualMachineProfile, com.cloud.vm.Nic) */ @Override - public NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri) { + public void releaseNic(VirtualMachineProfile vmProfile, Nic nic) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#createNicForVm(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.ReservationContext, com.cloud.vm.VirtualMachineProfileImpl, boolean) + */ + @Override + public NicProfile createNicForVm(Network network, NicProfile requested, ReservationContext context, + VirtualMachineProfileImpl vmProfile, boolean prepare) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { // TODO Auto-generated method stub return null; } @@ -1088,7 +744,8 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS * @see com.cloud.network.NetworkManager#assignVpnGatewayIpAddress(long, com.cloud.user.Account, long) */ @Override - public PublicIp assignVpnGatewayIpAddress(long dcId, Account owner, long vpcId) throws InsufficientAddressCapacityException, ConcurrentOperationException { + public PublicIp assignVpnGatewayIpAddress(long dcId, Account owner, long vpcId) + throws InsufficientAddressCapacityException, ConcurrentOperationException { // TODO Auto-generated method stub return null; } @@ -1106,25 +763,8 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS * @see com.cloud.network.NetworkManager#assignDedicateIpAddress(com.cloud.user.Account, java.lang.Long, java.lang.Long, long, boolean) */ @Override - public PublicIp assignDedicateIpAddress(Account owner, Long guestNtwkId, Long vpcId, long dcId, boolean isSourceNat) throws ConcurrentOperationException, InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long, com.cloud.user.Account) - */ - @Override - public List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultUniqueProviderForService(java.lang.String) - */ - @Override - public Provider getDefaultUniqueProviderForService(String serviceName) { + public PublicIp assignDedicateIpAddress(Account owner, Long guestNtwkId, Long vpcId, long dcId, boolean isSourceNat) + throws ConcurrentOperationException, InsufficientAddressCapacityException { // TODO Auto-generated method stub return null; } @@ -1168,4 +808,14 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager, NetworkS // TODO Auto-generated method stub return null; } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#allocateIP(com.cloud.user.Account, boolean, long) + */ + @Override + public IpAddress allocateIP(Account ipOwner, boolean isSystem, long zoneId) throws ResourceAllocationException, + InsufficientAddressCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } } diff --git a/server/test/com/cloud/network/MockNetworkModelImpl.java b/server/test/com/cloud/network/MockNetworkModelImpl.java new file mode 100644 index 00000000000..1771660f86c --- /dev/null +++ b/server/test/com/cloud/network/MockNetworkModelImpl.java @@ -0,0 +1,809 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import com.cloud.dc.Vlan; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.hypervisor.Hypervisor.HypervisorType; +import com.cloud.network.Network.Capability; +import com.cloud.network.Network.GuestType; +import com.cloud.network.Network.Provider; +import com.cloud.network.Network.Service; +import com.cloud.network.Networks.TrafficType; +import com.cloud.network.addr.PublicIp; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.UserDataServiceProvider; +import com.cloud.network.rules.FirewallRule; +import com.cloud.offering.NetworkOffering; +import com.cloud.offerings.NetworkOfferingVO; +import com.cloud.user.Account; +import com.cloud.utils.component.Manager; +import com.cloud.vm.Nic; +import com.cloud.vm.NicProfile; +import com.cloud.vm.VirtualMachine; + +@Local(value = {NetworkModel.class}) +public class MockNetworkModelImpl implements NetworkModel, Manager { + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#configure(java.lang.String, java.util.Map) + */ + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#start() + */ + @Override + public boolean start() { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#stop() + */ + @Override + public boolean stop() { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#getName() + */ + @Override + public String getName() { + return "MockNetworkModelImpl"; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listPublicIpsAssignedToGuestNtwk(long, long, java.lang.Boolean) + */ + @Override + public List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, + Boolean sourceNat) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getSystemAccountNetworkOfferings(java.lang.String[]) + */ + @Override + public List getSystemAccountNetworkOfferings(String... offeringNames) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNics(long) + */ + @Override + public List getNics(long vmId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNextAvailableMacAddressInNetwork(long) + */ + @Override + public String getNextAvailableMacAddressInNetwork(long networkConfigurationId) + throws InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getPublicIpAddress(long) + */ + @Override + public PublicIpAddress getPublicIpAddress(long ipAddressId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listPodVlans(long) + */ + @Override + public List listPodVlans(long podId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listNetworksUsedByVm(long, boolean) + */ + @Override + public List listNetworksUsedByVm(long vmId, boolean isSystem) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNicInNetwork(long, long) + */ + @Override + public Nic getNicInNetwork(long vmId, long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNicsForTraffic(long, com.cloud.network.Networks.TrafficType) + */ + @Override + public List getNicsForTraffic(long vmId, TrafficType type) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultNetworkForVm(long) + */ + @Override + public Network getDefaultNetworkForVm(long vmId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultNic(long) + */ + @Override + public Nic getDefaultNic(long vmId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getUserDataUpdateProvider(com.cloud.network.Network) + */ + @Override + public UserDataServiceProvider getUserDataUpdateProvider(Network network) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#networkIsConfiguredForExternalNetworking(long, long) + */ + @Override + public boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkServiceCapabilities(long, com.cloud.network.Network.Service) + */ + @Override + public Map getNetworkServiceCapabilities(long networkId, Service service) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#areServicesSupportedByNetworkOffering(long, com.cloud.network.Network.Service[]) + */ + @Override + public boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkWithSecurityGroupEnabled(java.lang.Long) + */ + @Override + public NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getIpOfNetworkElementInVirtualNetwork(long, long) + */ + @Override + public String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listNetworksForAccount(long, long, com.cloud.network.Network.GuestType) + */ + @Override + public List listNetworksForAccount(long accountId, long zoneId, GuestType type) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listAllNetworksInAllZonesByType(com.cloud.network.Network.GuestType) + */ + @Override + public List listAllNetworksInAllZonesByType(GuestType type) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getGlobalGuestDomainSuffix() + */ + @Override + public String getGlobalGuestDomainSuffix() { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getStartIpAddress(long) + */ + @Override + public String getStartIpAddress(long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getIpInNetwork(long, long) + */ + @Override + public String getIpInNetwork(long vmId, long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getIpInNetworkIncludingRemoved(long, long) + */ + @Override + public String getIpInNetworkIncludingRemoved(long vmId, long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getPodIdForVlan(long) + */ + @Override + public Long getPodIdForVlan(long vlanDbId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listNetworkOfferingsForUpgrade(long) + */ + @Override + public List listNetworkOfferingsForUpgrade(long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isSecurityGroupSupportedInNetwork(com.cloud.network.Network) + */ + @Override + public boolean isSecurityGroupSupportedInNetwork(Network network) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isProviderSupportServiceInNetwork(long, com.cloud.network.Network.Service, com.cloud.network.Network.Provider) + */ + @Override + public boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isProviderEnabledInPhysicalNetwork(long, java.lang.String) + */ + @Override + public boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkTag(com.cloud.hypervisor.Hypervisor.HypervisorType, com.cloud.network.Network) + */ + @Override + public String getNetworkTag(HypervisorType hType, Network network) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getElementServices(com.cloud.network.Network.Provider) + */ + @Override + public List getElementServices(Provider provider) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#canElementEnableIndividualServices(com.cloud.network.Network.Provider) + */ + @Override + public boolean canElementEnableIndividualServices(Provider provider) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#areServicesSupportedInNetwork(long, com.cloud.network.Network.Service[]) + */ + @Override + public boolean areServicesSupportedInNetwork(long networkId, Service... services) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isNetworkSystem(com.cloud.network.Network) + */ + @Override + public boolean isNetworkSystem(Network network) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkOfferingServiceCapabilities(com.cloud.offering.NetworkOffering, com.cloud.network.Network.Service) + */ + @Override + public Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getPhysicalNetworkId(com.cloud.network.Network) + */ + @Override + public Long getPhysicalNetworkId(Network network) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getAllowSubdomainAccessGlobal() + */ + @Override + public boolean getAllowSubdomainAccessGlobal() { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isProviderForNetwork(com.cloud.network.Network.Provider, long) + */ + @Override + public boolean isProviderForNetwork(Provider provider, long networkId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isProviderForNetworkOffering(com.cloud.network.Network.Provider, long) + */ + @Override + public boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#canProviderSupportServices(java.util.Map) + */ + @Override + public void canProviderSupportServices(Map> providersMap) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getPhysicalNetworkInfo(long, com.cloud.hypervisor.Hypervisor.HypervisorType) + */ + @Override + public List getPhysicalNetworkInfo(long dcId, HypervisorType hypervisorType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#canAddDefaultSecurityGroup() + */ + @Override + public boolean canAddDefaultSecurityGroup() { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listNetworkOfferingServices(long) + */ + @Override + public List listNetworkOfferingServices(long networkOfferingId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#areServicesEnabledInZone(long, com.cloud.offering.NetworkOffering, java.util.List) + */ + @Override + public boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#checkIpForService(com.cloud.network.IPAddressVO, com.cloud.network.Network.Service, java.lang.Long) + */ + @Override + public boolean checkIpForService(IpAddress ip, Service service, Long networkId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#checkCapabilityForProvider(java.util.Set, com.cloud.network.Network.Service, com.cloud.network.Network.Capability, java.lang.String) + */ + @Override + public void checkCapabilityForProvider(Set providers, Service service, Capability cap, String capValue) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultUniqueProviderForService(java.lang.String) + */ + @Override + public Provider getDefaultUniqueProviderForService(String serviceName) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#checkNetworkPermissions(com.cloud.user.Account, com.cloud.network.Network) + */ + @Override + public void checkNetworkPermissions(Account owner, Network network) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultManagementTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) + */ + @Override + public String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultStorageTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) + */ + @Override + public String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultPublicTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) + */ + @Override + public String getDefaultPublicTrafficLabel(long dcId, HypervisorType vmware) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultGuestTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) + */ + @Override + public String getDefaultGuestTrafficLabel(long dcId, HypervisorType vmware) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getElementImplementingProvider(java.lang.String) + */ + @Override + public NetworkElement getElementImplementingProvider(String providerName) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getAccountNetworkDomain(long, long) + */ + @Override + public String getAccountNetworkDomain(long accountId, long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultNetworkDomain() + */ + @Override + public String getDefaultNetworkDomain() { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNtwkOffDistinctProviders(long) + */ + @Override + public List getNtwkOffDistinctProviders(long ntwkOffId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listPublicIpsAssignedToAccount(long, long, java.lang.Boolean) + */ + @Override + public List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getPhysicalNtwksSupportingTrafficType(long, com.cloud.network.Networks.TrafficType) + */ + @Override + public List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isPrivateGateway(com.cloud.vm.Nic) + */ + @Override + public boolean isPrivateGateway(Nic guestNic) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkCapabilities(long) + */ + @Override + public Map> getNetworkCapabilities(long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getSystemNetworkByZoneAndTrafficType(long, com.cloud.network.Networks.TrafficType) + */ + @Override + public Network getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDedicatedNetworkDomain(long) + */ + @Override + public Long getDedicatedNetworkDomain(long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkOfferingServiceProvidersMap(long) + */ + @Override + public Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listSupportedNetworkServiceProviders(java.lang.String) + */ + @Override + public List listSupportedNetworkServiceProviders(String serviceName) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#listNetworksByVpc(long) + */ + @Override + public List listNetworksByVpc(long vpcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#canUseForDeploy(com.cloud.network.Network) + */ + @Override + public boolean canUseForDeploy(Network network) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getExclusiveGuestNetwork(long) + */ + @Override + public Network getExclusiveGuestNetwork(long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#findPhysicalNetworkId(long, java.lang.String, com.cloud.network.Networks.TrafficType) + */ + @Override + public long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType) { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetworkRate(long, java.lang.Long) + */ + @Override + public Integer getNetworkRate(long networkId, Long vmId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isVmPartOfNetwork(long, long) + */ + @Override + public boolean isVmPartOfNetwork(long vmId, long ntwkId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDefaultPhysicalNetworkByZoneAndTrafficType(long, com.cloud.network.Networks.TrafficType) + */ + @Override + public PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNetwork(long) + */ + @Override + public Network getNetwork(long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getIp(long) + */ + @Override + public IpAddress getIp(long sourceIpAddressId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isNetworkAvailableInDomain(long, long) + */ + @Override + public boolean isNetworkAvailableInDomain(long networkId, long domainId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getNicProfile(com.cloud.vm.VirtualMachine, long, java.lang.String) + */ + @Override + public NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getAvailableIps(com.cloud.network.Network, java.lang.String) + */ + @Override + public Set getAvailableIps(Network network, String requestedIp) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getDomainNetworkDomain(long, long) + */ + @Override + public String getDomainNetworkDomain(long domainId, long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getIpToServices(java.util.List, boolean, boolean) + */ + @Override + public Map> getIpToServices(List publicIps, boolean rulesRevoked, + boolean includingFirewall) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getProviderToIpList(com.cloud.network.Network, java.util.Map) + */ + @Override + public Map> getProviderToIpList(Network network, + Map> ipToServices) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#getSourceNatIpAddressForGuestNetwork(com.cloud.user.Account, com.cloud.network.Network) + */ + @Override + public PublicIpAddress getSourceNatIpAddressForGuestNetwork(Account owner, Network guestNetwork) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.NetworkModel#isNetworkInlineMode(com.cloud.network.Network) + */ + @Override + public boolean isNetworkInlineMode(Network network) { + // TODO Auto-generated method stub + return false; + } + +} diff --git a/server/test/com/cloud/network/MockRulesManagerImpl.java b/server/test/com/cloud/network/MockRulesManagerImpl.java new file mode 100644 index 00000000000..3687e9c441b --- /dev/null +++ b/server/test/com/cloud/network/MockRulesManagerImpl.java @@ -0,0 +1,312 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.network; + +import java.util.List; +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.api.command.user.firewall.ListPortForwardingRulesCmd; + +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.exception.NetworkRuleConflictException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.rules.FirewallRule; +import com.cloud.network.rules.PortForwardingRule; +import com.cloud.network.rules.PortForwardingRuleVO; +import com.cloud.network.rules.RulesManager; +import com.cloud.network.rules.RulesService; +import com.cloud.network.rules.StaticNatRule; +import com.cloud.network.rules.FirewallRule.Purpose; +import com.cloud.user.Account; +import com.cloud.uservm.UserVm; +import com.cloud.utils.Pair; +import com.cloud.utils.component.Manager; +import com.cloud.vm.VirtualMachine; + +@Local(value = {RulesManager.class, RulesService.class}) +public class MockRulesManagerImpl implements RulesManager, Manager, RulesService { + + @Override + public Pair, Integer> searchStaticNatRules( + Long ipId, Long id, Long vmId, Long start, Long size, + String accountName, Long domainId, Long projectId, + boolean isRecursive, boolean listAll) { + // TODO Auto-generated method stub + return null; + } + + @Override + public PortForwardingRule createPortForwardingRule(PortForwardingRule rule, + Long vmId, boolean openFirewall) + throws NetworkRuleConflictException { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean revokePortForwardingRule(long ruleId, boolean apply) { + // TODO Auto-generated method stub + return false; + } + + @Override + public Pair, Integer> listPortForwardingRules( + ListPortForwardingRulesCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean applyPortForwardingRules(long ipAdddressId, Account caller) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean enableStaticNat(long ipAddressId, long vmId, long networkId, + boolean isSystemVm) throws NetworkRuleConflictException, + ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public PortForwardingRule getPortForwardigRule(long ruleId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public FirewallRule getFirewallRule(long ruleId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public StaticNatRule createStaticNatRule(StaticNatRule rule, + boolean openFirewall) throws NetworkRuleConflictException { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean revokeStaticNatRule(long ruleId, boolean apply) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyStaticNatRules(long ipAdddressId, Account caller) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public StaticNatRule buildStaticNatRule(FirewallRule rule, boolean forRevoke) { + // TODO Auto-generated method stub + return null; + } + + @Override + public List getSourceCidrs(long ruleId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean disableStaticNat(long ipId) + throws ResourceUnavailableException, NetworkRuleConflictException, + InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyPortForwardingRules(long ipAddressId, + boolean continueOnError, Account caller) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyStaticNatRulesForIp(long sourceIpId, + boolean continueOnError, Account caller, boolean forRevoke) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyPortForwardingRulesForNetwork(long networkId, + boolean continueOnError, Account caller) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyStaticNatRulesForNetwork(long networkId, + boolean continueOnError, Account caller) { + // TODO Auto-generated method stub + return false; + } + + @Override + public void checkIpAndUserVm(IpAddress ipAddress, UserVm userVm, + Account caller) { + // TODO Auto-generated method stub + + } + + @Override + public void checkRuleAndUserVm(FirewallRule rule, UserVm userVm, + Account caller) { + // TODO Auto-generated method stub + + } + + @Override + public boolean revokeAllPFAndStaticNatRulesForIp(long ipId, long userId, + Account caller) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean revokeAllPFStaticNatRulesForNetwork(long networkId, + long userId, Account caller) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public List listFirewallRulesByIp(long ipAddressId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public List listPortForwardingRulesForApplication( + long ipId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public List gatherPortForwardingRulesForApplication( + List addrs) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean revokePortForwardingRulesForVm(long vmId) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean revokeStaticNatRulesForVm(long vmId) { + // TODO Auto-generated method stub + return false; + } + + @Override + public FirewallRule[] reservePorts(IpAddress ip, String protocol, + Purpose purpose, boolean openFirewall, Account caller, int... ports) + throws NetworkRuleConflictException { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean releasePorts(long ipId, String protocol, Purpose purpose, + int... ports) { + // TODO Auto-generated method stub + return false; + } + + @Override + public List listByNetworkId(long networkId) { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean applyStaticNatForIp(long sourceIpId, + boolean continueOnError, Account caller, boolean forRevoke) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyStaticNatsForNetwork(long networkId, + boolean continueOnError, Account caller) { + // TODO Auto-generated method stub + return false; + } + + @Override + public void getSystemIpAndEnableStaticNatForVm(VirtualMachine vm, + boolean getNewIp) throws InsufficientAddressCapacityException { + // TODO Auto-generated method stub + + } + + @Override + public boolean disableStaticNat(long ipAddressId, Account caller, + long callerUserId, boolean releaseIpIfElastic) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean applyStaticNatForNetwork(long networkId, + boolean continueOnError, Account caller, boolean forRevoke) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean configure(String name, Map params) + throws ConfigurationException { + + return true; + } + + @Override + public boolean start() { + return true; + } + + @Override + public boolean stop() { + // TODO Auto-generated method stub + return false; + } + + @Override + public String getName() { + // TODO Auto-generated method stub + return "MockRulesManagerImpl"; + } + +} diff --git a/server/test/com/cloud/network/NetworkManagerTest.java b/server/test/com/cloud/network/NetworkManagerTest.java new file mode 100644 index 00000000000..c7d2a076c94 --- /dev/null +++ b/server/test/com/cloud/network/NetworkManagerTest.java @@ -0,0 +1,66 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + + +import junit.framework.Assert; + +import org.apache.log4j.Logger; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; + +import com.cloud.network.element.DhcpServiceProvider; +import com.cloud.network.element.IpDeployer; +import com.cloud.utils.component.ComponentLocator; +import com.cloud.utils.testcase.ComponentSetup; +import com.cloud.utils.testcase.ComponentTestCase; + +@Ignore("Requires database to be set up") +@ComponentSetup(managerName="management-server", setupXml="network-mgr-component.xml") +public class NetworkManagerTest extends ComponentTestCase { + private static final Logger s_logger = Logger.getLogger(NetworkManagerTest.class); + @Before + @Override + protected void setUp() { + super.setUp(); + } + + @Test + public void testInjected() { + NetworkManagerImpl networkMgr = (NetworkManagerImpl)ComponentLocator.getCurrentLocator().getManager(NetworkManager.class); + Assert.assertTrue(networkMgr._ipDeployers.enumeration().hasMoreElements()); + Assert.assertTrue(networkMgr._networkElements.enumeration().hasMoreElements()); + Assert.assertTrue(networkMgr._dhcpProviders.enumeration().hasMoreElements()); + Assert.assertNotNull(networkMgr._networkModel); + + Assert.assertNotNull(networkMgr._ipDeployers.get("VirtualRouter")); + Assert.assertNotNull(networkMgr._ipDeployers.get("VpcVirtualRouter")); + + Assert.assertNotNull(networkMgr._dhcpProviders.get("VirtualRouter")); + Assert.assertNotNull(networkMgr._dhcpProviders.get("VpcVirtualRouter")); + + + Assert.assertTrue(networkMgr._ipDeployers.get("VirtualRouter") instanceof IpDeployer); + Assert.assertTrue(networkMgr._dhcpProviders.get("VirtualRouter") instanceof DhcpServiceProvider); + + s_logger.info("Done testing injection of network manager's network elements"); + + } + +} diff --git a/server/test/com/cloud/network/NetworkManagerTestComponentLibrary.java b/server/test/com/cloud/network/NetworkManagerTestComponentLibrary.java new file mode 100644 index 00000000000..24979e40b66 --- /dev/null +++ b/server/test/com/cloud/network/NetworkManagerTestComponentLibrary.java @@ -0,0 +1,104 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + +import com.cloud.agent.MockAgentManagerImpl; +import com.cloud.alert.AlertManagerImpl; +import com.cloud.alert.MockAlertManagerImpl; +import com.cloud.baremetal.ExternalDhcpManagerImpl; +import com.cloud.configuration.ConfigurationManagerImpl; +import com.cloud.configuration.DefaultComponentLibrary; +import com.cloud.network.as.AutoScaleManagerImpl; +import com.cloud.network.firewall.FirewallManagerImpl; +import com.cloud.network.lb.LoadBalancingRulesManagerImpl; +import com.cloud.network.router.VpcVirtualNetworkApplianceManagerImpl; +import com.cloud.network.rules.RulesManagerImpl; +import com.cloud.network.security.SecurityGroupManagerImpl2; +import com.cloud.network.vpc.NetworkACLManagerImpl; +import com.cloud.network.vpc.VpcManagerImpl; +import com.cloud.network.vpn.RemoteAccessVpnManagerImpl; +import com.cloud.network.vpn.Site2SiteVpnManagerImpl; +import com.cloud.projects.MockProjectManagerImpl; +import com.cloud.projects.ProjectManagerImpl; +import com.cloud.resource.MockResourceManagerImpl; +import com.cloud.resource.ResourceManagerImpl; +import com.cloud.resourcelimit.ResourceLimitManagerImpl; +import com.cloud.storage.s3.S3ManagerImpl; +import com.cloud.storage.secondary.SecondaryStorageManagerImpl; +import com.cloud.storage.swift.SwiftManagerImpl; +import com.cloud.tags.TaggedResourceManagerImpl; +import com.cloud.template.TemplateManagerImpl; +import com.cloud.user.AccountManagerImpl; +import com.cloud.user.DomainManagerImpl; +import com.cloud.user.MockAccountManagerImpl; +import com.cloud.user.MockDomainManagerImpl; +import com.cloud.vm.MockVirtualMachineManagerImpl; +import com.cloud.vpc.MockConfigurationManagerImpl; +import com.cloud.vpc.MockResourceLimitManagerImpl; +import com.cloud.vpc.MockVpcManagerImpl; +import com.cloud.vpc.MockVpcVirtualNetworkApplianceManager; + + +public class NetworkManagerTestComponentLibrary extends DefaultComponentLibrary { + + /* (non-Javadoc) + * @see com.cloud.configuration.DefaultComponentLibrary#populateManagers() + */ + @Override + protected void populateManagers() { + addManager("configuration manager", MockConfigurationManagerImpl.class); + addManager("account manager", MockAccountManagerImpl.class); + addManager("domain manager", MockDomainManagerImpl.class); + addManager("resource limit manager", MockResourceLimitManagerImpl.class); + addManager("network service", NetworkServiceImpl.class); + addManager("network manager", NetworkManagerImpl.class); + addManager("network model", NetworkModelImpl.class); + addManager("LoadBalancingRulesManager", LoadBalancingRulesManagerImpl.class); + //addManager("AutoScaleManager", AutoScaleManagerImpl.class); + addManager("RulesManager", RulesManagerImpl.class); + addManager("RemoteAccessVpnManager", RemoteAccessVpnManagerImpl.class); + addManager("FirewallManager", FirewallManagerImpl.class); + addManager("StorageNetworkManager", StorageNetworkManagerImpl.class); + addManager("VPC Manager", MockVpcManagerImpl.class); + addManager("VpcVirtualRouterManager", MockVpcVirtualNetworkApplianceManager.class); + addManager("NetworkACLManager", NetworkACLManagerImpl.class); + addManager("Site2SiteVpnManager", Site2SiteVpnManagerImpl.class); + addManager("Alert Manager", MockAlertManagerImpl.class); + addManager("ProjectManager", MockProjectManagerImpl.class); + //addManager("SwiftManager", SwiftManagerImpl.class); + //addManager("S3Manager", S3ManagerImpl.class); + //addManager("SecondaryStorageManager", SecondaryStorageManagerImpl.class); + //addManager("SecurityGroupManager", SecurityGroupManagerImpl2.class); + addManager("AgentManager", MockAgentManagerImpl.class); + addManager("ExternalLoadBalancerUsageManager", ExternalLoadBalancerUsageManagerImpl.class); + //addManager("TemplateManager", TemplateManagerImpl.class); + //addManager("VirtualMachineManager", MockVirtualMachineManagerImpl.class); + addManager("ResourceManager", MockResourceManagerImpl.class); + addManager("ExternalDhcpManager", ExternalDhcpManagerImpl.class); + + + + + } + + @Override + protected void populateAdapters() { + //no-op + } + +} diff --git a/server/test/com/cloud/network/NetworkModelTest.java b/server/test/com/cloud/network/NetworkModelTest.java new file mode 100644 index 00000000000..52b3187e50c --- /dev/null +++ b/server/test/com/cloud/network/NetworkModelTest.java @@ -0,0 +1,88 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.mockito.Matchers.*; + +import java.util.ArrayList; +import java.util.List; + +import junit.framework.Assert; + +import org.junit.Before; +import org.junit.Test; + +import com.cloud.dc.VlanVO; +import com.cloud.dc.dao.VlanDao; +import com.cloud.network.dao.IPAddressDao; +import com.cloud.user.Account; +import com.cloud.utils.db.Filter; +import com.cloud.utils.db.SearchBuilder; +import com.cloud.utils.db.SearchCriteria; +import com.cloud.utils.net.Ip; + +public class NetworkModelTest { + @Before + public void setUp() { + + } + + @Test + public void testGetSourceNatIpAddressForGuestNetwork() { + NetworkModelImpl modelImpl = new NetworkModelImpl(); + IPAddressDao ipAddressDao = mock(IPAddressDao.class); + modelImpl._ipAddressDao = ipAddressDao; + List fakeList = new ArrayList(); + IPAddressVO fakeIp = new IPAddressVO(new Ip("75.75.75.75"), 1, 0xaabbccddeeffL, 10, false); + fakeList.add(fakeIp); + SearchBuilder fakeSearch = mock(SearchBuilder.class); + modelImpl.IpAddressSearch = fakeSearch; + VlanDao fakeVlanDao = mock(VlanDao.class); + when (fakeVlanDao.findById(anyLong())).thenReturn(mock(VlanVO.class)); + modelImpl._vlanDao = fakeVlanDao; + when(fakeSearch.create()).thenReturn(mock(SearchCriteria.class)); + when( + ipAddressDao.search( + any(SearchCriteria.class), + (Filter)org.mockito.Matchers.isNull() + ) + ).thenReturn(fakeList); + when ( + ipAddressDao.findById(anyLong()) + ).thenReturn(fakeIp); + Account fakeAccount = mock(Account.class); + when(fakeAccount.getId()).thenReturn(1L); + Network fakeNetwork = mock(Network.class); + when(fakeNetwork.getId()).thenReturn(1L); + PublicIpAddress answer = modelImpl.getSourceNatIpAddressForGuestNetwork(fakeAccount, fakeNetwork); + Assert.assertNull(answer); + IPAddressVO fakeIp2 = new IPAddressVO(new Ip("76.75.75.75"), 1, 0xaabb10ddeeffL, 10, true); + fakeList.add(fakeIp2); + when ( + ipAddressDao.findById(anyLong()) + ).thenReturn(fakeIp2); + answer = modelImpl.getSourceNatIpAddressForGuestNetwork(fakeAccount, fakeNetwork); + Assert.assertNotNull(answer); + Assert.assertEquals(answer.getAddress().addr(), "76.75.75.75"); + + } + +} diff --git a/server/test/com/cloud/network/firewall/FirewallManagerTest.java b/server/test/com/cloud/network/firewall/FirewallManagerTest.java new file mode 100644 index 00000000000..4fbe8d9aca1 --- /dev/null +++ b/server/test/com/cloud/network/firewall/FirewallManagerTest.java @@ -0,0 +1,177 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.network.firewall; + + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyBoolean; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; + +import junit.framework.Assert; + +import org.apache.log4j.Level; +import org.apache.log4j.Logger; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; + +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.Network; +import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkRuleApplier; +import com.cloud.network.element.FirewallServiceProvider; +import com.cloud.network.element.NetworkACLServiceProvider; +import com.cloud.network.element.PortForwardingServiceProvider; +import com.cloud.network.element.StaticNatServiceProvider; +import com.cloud.network.element.VirtualRouterElement; +import com.cloud.network.element.VpcVirtualRouterElement; +import com.cloud.network.rules.FirewallManager; +import com.cloud.network.rules.FirewallRule; +import com.cloud.network.rules.FirewallRule.Purpose; +import com.cloud.network.rules.FirewallRuleVO; +import com.cloud.utils.component.Adapter; +import com.cloud.utils.component.Adapters; +import com.cloud.utils.component.ComponentLocator; +import com.cloud.utils.component.ComponentLocator.ComponentInfo; +import com.cloud.utils.db.GenericDaoBase; +import com.cloud.utils.testcase.ComponentSetup; +import com.cloud.utils.testcase.ComponentTestCase; + +@Ignore("Requires database to be set up") +@ComponentSetup(managerName="management-server", setupXml="network-mgr-component.xml") +public class FirewallManagerTest extends ComponentTestCase { + private static final Logger s_logger = Logger.getLogger(FirewallManagerTest.class); + + @Before + public void setUp() { + Logger componentlogger = Logger.getLogger(ComponentLocator.class); + Logger daoLogger = Logger.getLogger(GenericDaoBase.class); + Logger cloudLogger = Logger.getLogger("com.cloud"); + + componentlogger.setLevel(Level.WARN); + daoLogger.setLevel(Level.ERROR); + cloudLogger.setLevel(Level.ERROR); + s_logger.setLevel(Level.INFO); + super.setUp(); + } + + + @Test + public void testInjected() { + + FirewallManagerImpl firewallMgr = (FirewallManagerImpl)ComponentLocator.getCurrentLocator().getManager(FirewallManager.class); + Assert.assertTrue(firewallMgr._firewallElements.enumeration().hasMoreElements()); + Assert.assertTrue(firewallMgr._pfElements.enumeration().hasMoreElements()); + Assert.assertTrue(firewallMgr._staticNatElements.enumeration().hasMoreElements()); + Assert.assertTrue(firewallMgr._networkAclElements.enumeration().hasMoreElements()); + Assert.assertNotNull(firewallMgr._networkModel); + + Assert.assertNotNull(firewallMgr._firewallElements.get("VirtualRouter")); + Assert.assertNotNull(firewallMgr._firewallElements.get("VpcVirtualRouter")); + Assert.assertNotNull(firewallMgr._pfElements.get("VirtualRouter")); + Assert.assertNotNull(firewallMgr._pfElements.get("VpcVirtualRouter")); + Assert.assertNotNull(firewallMgr._staticNatElements.get("VirtualRouter")); + Assert.assertNotNull(firewallMgr._staticNatElements.get("VpcVirtualRouter")); + Assert.assertNotNull(firewallMgr._networkAclElements.get("VpcVirtualRouter")); + Assert.assertNull(firewallMgr._networkAclElements.get("VirtualRouter")); + + + Assert.assertTrue(firewallMgr._firewallElements.get("VirtualRouter") instanceof FirewallServiceProvider); + Assert.assertTrue(firewallMgr._pfElements.get("VirtualRouter") instanceof PortForwardingServiceProvider); + Assert.assertTrue(firewallMgr._staticNatElements.get("VirtualRouter") instanceof StaticNatServiceProvider); + Assert.assertTrue(firewallMgr._networkAclElements.get("VpcVirtualRouter") instanceof NetworkACLServiceProvider); + + s_logger.info("Done testing injection of service elements into firewall manager"); + + } + + @Test + public void testApplyRules() { + List ruleList = new ArrayList(); + FirewallRuleVO rule = + new FirewallRuleVO("rule1", 1, 80, "TCP", 1, 2, 1, + FirewallRule.Purpose.Firewall, null, null, null, null); + ruleList.add(rule); + FirewallManagerImpl firewallMgr = (FirewallManagerImpl)ComponentLocator.getCurrentLocator().getManager(FirewallManager.class); + + NetworkManager netMgr = mock(NetworkManager.class); + firewallMgr._networkMgr = netMgr; + + try { + firewallMgr.applyRules(ruleList, false, false); + verify(netMgr) + .applyRules(any(List.class), + any(FirewallRule.Purpose.class), + any(NetworkRuleApplier.class), + anyBoolean()); + + } catch (ResourceUnavailableException e) { + Assert.fail("Unreachable code"); + } + } + + @Test + public void testApplyFWRules() { + List ruleList = new ArrayList(); + FirewallRuleVO rule = + new FirewallRuleVO("rule1", 1, 80, "TCP", 1, 2, 1, + FirewallRule.Purpose.Firewall, null, null, null, null); + ruleList.add(rule); + FirewallManagerImpl firewallMgr = (FirewallManagerImpl)ComponentLocator.getCurrentLocator().getManager(FirewallManager.class); + VirtualRouterElement virtualRouter = + mock(VirtualRouterElement.class); + VpcVirtualRouterElement vpcVirtualRouter = + mock(VpcVirtualRouterElement.class); + ComponentInfo c1 = + new ComponentInfo("VirtualRouter", + VirtualRouterElement.class, virtualRouter); + ComponentInfo c2 = + new ComponentInfo("VpcVirtualRouter", + VpcVirtualRouterElement.class, vpcVirtualRouter); + List> adapters = + new ArrayList>(); + adapters.add(c1); + adapters.add(c2); + Adapters fwElements = + new Adapters("firewalElements", adapters); + firewallMgr._firewallElements = fwElements; + + try { + when( + virtualRouter.applyFWRules(any(Network.class), any(List.class)) + ).thenReturn(false); + when( + vpcVirtualRouter.applyFWRules(any(Network.class), any(List.class)) + ).thenReturn(true); + //Network network, Purpose purpose, List rules + firewallMgr.applyRules(mock(Network.class), Purpose.Firewall, ruleList); + verify(vpcVirtualRouter).applyFWRules(any(Network.class), any(List.class)); + verify(virtualRouter).applyFWRules(any(Network.class), any(List.class)); + + + } catch (ResourceUnavailableException e) { + Assert.fail("Unreachable code"); + } + } + +} diff --git a/server/test/com/cloud/network/security/SecurityGroupManagerImpl2Test.java b/server/test/com/cloud/network/security/SecurityGroupManagerImpl2Test.java index 461bde0b95d..c7c5513b6b2 100644 --- a/server/test/com/cloud/network/security/SecurityGroupManagerImpl2Test.java +++ b/server/test/com/cloud/network/security/SecurityGroupManagerImpl2Test.java @@ -34,6 +34,7 @@ import com.cloud.configuration.dao.ConfigurationDaoImpl; import com.cloud.domain.dao.DomainDaoImpl; import com.cloud.event.dao.UsageEventDaoImpl; import com.cloud.network.MockNetworkManagerImpl; +import com.cloud.network.MockNetworkModelImpl; import com.cloud.network.security.dao.SecurityGroupDaoImpl; import com.cloud.network.security.dao.SecurityGroupRuleDaoImpl; import com.cloud.network.security.dao.SecurityGroupRulesDaoImpl; @@ -83,6 +84,7 @@ public class SecurityGroupManagerImpl2Test extends TestCase { locator.addManager("VirtualMachineManager", MockVirtualMachineManagerImpl.class); locator.addManager("UserVmManager", MockUserVmManagerImpl.class); locator.addManager("NetworkManager", MockNetworkManagerImpl.class); + locator.addManager("NetworkModel", MockNetworkModelImpl.class); locator.addManager("AccountManager", MockAccountManagerImpl.class); locator.addManager("DomainManager", MockDomainManagerImpl.class); locator.addManager("ProjectManager", MockProjectManagerImpl.class); diff --git a/server/test/com/cloud/network/vpn/MockRemoteAccessVPNServiceProvider.java b/server/test/com/cloud/network/vpn/MockRemoteAccessVPNServiceProvider.java new file mode 100644 index 00000000000..1a01681a112 --- /dev/null +++ b/server/test/com/cloud/network/vpn/MockRemoteAccessVPNServiceProvider.java @@ -0,0 +1,78 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.network.vpn; + +import java.util.List; +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.Network; +import com.cloud.network.RemoteAccessVpn; +import com.cloud.network.VpnUser; +import com.cloud.network.element.RemoteAccessVPNServiceProvider; + +@Local (value = RemoteAccessVPNServiceProvider.class) +public class MockRemoteAccessVPNServiceProvider implements + RemoteAccessVPNServiceProvider { + + @Override + public boolean configure(String name, Map params) + throws ConfigurationException { + return true; + } + + @Override + public String getName() { + return "MockRemoteAccessVPNServiceProvider"; + } + + @Override + public boolean start() { + return true; + } + + @Override + public boolean stop() { + // TODO Auto-generated method stub + return false; + } + + @Override + public String[] applyVpnUsers(RemoteAccessVpn vpn, + List users) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean startVpn(Network network, RemoteAccessVpn vpn) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean stopVpn(Network network, RemoteAccessVpn vpn) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + +} diff --git a/server/test/com/cloud/network/vpn/RemoteAccessVpnTest.java b/server/test/com/cloud/network/vpn/RemoteAccessVpnTest.java new file mode 100644 index 00000000000..b691d2a1b6f --- /dev/null +++ b/server/test/com/cloud/network/vpn/RemoteAccessVpnTest.java @@ -0,0 +1,109 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.network.vpn; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import javax.naming.ConfigurationException; + +import junit.framework.Assert; + +import org.apache.log4j.Logger; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import com.cloud.configuration.DefaultInterceptorLibrary; +import com.cloud.configuration.dao.ConfigurationDaoImpl; +import com.cloud.domain.dao.DomainDaoImpl; +import com.cloud.event.dao.UsageEventDaoImpl; +import com.cloud.network.MockFirewallManagerImpl; +import com.cloud.network.MockNetworkManagerImpl; +import com.cloud.network.MockNetworkModelImpl; +import com.cloud.network.MockRulesManagerImpl; +import com.cloud.network.dao.FirewallRulesDaoImpl; +import com.cloud.network.dao.IPAddressDaoImpl; +import com.cloud.network.dao.RemoteAccessVpnDaoImpl; +import com.cloud.network.dao.VpnUserDaoImpl; +import com.cloud.network.element.RemoteAccessVPNServiceProvider; +import com.cloud.user.MockAccountManagerImpl; +import com.cloud.user.MockDomainManagerImpl; +import com.cloud.user.dao.AccountDaoImpl; +import com.cloud.utils.Pair; +import com.cloud.utils.component.ComponentLocator; +import com.cloud.utils.component.MockComponentLocator; + +public class RemoteAccessVpnTest { + private MockComponentLocator locator; + private final static Logger s_logger = Logger.getLogger(RemoteAccessVpnTest.class); + + + private static void addDaos(MockComponentLocator locator) { + locator.addDao("AccountDao", AccountDaoImpl.class); + locator.addDao("VpnUserDao", VpnUserDaoImpl.class); + locator.addDao("FirewallRulesDao", FirewallRulesDaoImpl.class); + locator.addDao("IPAddressDao", IPAddressDaoImpl.class); + locator.addDao("DomainDao", DomainDaoImpl.class); + locator.addDao("UsageEventDao", UsageEventDaoImpl.class); + locator.addDao("RemoteAccessVpnDao", RemoteAccessVpnDaoImpl.class); + locator.addDao("ConfigurationDao", ConfigurationDaoImpl.class); + + } + + private static void addManagers(MockComponentLocator locator) { + locator.addManager("AccountManager", MockAccountManagerImpl.class); + locator.addManager("DomainManager", MockDomainManagerImpl.class); + locator.addManager("NetworkManager", MockNetworkManagerImpl.class); + locator.addManager("NetworkModel", MockNetworkModelImpl.class); + locator.addManager("RulesManager", MockRulesManagerImpl.class); + locator.addManager("FirewallManager", MockFirewallManagerImpl.class); + } + + @Before + public void setUp() { + locator = new MockComponentLocator("management-server"); + addDaos(locator); + addManagers(locator); + s_logger.info("Finished setUp"); + } + + @After + public void tearDown() throws Exception { + } + + + @Test + public void testInjected() throws Exception { + List>> list = + new ArrayList>>(); + list.add(new Pair>("RemoteAccessVPNServiceProvider", MockRemoteAccessVPNServiceProvider.class)); + locator.addAdapterChain(RemoteAccessVPNServiceProvider.class, list); + s_logger.info("Finished add adapter"); + locator.makeActive(new DefaultInterceptorLibrary()); + s_logger.info("Finished make active"); + RemoteAccessVpnManagerImpl vpnMgr = ComponentLocator.inject(RemoteAccessVpnManagerImpl.class); + s_logger.info("Finished inject"); + Assert.assertTrue(vpnMgr.configure("RemoteAccessVpnMgr",new HashMap()) ); + Assert.assertTrue(vpnMgr.start()); + int numProviders = vpnMgr.getRemoteAccessVPNServiceProviders().size(); + Assert.assertTrue(numProviders > 0); + } + + +} diff --git a/server/test/com/cloud/resource/MockResourceManagerImpl.java b/server/test/com/cloud/resource/MockResourceManagerImpl.java new file mode 100644 index 00000000000..e94cdea9853 --- /dev/null +++ b/server/test/com/cloud/resource/MockResourceManagerImpl.java @@ -0,0 +1,601 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.resource; + +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.api.command.admin.cluster.AddClusterCmd; +import org.apache.cloudstack.api.command.admin.cluster.DeleteClusterCmd; +import org.apache.cloudstack.api.command.admin.host.*; +import org.apache.cloudstack.api.command.admin.storage.*; +import org.apache.cloudstack.api.command.admin.swift.*; + +import com.cloud.agent.api.StartupCommand; +import com.cloud.agent.api.StartupRoutingCommand; + +import com.cloud.dc.DataCenterVO; +import com.cloud.dc.HostPodVO; +import com.cloud.dc.PodCluster; +import com.cloud.exception.AgentUnavailableException; +import com.cloud.exception.DiscoveryException; +import com.cloud.exception.InvalidParameterValueException; +import com.cloud.exception.ResourceInUseException; +import com.cloud.host.Host; +import com.cloud.host.HostStats; +import com.cloud.host.HostVO; +import com.cloud.host.Status; +import com.cloud.host.Host.Type; +import com.cloud.hypervisor.Hypervisor.HypervisorType; +import com.cloud.org.Cluster; +import com.cloud.resource.ResourceState.Event; +import com.cloud.service.ServiceOfferingVO; +import com.cloud.storage.S3; +import com.cloud.storage.Swift; +import com.cloud.template.VirtualMachineTemplate; +import com.cloud.utils.Pair; +import com.cloud.utils.component.Manager; +import com.cloud.utils.fsm.NoTransitionException; + +@Local(value = {ResourceManager.class}) +public class MockResourceManagerImpl implements ResourceManager, Manager { + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#updateHost(com.cloud.api.commands.UpdateHostCmd) + */ + @Override + public Host updateHost(UpdateHostCmd cmd) throws NoTransitionException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#cancelMaintenance(com.cloud.api.commands.CancelMaintenanceCmd) + */ + @Override + public Host cancelMaintenance(CancelMaintenanceCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#reconnectHost(com.cloud.api.commands.ReconnectHostCmd) + */ + @Override + public Host reconnectHost(ReconnectHostCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#discoverCluster(com.cloud.api.commands.AddClusterCmd) + */ + @Override + public List discoverCluster(AddClusterCmd cmd) throws IllegalArgumentException, + DiscoveryException, ResourceInUseException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#deleteCluster(com.cloud.api.commands.DeleteClusterCmd) + */ + @Override + public boolean deleteCluster(DeleteClusterCmd cmd) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#updateCluster(com.cloud.org.Cluster, java.lang.String, java.lang.String, java.lang.String, java.lang.String) + */ + @Override + public Cluster updateCluster(Cluster cluster, String clusterType, String hypervisor, String allocationState, + String managedstate) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#discoverHosts(com.cloud.api.commands.AddHostCmd) + */ + @Override + public List discoverHosts(AddHostCmd cmd) throws IllegalArgumentException, DiscoveryException, + InvalidParameterValueException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#discoverHosts(com.cloud.api.commands.AddSecondaryStorageCmd) + */ + @Override + public List discoverHosts(AddSecondaryStorageCmd cmd) throws IllegalArgumentException, + DiscoveryException, InvalidParameterValueException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#maintain(com.cloud.api.commands.PrepareForMaintenanceCmd) + */ + @Override + public Host maintain(PrepareForMaintenanceCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#updateHostPassword(com.cloud.api.commands.UpdateHostPasswordCmd) + */ + @Override + public boolean updateHostPassword(UpdateHostPasswordCmd upasscmd) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#getHost(long) + */ + @Override + public Host getHost(long hostId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#getCluster(java.lang.Long) + */ + @Override + public Cluster getCluster(Long clusterId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#discoverSwift(com.cloud.api.commands.AddSwiftCmd) + */ + @Override + public Swift discoverSwift(AddSwiftCmd addSwiftCmd) throws DiscoveryException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#discoverS3(com.cloud.api.commands.AddS3Cmd) + */ + @Override + public S3 discoverS3(AddS3Cmd cmd) throws DiscoveryException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#getSupportedHypervisorTypes(long, boolean, java.lang.Long) + */ + @Override + public List getSupportedHypervisorTypes(long zoneId, boolean forVirtualRouter, Long podId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#listSwifts(com.cloud.api.commands.ListSwiftsCmd) + */ + @Override + public List listSwifts(ListSwiftsCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceService#listS3s(com.cloud.api.commands.ListS3sCmd) + */ + @Override + public List listS3s(ListS3sCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#registerResourceEvent(java.lang.Integer, com.cloud.resource.ResourceListener) + */ + @Override + public void registerResourceEvent(Integer event, ResourceListener listener) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#unregisterResourceEvent(com.cloud.resource.ResourceListener) + */ + @Override + public void unregisterResourceEvent(ResourceListener listener) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#registerResourceStateAdapter(java.lang.String, com.cloud.resource.ResourceStateAdapter) + */ + @Override + public void registerResourceStateAdapter(String name, ResourceStateAdapter adapter) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#unregisterResourceStateAdapter(java.lang.String) + */ + @Override + public void unregisterResourceStateAdapter(String name) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#createHostAndAgent(java.lang.Long, com.cloud.resource.ServerResource, java.util.Map, boolean, java.util.List, boolean) + */ + @Override + public Host createHostAndAgent(Long hostId, ServerResource resource, Map details, boolean old, + List hostTags, boolean forRebalance) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#addHost(long, com.cloud.resource.ServerResource, com.cloud.host.Host.Type, java.util.Map) + */ + @Override + public Host addHost(long zoneId, ServerResource resource, Type hostType, Map hostDetails) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#createHostVOForConnectedAgent(com.cloud.agent.api.StartupCommand[]) + */ + @Override + public HostVO createHostVOForConnectedAgent(StartupCommand[] cmds) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#checkCIDR(com.cloud.dc.HostPodVO, com.cloud.dc.DataCenterVO, java.lang.String, java.lang.String) + */ + @Override + public void checkCIDR(HostPodVO pod, DataCenterVO dc, String serverPrivateIP, String serverPrivateNetmask) { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#fillRoutingHostVO(com.cloud.host.HostVO, com.cloud.agent.api.StartupRoutingCommand, com.cloud.hypervisor.Hypervisor.HypervisorType, java.util.Map, java.util.List) + */ + @Override + public HostVO fillRoutingHostVO(HostVO host, StartupRoutingCommand ssCmd, HypervisorType hyType, + Map details, List hostTags) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#deleteRoutingHost(com.cloud.host.HostVO, boolean, boolean) + */ + @Override + public void deleteRoutingHost(HostVO host, boolean isForced, boolean forceDestroyStorage) + throws UnableDeleteHostException { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#executeUserRequest(long, com.cloud.resource.ResourceState.Event) + */ + @Override + public boolean executeUserRequest(long hostId, Event event) throws AgentUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#resourceStateTransitTo(com.cloud.host.Host, com.cloud.resource.ResourceState.Event, long) + */ + @Override + public boolean resourceStateTransitTo(Host host, Event event, long msId) throws NoTransitionException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#umanageHost(long) + */ + @Override + public boolean umanageHost(long hostId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#maintenanceFailed(long) + */ + @Override + public boolean maintenanceFailed(long hostId) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#maintain(long) + */ + @Override + public boolean maintain(long hostId) throws AgentUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#deleteHost(long, boolean, boolean) + */ + @Override + public boolean deleteHost(long hostId, boolean isForced, boolean isForceDeleteStorage) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#findDirectlyConnectedHosts() + */ + @Override + public List findDirectlyConnectedHosts() { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllUpAndEnabledHosts(com.cloud.host.Host.Type, java.lang.Long, java.lang.Long, long) + */ + @Override + public List listAllUpAndEnabledHosts(Type type, Long clusterId, Long podId, long dcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllHostsInCluster(long) + */ + @Override + public List listAllHostsInCluster(long clusterId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listHostsInClusterByStatus(long, com.cloud.host.Status) + */ + @Override + public List listHostsInClusterByStatus(long clusterId, Status status) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllUpAndEnabledHostsInOneZoneByType(com.cloud.host.Host.Type, long) + */ + @Override + public List listAllUpAndEnabledHostsInOneZoneByType(Type type, long dcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllHostsInOneZoneByType(com.cloud.host.Host.Type, long) + */ + @Override + public List listAllHostsInOneZoneByType(Type type, long dcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllHostsInAllZonesByType(com.cloud.host.Host.Type) + */ + @Override + public List listAllHostsInAllZonesByType(Type type) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAvailHypervisorInZone(java.lang.Long, java.lang.Long) + */ + @Override + public List listAvailHypervisorInZone(Long hostId, Long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#findHostByGuid(java.lang.String) + */ + @Override + public HostVO findHostByGuid(String guid) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#findHostByName(java.lang.String) + */ + @Override + public HostVO findHostByName(String name) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listHostsByNameLike(java.lang.String) + */ + @Override + public List listHostsByNameLike(String name) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#findPod(com.cloud.template.VirtualMachineTemplate, com.cloud.service.ServiceOfferingVO, com.cloud.dc.DataCenterVO, long, java.util.Set) + */ + @Override + public Pair findPod(VirtualMachineTemplate template, ServiceOfferingVO offering, DataCenterVO dc, + long accountId, Set avoids) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#getHostStatistics(long) + */ + @Override + public HostStats getHostStatistics(long hostId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#getGuestOSCategoryId(long) + */ + @Override + public Long getGuestOSCategoryId(long hostId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#getHostTags(long) + */ + @Override + public String getHostTags(long hostId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listByDataCenter(long) + */ + @Override + public List listByDataCenter(long dcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllNotInMaintenanceHostsInOneZone(com.cloud.host.Host.Type, java.lang.Long) + */ + @Override + public List listAllNotInMaintenanceHostsInOneZone(Type type, Long dcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#getDefaultHypervisor(long) + */ + @Override + public HypervisorType getDefaultHypervisor(long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#getAvailableHypervisor(long) + */ + @Override + public HypervisorType getAvailableHypervisor(long zoneId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#getMatchingDiscover(com.cloud.hypervisor.Hypervisor.HypervisorType) + */ + @Override + public Discoverer getMatchingDiscover(HypervisorType hypervisorType) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#findHostByGuid(long, java.lang.String) + */ + @Override + public List findHostByGuid(long dcId, String guid) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.resource.ResourceManager#listAllUpAndEnabledNonHAHosts(com.cloud.host.Host.Type, java.lang.Long, java.lang.Long, long) + */ + @Override + public List listAllUpAndEnabledNonHAHosts(Type type, Long clusterId, Long podId, long dcId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#configure(java.lang.String, java.util.Map) + */ + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#start() + */ + @Override + public boolean start() { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#stop() + */ + @Override + public boolean stop() { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#getName() + */ + @Override + public String getName() { + // TODO Auto-generated method stub + return "MockResourceManagerImpl"; + } + +} diff --git a/server/test/com/cloud/user/MockDomainManagerImpl.java b/server/test/com/cloud/user/MockDomainManagerImpl.java index 9f49535ce68..0fe259d5c77 100644 --- a/server/test/com/cloud/user/MockDomainManagerImpl.java +++ b/server/test/com/cloud/user/MockDomainManagerImpl.java @@ -31,8 +31,8 @@ import com.cloud.exception.PermissionDeniedException; import com.cloud.utils.component.Manager; import com.cloud.utils.Pair; -@Local(value = { DomainManager.class }) -public class MockDomainManagerImpl implements Manager, DomainManager { +@Local(value = { DomainManager.class, DomainService.class }) +public class MockDomainManagerImpl implements Manager, DomainManager, DomainService { @Override public Domain createDomain(String name, Long parentId, String networkDomain) { diff --git a/server/test/com/cloud/vpc/MockNetworkManagerImpl.java b/server/test/com/cloud/vpc/MockNetworkManagerImpl.java index 642ea10c7ca..b4e17948a43 100644 --- a/server/test/com/cloud/vpc/MockNetworkManagerImpl.java +++ b/server/test/com/cloud/vpc/MockNetworkManagerImpl.java @@ -16,23 +16,52 @@ // under the License. package com.cloud.vpc; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.acl.ControlledEntity.ACLType; +import org.apache.cloudstack.api.command.admin.usage.ListTrafficTypeImplementorsCmd; +import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd; +import org.apache.cloudstack.api.command.user.network.ListNetworksCmd; +import org.apache.cloudstack.api.command.user.network.RestartNetworkCmd; +import org.apache.log4j.Logger; + import com.cloud.dc.DataCenter; -import com.cloud.dc.Vlan; import com.cloud.dc.Vlan.VlanType; import com.cloud.deploy.DataCenterDeployment; import com.cloud.deploy.DeployDestination; import com.cloud.deploy.DeploymentPlan; -import com.cloud.exception.*; -import com.cloud.hypervisor.Hypervisor.HypervisorType; -import com.cloud.network.*; -import com.cloud.network.Network.Capability; -import com.cloud.network.Network.GuestType; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientAddressCapacityException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.InsufficientVirtualNetworkCapcityException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.IPAddressVO; +import com.cloud.network.IpAddress; +import com.cloud.network.Network; import com.cloud.network.Network.Provider; import com.cloud.network.Network.Service; +import com.cloud.network.NetworkManager; +import com.cloud.network.NetworkProfile; +import com.cloud.network.NetworkRuleApplier; +import com.cloud.network.NetworkService; +import com.cloud.network.NetworkVO; import com.cloud.network.Networks.TrafficType; +import com.cloud.network.PhysicalNetwork; +import com.cloud.network.PhysicalNetworkServiceProvider; +import com.cloud.network.PhysicalNetworkTrafficType; +import com.cloud.network.PublicIpAddress; import com.cloud.network.addr.PublicIp; import com.cloud.network.dao.NetworkServiceMapDao; -import com.cloud.network.element.*; +import com.cloud.network.element.LoadBalancingServiceProvider; +import com.cloud.network.element.NetworkElement; +import com.cloud.network.element.StaticNatServiceProvider; +import com.cloud.network.element.UserDataServiceProvider; import com.cloud.network.guru.NetworkGuru; import com.cloud.network.rules.FirewallRule; import com.cloud.network.rules.FirewallRule.Purpose; @@ -47,21 +76,16 @@ import com.cloud.utils.Pair; import com.cloud.utils.component.Adapters; import com.cloud.utils.component.Inject; import com.cloud.utils.component.Manager; -import com.cloud.vm.*; -import com.cloud.vpc.dao.MockVpcVirtualRouterElement; -import org.apache.cloudstack.acl.ControlledEntity.ACLType; -import org.apache.cloudstack.api.command.admin.usage.ListTrafficTypeImplementorsCmd; -import org.apache.cloudstack.api.command.user.network.CreateNetworkCmd; -import org.apache.cloudstack.api.command.user.network.ListNetworksCmd; -import org.apache.cloudstack.api.command.user.network.RestartNetworkCmd; -import org.apache.log4j.Logger; - -import javax.ejb.Local; -import javax.naming.ConfigurationException; -import java.util.*; +import com.cloud.vm.Nic; +import com.cloud.vm.NicProfile; +import com.cloud.vm.ReservationContext; +import com.cloud.vm.VMInstanceVO; +import com.cloud.vm.VirtualMachine; +import com.cloud.vm.VirtualMachineProfile; +import com.cloud.vm.VirtualMachineProfileImpl; @Local(value = { NetworkManager.class, NetworkService.class }) -public class MockNetworkManagerImpl implements NetworkManager, Manager{ +public class MockNetworkManagerImpl implements NetworkManager, NetworkService, Manager{ @Inject NetworkServiceMapDao _ntwkSrvcDao; @Inject @@ -73,1361 +97,8 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager{ private static final Logger s_logger = Logger.getLogger(MockNetworkManagerImpl.class); - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getIsolatedNetworksOwnedByAccountInZone(long, com.cloud.user.Account) - */ - @Override - public List getIsolatedNetworksOwnedByAccountInZone(long zoneId, Account owner) { - // TODO Auto-generated method stub - return null; - } + - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#releaseIpAddress(long) - */ - @Override - public boolean releaseIpAddress(long ipAddressId) throws InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#createGuestNetwork(org.apache.cloudstack.api.commands.CreateNetworkCmd) - */ - @Override - public Network createGuestNetwork(CreateNetworkCmd cmd) throws InsufficientCapacityException, ConcurrentOperationException, ResourceAllocationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#searchForNetworks(org.apache.cloudstack.api.commands.ListNetworksCmd) - */ - @Override - public List searchForNetworks(ListNetworksCmd cmd) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#deleteNetwork(long) - */ - @Override - public boolean deleteNetwork(long networkId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#restartNetwork(org.apache.cloudstack.api.commands.RestartNetworkCmd, boolean) - */ - @Override - public boolean restartNetwork(RestartNetworkCmd cmd, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getActiveNicsInNetwork(long) - */ - @Override - public int getActiveNicsInNetwork(long networkId) { - // TODO Auto-generated method stub - return 0; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getNetwork(long) - */ - @Override - public Network getNetwork(long networkId) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Network getNetwork(String networkUuid) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getIp(long) - */ - @Override - public IpAddress getIp(long id) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#convertNetworkToNetworkProfile(long) - */ - @Override - public NetworkProfile convertNetworkToNetworkProfile(long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getNetworkCapabilities(long) - */ - @Override - public Map> getNetworkCapabilities(long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#isNetworkAvailableInDomain(long, long) - */ - @Override - public boolean isNetworkAvailableInDomain(long networkId, long domainId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getDedicatedNetworkDomain(long) - */ - @Override - public Long getDedicatedNetworkDomain(long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#updateGuestNetwork(long, java.lang.String, java.lang.String, com.cloud.user.Account, com.cloud.user.User, java.lang.String, java.lang.Long, java.lang.Boolean) - */ - @Override - public Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getNetworkRate(long, java.lang.Long) - */ - @Override - public Integer getNetworkRate(long networkId, Long vmId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getSystemNetworkByZoneAndTrafficType(long, com.cloud.network.Networks.TrafficType) - */ - @Override - public Network getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getNetworkOfferingServiceProvidersMap(long) - */ - @Override - public Map> getNetworkOfferingServiceProvidersMap(long networkOfferingId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#createPhysicalNetwork(java.lang.Long, java.lang.String, java.lang.String, java.util.List, java.lang.String, java.lang.Long, java.util.List, java.lang.String) - */ - @Override - public PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, List isolationMethods, String broadcastDomainRange, Long domainId, List tags, String name) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#searchPhysicalNetworks(java.lang.Long, java.lang.Long, java.lang.String, java.lang.Long, java.lang.Long, java.lang.String) - */ - @Override - public Pair, Integer> searchPhysicalNetworks(Long id, Long zoneId, String keyword, Long startIndex, Long pageSize, String name) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#updatePhysicalNetwork(java.lang.Long, java.lang.String, java.util.List, java.lang.String, java.lang.String) - */ - @Override - public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List tags, String newVnetRangeString, String state) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#deletePhysicalNetwork(java.lang.Long) - */ - @Override - public boolean deletePhysicalNetwork(Long id) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listNetworkServices(java.lang.String) - */ - @Override - public List listNetworkServices(String providerName) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listSupportedNetworkServiceProviders(java.lang.String) - */ - @Override - public List listSupportedNetworkServiceProviders(String serviceName) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#addProviderToPhysicalNetwork(java.lang.Long, java.lang.String, java.lang.Long, java.util.List) - */ - @Override - public PhysicalNetworkServiceProvider addProviderToPhysicalNetwork(Long physicalNetworkId, String providerName, Long destinationPhysicalNetworkId, List enabledServices) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listNetworkServiceProviders(java.lang.Long, java.lang.String, java.lang.String, java.lang.Long, java.lang.Long) - */ - @Override - public Pair, Integer> listNetworkServiceProviders(Long physicalNetworkId, String name, String state, Long startIndex, Long pageSize) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#updateNetworkServiceProvider(java.lang.Long, java.lang.String, java.util.List) - */ - @Override - public PhysicalNetworkServiceProvider updateNetworkServiceProvider(Long id, String state, List enabledServices) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#deleteNetworkServiceProvider(java.lang.Long) - */ - @Override - public boolean deleteNetworkServiceProvider(Long id) throws ConcurrentOperationException, ResourceUnavailableException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getPhysicalNetwork(java.lang.Long) - */ - @Override - public PhysicalNetwork getPhysicalNetwork(Long physicalNetworkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getCreatedPhysicalNetwork(java.lang.Long) - */ - @Override - public PhysicalNetwork getCreatedPhysicalNetwork(Long physicalNetworkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getPhysicalNetworkServiceProvider(java.lang.Long) - */ - @Override - public PhysicalNetworkServiceProvider getPhysicalNetworkServiceProvider(Long providerId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getCreatedPhysicalNetworkServiceProvider(java.lang.Long) - */ - @Override - public PhysicalNetworkServiceProvider getCreatedPhysicalNetworkServiceProvider(Long providerId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#findPhysicalNetworkId(long, java.lang.String, com.cloud.network.Networks.TrafficType) - */ - @Override - public long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType) { - // TODO Auto-generated method stub - return 0; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#addTrafficTypeToPhysicalNetwork(java.lang.Long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) - */ - @Override - public PhysicalNetworkTrafficType addTrafficTypeToPhysicalNetwork(Long physicalNetworkId, String trafficType, String xenLabel, String kvmLabel, String vmwareLabel, String simulatorLabel, String vlan) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getPhysicalNetworkTrafficType(java.lang.Long) - */ - @Override - public PhysicalNetworkTrafficType getPhysicalNetworkTrafficType(Long id) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#updatePhysicalNetworkTrafficType(java.lang.Long, java.lang.String, java.lang.String, java.lang.String) - */ - @Override - public PhysicalNetworkTrafficType updatePhysicalNetworkTrafficType(Long id, String xenLabel, String kvmLabel, String vmwareLabel) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#deletePhysicalNetworkTrafficType(java.lang.Long) - */ - @Override - public boolean deletePhysicalNetworkTrafficType(Long id) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listTrafficTypes(java.lang.Long) - */ - @Override - public Pair, Integer> listTrafficTypes(Long physicalNetworkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getDefaultPhysicalNetworkByZoneAndTrafficType(long, com.cloud.network.Networks.TrafficType) - */ - @Override - public PhysicalNetwork getDefaultPhysicalNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getExclusiveGuestNetwork(long) - */ - @Override - public Network getExclusiveGuestNetwork(long zoneId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listTrafficTypeImplementor(org.apache.cloudstack.api.commands.ListTrafficTypeImplementorsCmd) - */ - @Override - public List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long, com.cloud.user.Account) - */ - @Override - public List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#listNetworksByVpc(long) - */ - @Override - public List listNetworksByVpc(long vpcId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#isVmPartOfNetwork(long, long) - */ - @Override - public boolean isVmPartOfNetwork(long vmId, long ntwkId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#associateIPToNetwork(long, long) - */ - @Override - public IpAddress associateIPToNetwork(long ipId, long networkId) throws InsufficientAddressCapacityException, ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#createPrivateNetwork(java.lang.String, java.lang.String, long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, long, java.lang.Long) - */ - @Override - public Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, String vlan, String startIp, String endIP, String gateway, String netmask, long networkOwnerId, Long vpcId) - throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkService#canUseForDeploy(com.cloud.network.Network) - */ - @Override - public boolean canUseForDeploy(Network network) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignPublicIpAddress(long, java.lang.Long, com.cloud.user.Account, com.cloud.dc.Vlan.VlanType, java.lang.Long, java.lang.String, boolean) - */ - @Override - public PublicIp assignPublicIpAddress(long dcId, Long podId, Account owner, VlanType type, Long networkId, String requestedIp, boolean isSystem) throws InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#disassociatePublicIpAddress(long, long, com.cloud.user.Account) - */ - @Override - public boolean disassociatePublicIpAddress(long id, long userId, Account caller) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listPublicIpsAssignedToGuestNtwk(long, long, java.lang.Boolean) - */ - @Override - public List listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#setupNetwork(com.cloud.user.Account, com.cloud.offerings.NetworkOfferingVO, com.cloud.deploy.DeploymentPlan, java.lang.String, java.lang.String, boolean) - */ - @Override - public List setupNetwork(Account owner, NetworkOfferingVO offering, DeploymentPlan plan, String name, String displayText, boolean isDefault) throws ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#setupNetwork(com.cloud.user.Account, com.cloud.offerings.NetworkOfferingVO, com.cloud.network.Network, com.cloud.deploy.DeploymentPlan, java.lang.String, java.lang.String, boolean, java.lang.Long, org.apache.cloudstack.acl.ControlledEntity.ACLType, java.lang.Boolean, java.lang.Long) - */ - @Override - public List setupNetwork(Account owner, NetworkOfferingVO offering, Network predefined, DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, ACLType aclType, - Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getSystemAccountNetworkOfferings(java.lang.String[]) - */ - @Override - public List getSystemAccountNetworkOfferings(String... offeringNames) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#allocate(com.cloud.vm.VirtualMachineProfile, java.util.List) - */ - @Override - public void allocate(VirtualMachineProfile vm, List> networks) throws InsufficientCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#prepare(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext) - */ - @Override - public void prepare(VirtualMachineProfile profile, DeployDestination dest, ReservationContext context) throws InsufficientCapacityException, ConcurrentOperationException, - ResourceUnavailableException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#release(com.cloud.vm.VirtualMachineProfile, boolean) - */ - @Override - public void release(VirtualMachineProfile vmProfile, boolean forced) throws ConcurrentOperationException, ResourceUnavailableException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#cleanupNics(com.cloud.vm.VirtualMachineProfile) - */ - @Override - public void cleanupNics(VirtualMachineProfile vm) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#expungeNics(com.cloud.vm.VirtualMachineProfile) - */ - @Override - public void expungeNics(VirtualMachineProfile vm) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNics(long) - */ - @Override - public List getNics(long vmId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNicProfiles(com.cloud.vm.VirtualMachine) - */ - @Override - public List getNicProfiles(VirtualMachine vm) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNextAvailableMacAddressInNetwork(long) - */ - @Override - public String getNextAvailableMacAddressInNetwork(long networkConfigurationId) throws InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#applyRules(java.util.List, boolean) - */ - @Override - public boolean applyRules(List rules, boolean continueOnError) throws ResourceUnavailableException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#validateRule(com.cloud.network.rules.FirewallRule) - */ - @Override - public boolean validateRule(FirewallRule rule) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getRemoteAccessVpnElements() - */ - @Override - public List getRemoteAccessVpnElements() { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getSite2SiteVpnElements() - */ - @Override - public List getSite2SiteVpnElements() { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPublicIpAddress(long) - */ - @Override - public PublicIpAddress getPublicIpAddress(long ipAddressId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listPodVlans(long) - */ - @Override - public List listPodVlans(long podId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#implementNetwork(long, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext) - */ - @Override - public Pair implementNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, - InsufficientCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listNetworksUsedByVm(long, boolean) - */ - @Override - public List listNetworksUsedByVm(long vmId, boolean isSystem) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#prepareNicForMigration(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination) - */ - @Override - public void prepareNicForMigration(VirtualMachineProfile vm, DeployDestination dest) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#shutdownNetwork(long, com.cloud.vm.ReservationContext, boolean) - */ - @Override - public boolean shutdownNetwork(long networkId, ReservationContext context, boolean cleanupElements) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#destroyNetwork(long, com.cloud.vm.ReservationContext) - */ - @Override - public boolean destroyNetwork(long networkId, ReservationContext context) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#createGuestNetwork(long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, com.cloud.user.Account, java.lang.Long, com.cloud.network.PhysicalNetwork, long, org.apache.cloudstack.acl.ControlledEntity.ACLType, java.lang.Boolean, java.lang.Long) - */ - @Override - public Network createGuestNetwork(long networkOfferingId, String name, String displayText, String gateway, String cidr, String vlanId, String networkDomain, Account owner, Long domainId, - PhysicalNetwork physicalNetwork, long zoneId, ACLType aclType, Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException, InsufficientCapacityException, ResourceAllocationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#associateIpAddressListToAccount(long, long, long, java.lang.Long, com.cloud.network.Network) - */ - @Override - public boolean associateIpAddressListToAccount(long userId, long accountId, long zoneId, Long vlanId, Network guestNetwork) throws InsufficientCapacityException, ConcurrentOperationException, - ResourceUnavailableException, ResourceAllocationException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNicInNetwork(long, long) - */ - @Override - public Nic getNicInNetwork(long vmId, long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNicsForTraffic(long, com.cloud.network.Networks.TrafficType) - */ - @Override - public List getNicsForTraffic(long vmId, TrafficType type) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultNetworkForVm(long) - */ - @Override - public Network getDefaultNetworkForVm(long vmId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultNic(long) - */ - @Override - public Nic getDefaultNic(long vmId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPasswordResetElements() - */ - @Override - public UserDataServiceProvider getPasswordResetProvider(Network network) { - // TODO Auto-generated method stub - return null; - } - - @Override - public UserDataServiceProvider getUserDataUpdateProvider(Network network) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#networkIsConfiguredForExternalNetworking(long, long) - */ - @Override - public boolean networkIsConfiguredForExternalNetworking(long zoneId, long networkId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNetworkServiceCapabilities(long, com.cloud.network.Network.Service) - */ - @Override - public Map getNetworkServiceCapabilities(long networkId, Service service) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#applyIpAssociations(com.cloud.network.Network, boolean) - */ - @Override - public boolean applyIpAssociations(Network network, boolean continueOnError) throws ResourceUnavailableException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#areServicesSupportedByNetworkOffering(long, com.cloud.network.Network.Service[]) - */ - @Override - public boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) { - return (_ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(networkOfferingId, services)); - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNetworkWithSecurityGroupEnabled(java.lang.Long) - */ - @Override - public NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#startNetwork(long, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext) - */ - @Override - public boolean startNetwork(long networkId, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getIpOfNetworkElementInVirtualNetwork(long, long) - */ - @Override - public String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listNetworksForAccount(long, long, com.cloud.network.Network.GuestType) - */ - @Override - public List listNetworksForAccount(long accountId, long zoneId, GuestType type) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listAllNetworksInAllZonesByType(com.cloud.network.Network.GuestType) - */ - @Override - public List listAllNetworksInAllZonesByType(GuestType type) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#markIpAsUnavailable(long) - */ - @Override - public IPAddressVO markIpAsUnavailable(long addrId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#acquireGuestIpAddress(com.cloud.network.Network, java.lang.String) - */ - @Override - public String acquireGuestIpAddress(Network network, String requestedIp) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getGlobalGuestDomainSuffix() - */ - @Override - public String getGlobalGuestDomainSuffix() { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getStartIpAddress(long) - */ - @Override - public String getStartIpAddress(long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#applyStaticNats(java.util.List, boolean) - */ - @Override - public boolean applyStaticNats(List staticNats, boolean continueOnError) throws ResourceUnavailableException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getIpInNetwork(long, long) - */ - @Override - public String getIpInNetwork(long vmId, long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getIpInNetworkIncludingRemoved(long, long) - */ - @Override - public String getIpInNetworkIncludingRemoved(long vmId, long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPodIdForVlan(long) - */ - @Override - public Long getPodIdForVlan(long vlanDbId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listNetworkOfferingsForUpgrade(long) - */ - @Override - public List listNetworkOfferingsForUpgrade(long networkId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isSecurityGroupSupportedInNetwork(com.cloud.network.Network) - */ - @Override - public boolean isSecurityGroupSupportedInNetwork(Network network) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isProviderSupportServiceInNetwork(long, com.cloud.network.Network.Service, com.cloud.network.Network.Provider) - */ - @Override - public boolean isProviderSupportServiceInNetwork(long networkId, Service service, Provider provider) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isProviderEnabledInPhysicalNetwork(long, java.lang.String) - */ - @Override - public boolean isProviderEnabledInPhysicalNetwork(long physicalNetowrkId, String providerName) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNetworkTag(com.cloud.hypervisor.Hypervisor.HypervisorType, com.cloud.network.Network) - */ - @Override - public String getNetworkTag(HypervisorType hType, Network network) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getElementServices(com.cloud.network.Network.Provider) - */ - @Override - public List getElementServices(Provider provider) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#canElementEnableIndividualServices(com.cloud.network.Network.Provider) - */ - @Override - public boolean canElementEnableIndividualServices(Provider provider) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#areServicesSupportedInNetwork(long, com.cloud.network.Network.Service[]) - */ - @Override - public boolean areServicesSupportedInNetwork(long networkId, Service... services) { - return (_ntwkSrvcDao.areServicesSupportedInNetwork(networkId, services)); - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isNetworkSystem(com.cloud.network.Network) - */ - @Override - public boolean isNetworkSystem(Network network) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#reallocate(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DataCenterDeployment) - */ - @Override - public boolean reallocate(VirtualMachineProfile vm, DataCenterDeployment dest) throws InsufficientCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNetworkOfferingServiceCapabilities(com.cloud.offering.NetworkOffering, com.cloud.network.Network.Service) - */ - @Override - public Map getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPhysicalNetworkId(com.cloud.network.Network) - */ - @Override - public Long getPhysicalNetworkId(Network network) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getAllowSubdomainAccessGlobal() - */ - @Override - public boolean getAllowSubdomainAccessGlobal() { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isProviderForNetwork(com.cloud.network.Network.Provider, long) - */ - @Override - public boolean isProviderForNetwork(Provider provider, long networkId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isProviderForNetworkOffering(com.cloud.network.Network.Provider, long) - */ - @Override - public boolean isProviderForNetworkOffering(Provider provider, long networkOfferingId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#canProviderSupportServices(java.util.Map) - */ - @Override - public void canProviderSupportServices(Map> providersMap) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPhysicalNetworkInfo(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public List getPhysicalNetworkInfo(long dcId, HypervisorType hypervisorType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#canAddDefaultSecurityGroup() - */ - @Override - public boolean canAddDefaultSecurityGroup() { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listNetworkOfferingServices(long) - */ - @Override - public List listNetworkOfferingServices(long networkOfferingId) { - List supportedSvcs = new ArrayList(); - if (networkOfferingId != 2) { - supportedSvcs.add(Service.SourceNat); - } - return supportedSvcs; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#areServicesEnabledInZone(long, com.cloud.offering.NetworkOffering, java.util.List) - */ - @Override - public boolean areServicesEnabledInZone(long zoneId, NetworkOffering offering, List services) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getIpToServices(java.util.List, boolean, boolean) - */ - @Override - public Map> getIpToServices(List publicIps, boolean rulesRevoked, boolean includingFirewall) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getProviderToIpList(com.cloud.network.Network, java.util.Map) - */ - @Override - public Map> getProviderToIpList(Network network, Map> ipToServices) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#checkIpForService(com.cloud.network.IPAddressVO, com.cloud.network.Network.Service, java.lang.Long) - */ - @Override - public boolean checkIpForService(IPAddressVO ip, Service service, Long networkId) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#checkCapabilityForProvider(java.util.Set, com.cloud.network.Network.Service, com.cloud.network.Network.Capability, java.lang.String) - */ - @Override - public void checkCapabilityForProvider(Set providers, Service service, Capability cap, String capValue) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultUniqueProviderForService(java.lang.String) - */ - @Override - public Provider getDefaultUniqueProviderForService(String serviceName) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignSystemIp(long, com.cloud.user.Account, boolean, boolean) - */ - @Override - public IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) throws InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#handleSystemIpRelease(com.cloud.network.IpAddress) - */ - @Override - public boolean handleSystemIpRelease(IpAddress ip) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#checkNetworkPermissions(com.cloud.user.Account, com.cloud.network.Network) - */ - @Override - public void checkNetworkPermissions(Account owner, Network network) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#allocateDirectIp(com.cloud.vm.NicProfile, com.cloud.dc.DataCenter, com.cloud.vm.VirtualMachineProfile, com.cloud.network.Network, java.lang.String) - */ - @Override - public void allocateDirectIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, Network network, String requestedIp) throws InsufficientVirtualNetworkCapcityException, - InsufficientAddressCapacityException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultManagementTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultManagementTrafficLabel(long zoneId, HypervisorType hypervisorType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultStorageTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultStorageTrafficLabel(long zoneId, HypervisorType hypervisorType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultPublicTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultPublicTrafficLabel(long dcId, HypervisorType vmware) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultGuestTrafficLabel(long, com.cloud.hypervisor.Hypervisor.HypervisorType) - */ - @Override - public String getDefaultGuestTrafficLabel(long dcId, HypervisorType vmware) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getElementImplementingProvider(java.lang.String) - */ - @Override - public NetworkElement getElementImplementingProvider(String providerName) { - return new MockVpcVirtualRouterElement(); - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignSourceNatIpAddressToGuestNetwork(com.cloud.user.Account, com.cloud.network.Network) - */ - @Override - public PublicIp assignSourceNatIpAddressToGuestNetwork(Account owner, Network guestNetwork) throws InsufficientAddressCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getAccountNetworkDomain(long, long) - */ - @Override - public String getAccountNetworkDomain(long accountId, long zoneId) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getDefaultNetworkDomain() - */ - @Override - public String getDefaultNetworkDomain() { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNtwkOffDistinctProviders(long) - */ - @Override - public List getNtwkOffDistinctProviders(long ntwkOffId) { - List providers = new ArrayList(); - providers.add(Provider.VPCVirtualRouter); - return providers; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#allocateNic(com.cloud.vm.NicProfile, com.cloud.network.Network, java.lang.Boolean, int, com.cloud.vm.VirtualMachineProfile) - */ - @Override - public Pair allocateNic(NicProfile requested, Network network, Boolean isDefaultNic, int deviceId, VirtualMachineProfile vm) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#prepareNic(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext, long, com.cloud.network.NetworkVO) - */ - @Override - public NicProfile prepareNic(VirtualMachineProfile vmProfile, DeployDestination dest, ReservationContext context, long nicId, NetworkVO network) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#removeNic(com.cloud.vm.VirtualMachineProfile, com.cloud.vm.Nic) - */ - @Override - public void removeNic(VirtualMachineProfile vm, Nic nic) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#listPublicIpsAssignedToAccount(long, long, java.lang.Boolean) - */ - @Override - public List listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#associateIPToGuestNetwork(long, long, boolean) - */ - @Override - public IPAddressVO associateIPToGuestNetwork(long ipAddrId, long networkId, boolean releaseOnFailure) throws ResourceAllocationException, ResourceUnavailableException, InsufficientAddressCapacityException, - ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getNicProfile(com.cloud.vm.VirtualMachine, long, java.lang.String) - */ - @Override - public NicProfile getNicProfile(VirtualMachine vm, long networkId, String broadcastUri) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#setupDns(com.cloud.network.Network, com.cloud.network.Network.Provider) - */ - @Override - public boolean setupDns(Network network, Provider provider) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#releaseNic(com.cloud.vm.VirtualMachineProfile, com.cloud.vm.Nic) - */ - @Override - public void releaseNic(VirtualMachineProfile vmProfile, Nic nic) throws ConcurrentOperationException, ResourceUnavailableException { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#getPhysicalNtwksSupportingTrafficType(long, com.cloud.network.Networks.TrafficType) - */ - @Override - public List getPhysicalNtwksSupportingTrafficType(long zoneId, TrafficType trafficType) { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#isPrivateGateway(com.cloud.vm.Nic) - */ - @Override - public boolean isPrivateGateway(Nic guestNic) { - // TODO Auto-generated method stub - return false; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#createNicForVm(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.ReservationContext, com.cloud.vm.VirtualMachineProfileImpl, boolean) - */ - @Override - public NicProfile createNicForVm(Network network, NicProfile requested, ReservationContext context, VirtualMachineProfileImpl vmProfile, boolean prepare) - throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignVpnGatewayIpAddress(long, com.cloud.user.Account, long) - */ - @Override - public PublicIp assignVpnGatewayIpAddress(long dcId, Account owner, long vpcId) throws InsufficientAddressCapacityException, ConcurrentOperationException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#markPublicIpAsAllocated(com.cloud.network.IPAddressVO) - */ - @Override - public void markPublicIpAsAllocated(IPAddressVO addr) { - // TODO Auto-generated method stub - - } - - /* (non-Javadoc) - * @see com.cloud.network.NetworkManager#assignDedicateIpAddress(com.cloud.user.Account, java.lang.Long, java.lang.Long, long, boolean) - */ - @Override - public PublicIp assignDedicateIpAddress(Account owner, Long guestNtwkId, Long vpcId, long dcId, boolean isSourceNat) throws ConcurrentOperationException, InsufficientAddressCapacityException { - // TODO Auto-generated method stub - return null; - } - - /* (non-Javadoc) - * @see com.cloud.utils.component.Manager#configure(java.lang.String, java.util.Map) - */ - @Override - public boolean configure(String name, Map params) throws ConfigurationException { - // TODO Auto-generated method stub - return true; - } /* (non-Javadoc) * @see com.cloud.utils.component.Manager#start() @@ -1448,15 +119,36 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager{ return true; } + + + + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#configure(java.lang.String, java.util.Map) + */ + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + // TODO Auto-generated method stub + return false; + } + + + + + /* (non-Javadoc) * @see com.cloud.utils.component.Manager#stop() */ @Override public boolean stop() { // TODO Auto-generated method stub - return true; + return false; } + + + + /* (non-Javadoc) * @see com.cloud.utils.component.Manager#getName() */ @@ -1466,16 +158,1040 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager{ return null; } + + + + /* (non-Javadoc) - * @see com.cloud.network.NetworkService#allocateIP(com.cloud.user.Account, boolean, long) + * @see com.cloud.network.NetworkService#getIsolatedNetworksOwnedByAccountInZone(long, com.cloud.user.Account) */ @Override - public IpAddress allocateIP(Account ipOwner, boolean isSystem, long zoneId) throws ResourceAllocationException, InsufficientAddressCapacityException, ConcurrentOperationException { + public List getIsolatedNetworksOwnedByAccountInZone(long zoneId, Account owner) { // TODO Auto-generated method stub return null; } + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#allocateIP(com.cloud.user.Account, long, java.lang.Long) + */ + @Override + public IpAddress allocateIP(Account ipOwner, boolean isSystem, long networkId) throws ResourceAllocationException, + InsufficientAddressCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#releaseIpAddress(long) + */ + @Override + public boolean releaseIpAddress(long ipAddressId) throws InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#createGuestNetwork(com.cloud.api.commands.CreateNetworkCmd) + */ + @Override + public Network createGuestNetwork(CreateNetworkCmd cmd) throws InsufficientCapacityException, + ConcurrentOperationException, ResourceAllocationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#searchForNetworks(com.cloud.api.commands.ListNetworksCmd) + */ + @Override + public List searchForNetworks(ListNetworksCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#deleteNetwork(long) + */ + @Override + public boolean deleteNetwork(long networkId) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#restartNetwork(com.cloud.api.commands.RestartNetworkCmd, boolean) + */ + @Override + public boolean restartNetwork(RestartNetworkCmd cmd, boolean cleanup) throws ConcurrentOperationException, + ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getActiveNicsInNetwork(long) + */ + @Override + public int getActiveNicsInNetwork(long networkId) { + // TODO Auto-generated method stub + return 0; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getNetwork(long) + */ + @Override + public Network getNetwork(long networkId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getIp(long) + */ + @Override + public IpAddress getIp(long id) { + // TODO Auto-generated method stub + return null; + } + + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#updateGuestNetwork(long, java.lang.String, java.lang.String, com.cloud.user.Account, com.cloud.user.User, java.lang.String, java.lang.Long, java.lang.Boolean) + */ + @Override + public Network updateGuestNetwork(long networkId, String name, String displayText, Account callerAccount, + User callerUser, String domainSuffix, Long networkOfferingId, Boolean changeCidr) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#createPhysicalNetwork(java.lang.Long, java.lang.String, java.lang.String, java.util.List, java.lang.String, java.lang.Long, java.util.List, java.lang.String) + */ + @Override + public PhysicalNetwork createPhysicalNetwork(Long zoneId, String vnetRange, String networkSpeed, + List isolationMethods, String broadcastDomainRange, Long domainId, List tags, String name) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#searchPhysicalNetworks(java.lang.Long, java.lang.Long, java.lang.String, java.lang.Long, java.lang.Long, java.lang.String) + */ + @Override + public Pair, Integer> searchPhysicalNetworks(Long id, Long zoneId, String keyword, + Long startIndex, Long pageSize, String name) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#updatePhysicalNetwork(java.lang.Long, java.lang.String, java.util.List, java.lang.String, java.lang.String) + */ + @Override + public PhysicalNetwork updatePhysicalNetwork(Long id, String networkSpeed, List tags, + String newVnetRangeString, String state) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#deletePhysicalNetwork(java.lang.Long) + */ + @Override + public boolean deletePhysicalNetwork(Long id) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#listNetworkServices(java.lang.String) + */ + @Override + public List listNetworkServices(String providerName) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#addProviderToPhysicalNetwork(java.lang.Long, java.lang.String, java.lang.Long, java.util.List) + */ + @Override + public PhysicalNetworkServiceProvider addProviderToPhysicalNetwork(Long physicalNetworkId, String providerName, + Long destinationPhysicalNetworkId, List enabledServices) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#listNetworkServiceProviders(java.lang.Long, java.lang.String, java.lang.String, java.lang.Long, java.lang.Long) + */ + @Override + public Pair, Integer> listNetworkServiceProviders( + Long physicalNetworkId, String name, String state, Long startIndex, Long pageSize) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#updateNetworkServiceProvider(java.lang.Long, java.lang.String, java.util.List) + */ + @Override + public PhysicalNetworkServiceProvider updateNetworkServiceProvider(Long id, String state, + List enabledServices) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#deleteNetworkServiceProvider(java.lang.Long) + */ + @Override + public boolean deleteNetworkServiceProvider(Long id) throws ConcurrentOperationException, + ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getPhysicalNetwork(java.lang.Long) + */ + @Override + public PhysicalNetwork getPhysicalNetwork(Long physicalNetworkId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getCreatedPhysicalNetwork(java.lang.Long) + */ + @Override + public PhysicalNetwork getCreatedPhysicalNetwork(Long physicalNetworkId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getPhysicalNetworkServiceProvider(java.lang.Long) + */ + @Override + public PhysicalNetworkServiceProvider getPhysicalNetworkServiceProvider(Long providerId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getCreatedPhysicalNetworkServiceProvider(java.lang.Long) + */ + @Override + public PhysicalNetworkServiceProvider getCreatedPhysicalNetworkServiceProvider(Long providerId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#findPhysicalNetworkId(long, java.lang.String, com.cloud.network.Networks.TrafficType) + */ + @Override + public long findPhysicalNetworkId(long zoneId, String tag, TrafficType trafficType) { + // TODO Auto-generated method stub + return 0; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#addTrafficTypeToPhysicalNetwork(java.lang.Long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) + */ + @Override + public PhysicalNetworkTrafficType addTrafficTypeToPhysicalNetwork(Long physicalNetworkId, String trafficType, + String xenLabel, String kvmLabel, String vmwareLabel, String simulatorLabel, String vlan) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getPhysicalNetworkTrafficType(java.lang.Long) + */ + @Override + public PhysicalNetworkTrafficType getPhysicalNetworkTrafficType(Long id) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#updatePhysicalNetworkTrafficType(java.lang.Long, java.lang.String, java.lang.String, java.lang.String) + */ + @Override + public PhysicalNetworkTrafficType updatePhysicalNetworkTrafficType(Long id, String xenLabel, String kvmLabel, + String vmwareLabel) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#deletePhysicalNetworkTrafficType(java.lang.Long) + */ + @Override + public boolean deletePhysicalNetworkTrafficType(Long id) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#listTrafficTypes(java.lang.Long) + */ + @Override + public Pair, Integer> listTrafficTypes(Long physicalNetworkId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getExclusiveGuestNetwork(long) + */ + @Override + public Network getExclusiveGuestNetwork(long zoneId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#listTrafficTypeImplementor(org.apache.cloudstack.api.commands.ListTrafficTypeImplementorsCmd) + */ + @Override + public List> listTrafficTypeImplementor(ListTrafficTypeImplementorsCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long, com.cloud.user.Account) + */ + @Override + public List getIsolatedNetworksWithSourceNATOwnedByAccountInZone(long zoneId, Account owner) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#associateIPToNetwork(long, long) + */ + @Override + public IpAddress associateIPToNetwork(long ipId, long networkId) throws InsufficientAddressCapacityException, + ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#createPrivateNetwork(java.lang.String, java.lang.String, long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, long, java.lang.Long) + */ + @Override + public Network createPrivateNetwork(String networkName, String displayText, long physicalNetworkId, String vlan, + String startIp, String endIP, String gateway, String netmask, long networkOwnerId, Long vpcId) + throws ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignPublicIpAddress(long, java.lang.Long, com.cloud.user.Account, com.cloud.dc.Vlan.VlanType, java.lang.Long, java.lang.String, boolean) + */ + @Override + public PublicIp assignPublicIpAddress(long dcId, Long podId, Account owner, VlanType type, Long networkId, + String requestedIp, boolean isSystem) throws InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#disassociatePublicIpAddress(long, long, com.cloud.user.Account) + */ + @Override + public boolean disassociatePublicIpAddress(long id, long userId, Account caller) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#setupNetwork(com.cloud.user.Account, com.cloud.offerings.NetworkOfferingVO, com.cloud.deploy.DeploymentPlan, java.lang.String, java.lang.String, boolean) + */ + @Override + public List setupNetwork(Account owner, NetworkOffering offering, DeploymentPlan plan, String name, + String displayText, boolean isDefault) throws ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#setupNetwork(com.cloud.user.Account, com.cloud.offerings.NetworkOfferingVO, com.cloud.network.Network, com.cloud.deploy.DeploymentPlan, java.lang.String, java.lang.String, boolean, java.lang.Long, org.apache.cloudstack.acl.ControlledEntity.ACLType, java.lang.Boolean, java.lang.Long) + */ + @Override + public List setupNetwork(Account owner, NetworkOffering offering, Network predefined, + DeploymentPlan plan, String name, String displayText, boolean errorIfAlreadySetup, Long domainId, + ACLType aclType, Boolean subdomainAccess, Long vpcId) throws ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocate(com.cloud.vm.VirtualMachineProfile, java.util.List) + */ + @Override + public void allocate(VirtualMachineProfile vm, List> networks) + throws InsufficientCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#prepare(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext) + */ + @Override + public void prepare(VirtualMachineProfile profile, DeployDestination dest, + ReservationContext context) throws InsufficientCapacityException, ConcurrentOperationException, + ResourceUnavailableException { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#release(com.cloud.vm.VirtualMachineProfile, boolean) + */ + @Override + public void release(VirtualMachineProfile vmProfile, boolean forced) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#cleanupNics(com.cloud.vm.VirtualMachineProfile) + */ + @Override + public void cleanupNics(VirtualMachineProfile vm) { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#expungeNics(com.cloud.vm.VirtualMachineProfile) + */ + @Override + public void expungeNics(VirtualMachineProfile vm) { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#getNicProfiles(com.cloud.vm.VirtualMachine) + */ + @Override + public List getNicProfiles(VirtualMachine vm) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#applyRules(java.util.List, com.cloud.network.rules.FirewallRule.Purpose, com.cloud.network.NetworkRuleApplier, boolean) + */ + @Override + public boolean applyRules(List rules, Purpose purpose, NetworkRuleApplier applier, + boolean continueOnError) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#implementNetwork(long, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext) + */ + @Override + public Pair implementNetwork(long networkId, DeployDestination dest, + ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException, + InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#prepareNicForMigration(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination) + */ + @Override + public void prepareNicForMigration(VirtualMachineProfile vm, DeployDestination dest) { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#shutdownNetwork(long, com.cloud.vm.ReservationContext, boolean) + */ + @Override + public boolean shutdownNetwork(long networkId, ReservationContext context, boolean cleanupElements) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#destroyNetwork(long, com.cloud.vm.ReservationContext) + */ + @Override + public boolean destroyNetwork(long networkId, ReservationContext context) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#createGuestNetwork(long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, com.cloud.user.Account, java.lang.Long, com.cloud.network.PhysicalNetwork, long, org.apache.cloudstack.acl.ControlledEntity.ACLType, java.lang.Boolean, java.lang.Long) + */ + @Override + public Network createGuestNetwork(long networkOfferingId, String name, String displayText, String gateway, + String cidr, String vlanId, String networkDomain, Account owner, Long domainId, + PhysicalNetwork physicalNetwork, long zoneId, ACLType aclType, Boolean subdomainAccess, Long vpcId) + throws ConcurrentOperationException, InsufficientCapacityException, ResourceAllocationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#associateIpAddressListToAccount(long, long, long, java.lang.Long, com.cloud.network.Network) + */ + @Override + public boolean associateIpAddressListToAccount(long userId, long accountId, long zoneId, Long vlanId, + Network guestNetwork) throws InsufficientCapacityException, ConcurrentOperationException, + ResourceUnavailableException, ResourceAllocationException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#getPasswordResetProvider(com.cloud.network.Network) + */ + @Override + public UserDataServiceProvider getPasswordResetProvider(Network network) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#applyIpAssociations(com.cloud.network.Network, boolean) + */ + @Override + public boolean applyIpAssociations(Network network, boolean continueOnError) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#applyIpAssociations(com.cloud.network.Network, boolean, boolean, java.util.List) + */ + @Override + public boolean applyIpAssociations(Network network, boolean rulesRevoked, boolean continueOnError, + List publicIps) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#startNetwork(long, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext) + */ + @Override + public boolean startNetwork(long networkId, DeployDestination dest, ReservationContext context) + throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#markIpAsUnavailable(long) + */ + @Override + public IPAddressVO markIpAsUnavailable(long addrId) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#acquireGuestIpAddress(com.cloud.network.Network, java.lang.String) + */ + @Override + public String acquireGuestIpAddress(Network network, String requestedIp) { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#applyStaticNats(java.util.List, boolean) + */ + @Override + public boolean applyStaticNats(List staticNats, boolean continueOnError) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#reallocate(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DataCenterDeployment) + */ + @Override + public boolean reallocate(VirtualMachineProfile vm, DataCenterDeployment dest) + throws InsufficientCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignSystemIp(long, com.cloud.user.Account, boolean, boolean) + */ + @Override + public IpAddress assignSystemIp(long networkId, Account owner, boolean forElasticLb, boolean forElasticIp) + throws InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#handleSystemIpRelease(com.cloud.network.IpAddress) + */ + @Override + public boolean handleSystemIpRelease(IpAddress ip) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocateDirectIp(com.cloud.vm.NicProfile, com.cloud.dc.DataCenter, com.cloud.vm.VirtualMachineProfile, com.cloud.network.Network, java.lang.String) + */ + @Override + public void allocateDirectIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, + Network network, String requestedIp) throws InsufficientVirtualNetworkCapcityException, + InsufficientAddressCapacityException { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignSourceNatIpAddressToGuestNetwork(com.cloud.user.Account, com.cloud.network.Network) + */ + @Override + public PublicIp assignSourceNatIpAddressToGuestNetwork(Account owner, Network guestNetwork) + throws InsufficientAddressCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocateNic(com.cloud.vm.NicProfile, com.cloud.network.Network, java.lang.Boolean, int, com.cloud.vm.VirtualMachineProfile) + */ + @Override + public Pair allocateNic(NicProfile requested, Network network, Boolean isDefaultNic, + int deviceId, VirtualMachineProfile vm) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#prepareNic(com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext, long, com.cloud.network.NetworkVO) + */ + @Override + public NicProfile prepareNic(VirtualMachineProfile vmProfile, DeployDestination dest, + ReservationContext context, long nicId, NetworkVO network) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#removeNic(com.cloud.vm.VirtualMachineProfile, com.cloud.vm.Nic) + */ + @Override + public void removeNic(VirtualMachineProfile vm, Nic nic) { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#associateIPToGuestNetwork(long, long, boolean) + */ + @Override + public IPAddressVO associateIPToGuestNetwork(long ipAddrId, long networkId, boolean releaseOnFailure) + throws ResourceAllocationException, ResourceUnavailableException, InsufficientAddressCapacityException, + ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#setupDns(com.cloud.network.Network, com.cloud.network.Network.Provider) + */ + @Override + public boolean setupDns(Network network, Provider provider) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#releaseNic(com.cloud.vm.VirtualMachineProfile, com.cloud.vm.Nic) + */ + @Override + public void releaseNic(VirtualMachineProfile vmProfile, Nic nic) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#createNicForVm(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.ReservationContext, com.cloud.vm.VirtualMachineProfileImpl, boolean) + */ + @Override + public NicProfile createNicForVm(Network network, NicProfile requested, ReservationContext context, + VirtualMachineProfileImpl vmProfile, boolean prepare) + throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, + ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignVpnGatewayIpAddress(long, com.cloud.user.Account, long) + */ + @Override + public PublicIp assignVpnGatewayIpAddress(long dcId, Account owner, long vpcId) + throws InsufficientAddressCapacityException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#markPublicIpAsAllocated(com.cloud.network.IPAddressVO) + */ + @Override + public void markPublicIpAsAllocated(IPAddressVO addr) { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#assignDedicateIpAddress(com.cloud.user.Account, java.lang.Long, java.lang.Long, long, boolean) + */ + @Override + public PublicIp assignDedicateIpAddress(Account owner, Long guestNtwkId, Long vpcId, long dcId, boolean isSourceNat) + throws ConcurrentOperationException, InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#convertNetworkToNetworkProfile(long) + */ + @Override + public NetworkProfile convertNetworkToNetworkProfile(long networkId) { + // TODO Auto-generated method stub + return null; + } + + + + + /* (non-Javadoc) * @see com.cloud.network.NetworkManager#getNetworkLockTimeout() */ @@ -1485,6 +1201,88 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager{ return 0; } + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#cleanupIpResources(long, long, com.cloud.user.Account) + */ + @Override + public boolean cleanupIpResources(long addrId, long userId, Account caller) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#restartNetwork(java.lang.Long, com.cloud.user.Account, com.cloud.user.User, boolean) + */ + @Override + public boolean restartNetwork(Long networkId, Account callerAccount, User callerUser, boolean cleanup) + throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#shutdownNetworkElementsAndResources(com.cloud.vm.ReservationContext, boolean, com.cloud.network.NetworkVO) + */ + @Override + public boolean shutdownNetworkElementsAndResources(ReservationContext context, boolean b, NetworkVO network) { + // TODO Auto-generated method stub + return false; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#implementNetworkElementsAndResources(com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext, com.cloud.network.NetworkVO, com.cloud.offerings.NetworkOfferingVO) + */ + @Override + public void implementNetworkElementsAndResources(DeployDestination dest, ReservationContext context, + NetworkVO network, NetworkOfferingVO findById) throws ConcurrentOperationException, + InsufficientAddressCapacityException, ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#allocateIp(com.cloud.user.Account, boolean, com.cloud.user.Account, com.cloud.dc.DataCenter) + */ + @Override + public IpAddress allocateIp(Account ipOwner, boolean isSystem, Account caller, long callerId, DataCenter zone) + throws ConcurrentOperationException, ResourceAllocationException, InsufficientAddressCapacityException { + // TODO Auto-generated method stub + return null; + } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkManager#finalizeServicesAndProvidersForNetwork(com.cloud.offering.NetworkOffering, java.lang.Long) + */ + @Override + public Map finalizeServicesAndProvidersForNetwork(NetworkOffering offering, Long physicalNetworkId) { + // TODO Auto-generated method stub + return null; + } + @Override public boolean isNetworkInlineMode(Network network) { // TODO Auto-generated method stub @@ -1514,4 +1312,17 @@ public class MockNetworkManagerImpl implements NetworkManager, Manager{ // TODO Auto-generated method stub return null; } + + + + + + /* (non-Javadoc) + * @see com.cloud.network.NetworkService#getNetwork(java.lang.String) + */ + @Override + public Network getNetwork(String networkUuid) { + // TODO Auto-generated method stub + return null; + } } diff --git a/server/test/com/cloud/vpc/MockSite2SiteVpnServiceProvider.java b/server/test/com/cloud/vpc/MockSite2SiteVpnServiceProvider.java new file mode 100644 index 00000000000..8f5c0c1c1bf --- /dev/null +++ b/server/test/com/cloud/vpc/MockSite2SiteVpnServiceProvider.java @@ -0,0 +1,86 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.vpc; + +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.Site2SiteVpnConnection; +import com.cloud.network.element.Site2SiteVpnServiceProvider; + +@Local({Site2SiteVpnServiceProvider.class}) +public class MockSite2SiteVpnServiceProvider implements Site2SiteVpnServiceProvider { + + /* (non-Javadoc) + * @see com.cloud.utils.component.Adapter#configure(java.lang.String, java.util.Map) + */ + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Adapter#getName() + */ + @Override + public String getName() { + // TODO Auto-generated method stub + return "Site2SiteVpnServiceProvider"; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Adapter#start() + */ + @Override + public boolean start() { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Adapter#stop() + */ + @Override + public boolean stop() { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.network.element.Site2SiteVpnServiceProvider#startSite2SiteVpn(com.cloud.network.Site2SiteVpnConnection) + */ + @Override + public boolean startSite2SiteVpn(Site2SiteVpnConnection conn) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return true; + } + + /* (non-Javadoc) + * @see com.cloud.network.element.Site2SiteVpnServiceProvider#stopSite2SiteVpn(com.cloud.network.Site2SiteVpnConnection) + */ + @Override + public boolean stopSite2SiteVpn(Site2SiteVpnConnection conn) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return true; + } + +} diff --git a/server/test/com/cloud/vpc/MockVpcVirtualNetworkApplianceManager.java b/server/test/com/cloud/vpc/MockVpcVirtualNetworkApplianceManager.java new file mode 100644 index 00000000000..65ee33a65ab --- /dev/null +++ b/server/test/com/cloud/vpc/MockVpcVirtualNetworkApplianceManager.java @@ -0,0 +1,391 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package com.cloud.vpc; + +import java.util.List; +import java.util.Map; + +import javax.ejb.Local; +import javax.naming.ConfigurationException; + +import org.apache.cloudstack.api.command.admin.router.UpgradeRouterCmd; + +import com.cloud.deploy.DeployDestination; +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.network.Network; +import com.cloud.network.PublicIpAddress; +import com.cloud.network.RemoteAccessVpn; +import com.cloud.network.Site2SiteVpnConnection; +import com.cloud.network.VpcVirtualNetworkApplianceService; +import com.cloud.network.VpnUser; +import com.cloud.network.router.VirtualRouter; +import com.cloud.network.router.VpcVirtualNetworkApplianceManager; +import com.cloud.network.rules.FirewallRule; +import com.cloud.network.rules.StaticNat; +import com.cloud.network.vpc.PrivateGateway; +import com.cloud.network.vpc.StaticRouteProfile; +import com.cloud.network.vpc.Vpc; +import com.cloud.user.Account; +import com.cloud.user.User; +import com.cloud.uservm.UserVm; +import com.cloud.utils.component.Manager; +import com.cloud.vm.DomainRouterVO; +import com.cloud.vm.NicProfile; +import com.cloud.vm.VirtualMachineProfile; +import com.cloud.vm.VirtualMachineProfile.Param; + +@Local(value = {VpcVirtualNetworkApplianceManager.class, VpcVirtualNetworkApplianceService.class}) +public class MockVpcVirtualNetworkApplianceManager implements VpcVirtualNetworkApplianceManager, + VpcVirtualNetworkApplianceService, Manager { + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#sendSshKeysToHost(java.lang.Long, java.lang.String, java.lang.String) + */ + @Override + public boolean sendSshKeysToHost(Long hostId, String pubKey, String prvKey) { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#savePasswordToRouter(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachineProfile, java.util.List) + */ + @Override + public boolean savePasswordToRouter(Network network, NicProfile nic, VirtualMachineProfile profile, + List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#saveUserDataToRouter(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachineProfile, java.util.List) + */ + @Override + public boolean saveUserDataToRouter(Network network, NicProfile nic, VirtualMachineProfile profile, + List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#deployVirtualRouterInGuestNetwork(com.cloud.network.Network, com.cloud.deploy.DeployDestination, com.cloud.user.Account, java.util.Map, boolean) + */ + @Override + public List deployVirtualRouterInGuestNetwork(Network guestNetwork, DeployDestination dest, + Account owner, Map params, boolean isRedundant) throws InsufficientCapacityException, + ResourceUnavailableException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#startRemoteAccessVpn(com.cloud.network.Network, com.cloud.network.RemoteAccessVpn, java.util.List) + */ + @Override + public boolean startRemoteAccessVpn(Network network, RemoteAccessVpn vpn, List routers) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#deleteRemoteAccessVpn(com.cloud.network.Network, com.cloud.network.RemoteAccessVpn, java.util.List) + */ + @Override + public boolean deleteRemoteAccessVpn(Network network, RemoteAccessVpn vpn, List routers) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#associatePublicIP(com.cloud.network.Network, java.util.List, java.util.List) + */ + @Override + public boolean associatePublicIP(Network network, List ipAddress, + List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#applyFirewallRules(com.cloud.network.Network, java.util.List, java.util.List) + */ + @Override + public boolean applyFirewallRules(Network network, List rules, + List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#getRoutersForNetwork(long) + */ + @Override + public List getRoutersForNetwork(long networkId) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#applyVpnUsers(com.cloud.network.Network, java.util.List, java.util.List) + */ + @Override + public String[] applyVpnUsers(Network network, List users, List routers) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#stop(com.cloud.network.router.VirtualRouter, boolean, com.cloud.user.User, com.cloud.user.Account) + */ + @Override + public VirtualRouter stop(VirtualRouter router, boolean forced, User callingUser, Account callingAccount) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#getDnsBasicZoneUpdate() + */ + @Override + public String getDnsBasicZoneUpdate() { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#applyStaticNats(com.cloud.network.Network, java.util.List, java.util.List) + */ + @Override + public boolean applyStaticNats(Network network, List rules, + List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#applyDhcpEntry(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, java.util.List) + */ + @Override + public boolean applyDhcpEntry(Network config, NicProfile nic, VirtualMachineProfile vm, + DeployDestination dest, List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VirtualNetworkApplianceManager#applyUserData(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, java.util.List) + */ + @Override + public boolean applyUserData(Network config, NicProfile nic, VirtualMachineProfile vm, + DeployDestination dest, List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.VirtualNetworkApplianceService#startRouter(long, boolean) + */ + @Override + public VirtualRouter startRouter(long routerId, boolean reprogramNetwork) throws ConcurrentOperationException, + ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.VirtualNetworkApplianceService#rebootRouter(long, boolean) + */ + @Override + public VirtualRouter rebootRouter(long routerId, boolean reprogramNetwork) throws ConcurrentOperationException, + ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.VirtualNetworkApplianceService#upgradeRouter(com.cloud.api.commands.UpgradeRouterCmd) + */ + @Override + public VirtualRouter upgradeRouter(UpgradeRouterCmd cmd) { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.VirtualNetworkApplianceService#stopRouter(long, boolean) + */ + @Override + public VirtualRouter stopRouter(long routerId, boolean forced) throws ResourceUnavailableException, + ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.VirtualNetworkApplianceService#startRouter(long) + */ + @Override + public VirtualRouter startRouter(long id) throws ResourceUnavailableException, InsufficientCapacityException, + ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.VirtualNetworkApplianceService#destroyRouter(long, com.cloud.user.Account, java.lang.Long) + */ + @Override + public VirtualRouter destroyRouter(long routerId, Account caller, Long callerUserId) + throws ResourceUnavailableException, ConcurrentOperationException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#configure(java.lang.String, java.util.Map) + */ + @Override + public boolean configure(String name, Map params) throws ConfigurationException { + return true; + + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#start() + */ + @Override + public boolean start() { + return true; + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#stop() + */ + @Override + public boolean stop() { + return true; + + } + + /* (non-Javadoc) + * @see com.cloud.utils.component.Manager#getName() + */ + @Override + public String getName() { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.VpcVirtualNetworkApplianceService#addVpcRouterToGuestNetwork(com.cloud.network.router.VirtualRouter, com.cloud.network.Network, boolean) + */ + @Override + public boolean addVpcRouterToGuestNetwork(VirtualRouter router, Network network, boolean isRedundant) + throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.VpcVirtualNetworkApplianceService#removeVpcRouterFromGuestNetwork(com.cloud.network.router.VirtualRouter, com.cloud.network.Network, boolean) + */ + @Override + public boolean removeVpcRouterFromGuestNetwork(VirtualRouter router, Network network, boolean isRedundant) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#deployVirtualRouterInVpc(com.cloud.network.vpc.Vpc, com.cloud.deploy.DeployDestination, com.cloud.user.Account, java.util.Map) + */ + @Override + public List deployVirtualRouterInVpc(Vpc vpc, DeployDestination dest, Account owner, + Map params) throws InsufficientCapacityException, ConcurrentOperationException, + ResourceUnavailableException { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#applyNetworkACLs(com.cloud.network.Network, java.util.List, java.util.List) + */ + @Override + public boolean applyNetworkACLs(Network network, List rules, + List routers) throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#setupPrivateGateway(com.cloud.network.vpc.PrivateGateway, com.cloud.network.router.VirtualRouter) + */ + @Override + public boolean setupPrivateGateway(PrivateGateway gateway, VirtualRouter router) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#destroyPrivateGateway(com.cloud.network.vpc.PrivateGateway, com.cloud.network.router.VirtualRouter) + */ + @Override + public boolean destroyPrivateGateway(PrivateGateway gateway, VirtualRouter router) + throws ConcurrentOperationException, ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#applyStaticRoutes(java.util.List, java.util.List) + */ + @Override + public boolean applyStaticRoutes(List routes, List routers) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#startSite2SiteVpn(com.cloud.network.Site2SiteVpnConnection, com.cloud.network.router.VirtualRouter) + */ + @Override + public boolean startSite2SiteVpn(Site2SiteVpnConnection conn, VirtualRouter router) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see com.cloud.network.router.VpcVirtualNetworkApplianceManager#stopSite2SiteVpn(com.cloud.network.Site2SiteVpnConnection, com.cloud.network.router.VirtualRouter) + */ + @Override + public boolean stopSite2SiteVpn(Site2SiteVpnConnection conn, VirtualRouter router) + throws ResourceUnavailableException { + // TODO Auto-generated method stub + return false; + } + +} diff --git a/server/test/com/cloud/vpc/Site2SiteVpnTest.java b/server/test/com/cloud/vpc/Site2SiteVpnTest.java new file mode 100644 index 00000000000..dd6a4fab6a4 --- /dev/null +++ b/server/test/com/cloud/vpc/Site2SiteVpnTest.java @@ -0,0 +1,98 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +package com.cloud.vpc; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import junit.framework.Assert; + +import org.apache.log4j.Logger; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import com.cloud.configuration.DefaultInterceptorLibrary; +import com.cloud.network.dao.IPAddressDaoImpl; +import com.cloud.network.dao.Site2SiteCustomerGatewayDaoImpl; +import com.cloud.network.dao.Site2SiteVpnConnectionDao; +import com.cloud.network.dao.Site2SiteVpnConnectionDaoImpl; +import com.cloud.network.dao.Site2SiteVpnGatewayDaoImpl; +import com.cloud.network.element.Site2SiteVpnServiceProvider; +import com.cloud.network.vpc.dao.VpcDaoImpl; +import com.cloud.network.vpn.Site2SiteVpnManagerImpl; +import com.cloud.user.MockAccountManagerImpl; +import com.cloud.user.dao.AccountDaoImpl; +import com.cloud.utils.Pair; +import com.cloud.utils.component.ComponentLocator; +import com.cloud.utils.component.Inject; +import com.cloud.utils.component.MockComponentLocator; +import com.cloud.vpc.dao.MockConfigurationDaoImpl; + +public class Site2SiteVpnTest { + private MockComponentLocator locator; + private final static Logger s_logger = Logger.getLogger(Site2SiteVpnTest.class); + + private static void addDaos(MockComponentLocator locator) { + locator.addDao("AccountDao", AccountDaoImpl.class); + locator.addDao("Site2SiteCustomerGatewayDao", Site2SiteCustomerGatewayDaoImpl.class); + locator.addDao("Site2SiteVpnGatewayDao", Site2SiteVpnGatewayDaoImpl.class); + locator.addDao("Site2SiteVpnConnectionDao", Site2SiteVpnConnectionDaoImpl.class); + + locator.addDao("IPAddressDao", IPAddressDaoImpl.class); + locator.addDao("VpcDao", VpcDaoImpl.class); + locator.addDao("ConfiguratioDao", MockConfigurationDaoImpl.class); + + } + + private static void addManagers(MockComponentLocator locator) { + locator.addManager("AccountManager", MockAccountManagerImpl.class); + locator.addManager("VpcManager", MockVpcManagerImpl.class); + } + + @Before + public void setUp() { + locator = new MockComponentLocator("management-server"); + addDaos(locator); + addManagers(locator); + s_logger.info("Finished setUp"); + } + + @After + public void tearDown() throws Exception { + } + + + @Test + public void testInjected() throws Exception { + List>> list = + new ArrayList>>(); + list.add(new Pair>("Site2SiteVpnServiceProvider", MockSite2SiteVpnServiceProvider.class)); + locator.addAdapterChain(Site2SiteVpnServiceProvider.class, list); + s_logger.info("Finished add adapter"); + locator.makeActive(new DefaultInterceptorLibrary()); + s_logger.info("Finished make active"); + Site2SiteVpnManagerImpl vpnMgr = ComponentLocator.inject(Site2SiteVpnManagerImpl.class); + s_logger.info("Finished inject"); + Assert.assertTrue(vpnMgr.configure("Site2SiteVpnMgr",new HashMap()) ); + Assert.assertTrue(vpnMgr.start()); + + } + + +} diff --git a/server/test/resources/network-mgr-component.xml b/server/test/resources/network-mgr-component.xml new file mode 100644 index 00000000000..42d3c2ebdb1 --- /dev/null +++ b/server/test/resources/network-mgr-component.xml @@ -0,0 +1,184 @@ + + + + + + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/setup/db/db/schema-40to410.sql b/setup/db/db/schema-40to410.sql index c115135d006..a9d168d6eed 100644 --- a/setup/db/db/schema-40to410.sql +++ b/setup/db/db/schema-40to410.sql @@ -944,3 +944,5 @@ left join host_pod_ref on storage_pool.pod_id = host_pod_ref.id left join storage_pool_details on storage_pool_details.pool_id = storage_pool.id and storage_pool_details.value = 'true' left join op_host_capacity on storage_pool.id = op_host_capacity.host_id and op_host_capacity.capacity_type = 3 left join async_job on async_job.instance_id = storage_pool.id and async_job.instance_type = "StoragePool" and async_job.job_status = 0; + +INSERT IGNORE INTO `cloud`.`configuration` VALUES ('Advanced', 'DEFAULT', 'management-server', 'direct.agent.pool.size', '500', 'Default size for DirectAgentPool'); diff --git a/ui/index.jsp b/ui/index.jsp index a9b83e6fdd5..3fe6bad5f4a 100644 --- a/ui/index.jsp +++ b/ui/index.jsp @@ -220,7 +220,7 @@ under the License. -
+

diff --git a/ui/scripts/instanceWizard.js b/ui/scripts/instanceWizard.js index e4b1f31d427..b98147b2056 100644 --- a/ui/scripts/instanceWizard.js +++ b/ui/scripts/instanceWizard.js @@ -268,25 +268,30 @@ } if (selectedZoneObj.networktype == "Advanced") { //Advanced zone. Show network list. - var $networkStep = $(".step.network:visible .nothing-to-select"); + var $networkStep = $(".step.network:visible .nothing-to-select"); + var $networkStepContainer = $('.step.network:visible'); + if(args.initArgs.pluginForm != null && args.initArgs.pluginForm.name == "vpcTierInstanceWizard") { //from VPC Tier chart step5ContainerType = 'nothing-to-select'; $networkStep.find("#from_instance_page_1").hide(); $networkStep.find("#from_instance_page_2").hide(); $networkStep.find("#from_vpc_tier").text("tier " + args.context.networks[0].name); $networkStep.find("#from_vpc_tier").show(); - } - else { //from Instance page + } else { //from Instance page if(selectedZoneObj.securitygroupsenabled != true) { // Advanced SG-disabled zone step5ContainerType = 'select-network'; $networkStep.find("#from_instance_page_1").show(); $networkStep.find("#from_instance_page_2").show(); $networkStep.find("#from_vpc_tier").text(""); $networkStep.find("#from_vpc_tier").hide(); + } else { // Advanced SG-enabled zone + step5ContainerType = 'select-advanced-sg'; } - else { // Advanced SG-enabled zone - step5ContainerType = 'select-security-group'; - } + + if ($networkStepContainer.hasClass('next-use-security-groups')) { + $networkStepContainer.removeClass('repeat next-use-security-groups loaded'); + step5ContainerType = 'select-security-group'; + } } } else { //Basic zone. Show securigy group list or nothing(when no SecurityGroup service in guest network) @@ -320,7 +325,7 @@ } //step5ContainerType = 'nothing-to-select'; //for testing only, comment it out before checking in - if(step5ContainerType == 'select-network') { + if(step5ContainerType == 'select-network' || step5ContainerType == 'select-advanced-sg') { var defaultNetworkArray = [], optionalNetworkArray = []; var networkData = { zoneId: args.currentData.zoneid @@ -379,6 +384,9 @@ }); //get network offerings (end) *** + if (step5ContainerType == 'select-advanced-sg') { + $networkStepContainer.addClass('repeat next-use-security-groups'); + } args.response.success({ type: 'select-network', @@ -545,41 +553,38 @@ if(checkedSecurityGroupIdArray.length > 0) array1.push("&securitygroupids=" + checkedSecurityGroupIdArray.join(",")); - - /* - if(selectedZoneObj.networktype == "Advanced" && selectedZoneObj.securitygroupsenabled == true) { // Advanced SG-enabled zone - var networkData = { - zoneId: selectedZoneObj.id, - type: 'Shared', - supportedServices: 'SecurityGroup' - }; - if (!(cloudStack.context.projects && cloudStack.context.projects[0])) { - networkData.domainid = g_domainid; - networkData.account = g_account; - } + + if(selectedZoneObj.networktype == "Advanced" && selectedZoneObj.securitygroupsenabled == true) { // Advanced SG-enabled zone + var array2 = []; + var myNetworks = $('.multi-wizard:visible form').data('my-networks'); //widget limitation: If using an advanced security group zone, get the guest networks like this + var defaultNetworkId = $('.multi-wizard:visible form').find('input[name=defaultNetwork]:checked').val(); + + var checkedNetworkIdArray; + if(typeof(myNetworks) == "object" && myNetworks.length != null) { //myNetworks is an array of string, e.g. ["203", "202"], + checkedNetworkIdArray = myNetworks; + } + else if(typeof(myNetworks) == "string" && myNetworks.length > 0) { //myNetworks is a string, e.g. "202" + checkedNetworkIdArray = []; + checkedNetworkIdArray.push(myNetworks); + } + else { // typeof(myNetworks) == null + checkedNetworkIdArray = []; + } - var selectedNetworkObj = null; - $.ajax({ - url: createURL('listNetworks'), - data: networkData, - async: false, - success: function(json) { - var networks = json.listnetworksresponse.network; - if(networks != null && networks.length > 0) { - selectedNetworkObj = networks[0]; //each Advanced SG-enabled zone has only one guest network that is Shared and has SecurityGroup service - } + //add default network first + if(defaultNetworkId != null && defaultNetworkId.length > 0 && defaultNetworkId != 'new-network') + array2.push(defaultNetworkId); + + //then, add other checked networks + if(checkedNetworkIdArray.length > 0) { + for(var i=0; i < checkedNetworkIdArray.length; i++) { + if(checkedNetworkIdArray[i] != defaultNetworkId) //exclude defaultNetworkId that has been added to array2 + array2.push(checkedNetworkIdArray[i]); } - }); - if(selectedNetworkObj != null) { - array1.push("&networkIds=" + selectedNetworkObj.id); } - else { - alert('unable to find any Shared network with SecurityGroup service. Therefore, unable to deploy VM in this Advanced SecurityGroup-enabled zone.'); - return; - } - } - */ - + + array1.push("&networkIds=" + array2.join(",")); + } } else if (step5ContainerType == 'nothing-to-select') { if(args.context.networks != null) { //from VPC tier diff --git a/ui/scripts/ui-custom/instanceWizard.js b/ui/scripts/ui-custom/instanceWizard.js index d2724a524f3..f2cfd9ced53 100644 --- a/ui/scripts/ui-custom/instanceWizard.js +++ b/ui/scripts/ui-custom/instanceWizard.js @@ -598,6 +598,8 @@ response: { success: function(args) { var vpcs = args.data.vpcs; + var addClass = args.addClass; + var removeClass = args.removeClass; // Populate VPC drop-down $vpcSelect.html(''); @@ -753,7 +755,8 @@ ) ); - $targetStep.addClass('loaded'); + if (!$targetStep.hasClass('repeat') && + !$targetStep.hasClass('always-load')) $targetStep.addClass('loaded'); } // Show launch vm button if last step @@ -806,6 +809,14 @@ //step 5 - select network if($activeStep.find('.wizard-step-conditional.select-network:visible').size() > 0) { + var data = $activeStep.data('my-networks'); + + if (!data) { + $activeStep.closest('form').data('my-networks', cloudStack.serializeForm( + $activeStep.closest('form') + )['my-networks']); + } + if($activeStep.find('input[type=checkbox]:checked').size() == 0) { //if no checkbox is checked cloudStack.dialog.notice({ message: 'message.step.4.continue' }); return false; @@ -828,7 +839,11 @@ } } - showStep($steps.filter(':visible').index() + 2); + if ($activeStep.hasClass('repeat')) { + showStep($steps.filter(':visible').index() + 1); + } else { + showStep($steps.filter(':visible').index() + 2); + } return false; } diff --git a/utils/src/com/cloud/utils/exception/CSExceptionErrorCode.java b/utils/src/com/cloud/utils/exception/CSExceptionErrorCode.java index 1a0969957a6..e794ea5d9c4 100755 --- a/utils/src/com/cloud/utils/exception/CSExceptionErrorCode.java +++ b/utils/src/com/cloud/utils/exception/CSExceptionErrorCode.java @@ -64,6 +64,7 @@ public class CSExceptionErrorCode { ExceptionErrorCodeMap.put("com.cloud.exception.UnsupportedServiceException", 4390); ExceptionErrorCodeMap.put("com.cloud.exception.VirtualMachineMigrationException", 4395); ExceptionErrorCodeMap.put("com.cloud.async.AsyncCommandQueued", 4540); + ExceptionErrorCodeMap.put("com.cloud.exception.RequestLimitException", 4545); // Have a special error code for ServerApiException when it is // thrown in a standalone manner when failing to detect any of the above