cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From h...@apache.org
Subject [3/4] CLOUDSTACK-6845 : NuageVsp Network plugin
Date Mon, 21 Jul 2014 08:50:19 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/DeleteNuageVspDeviceCmd.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/DeleteNuageVspDeviceCmd.java b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/DeleteNuageVspDeviceCmd.java
new file mode 100644
index 0000000..ae81c84
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/DeleteNuageVspDeviceCmd.java
@@ -0,0 +1,105 @@
+//
+// 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.api.commands;
+
+import javax.inject.Inject;
+
+import org.apache.cloudstack.api.APICommand;
+import org.apache.cloudstack.api.ApiErrorCode;
+import org.apache.cloudstack.api.BaseAsyncCmd;
+import org.apache.cloudstack.api.Parameter;
+import org.apache.cloudstack.api.ServerApiException;
+import org.apache.cloudstack.api.response.SuccessResponse;
+import org.apache.cloudstack.context.CallContext;
+
+import com.cloud.api.response.NuageVspDeviceResponse;
+import com.cloud.event.EventTypes;
+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.network.manager.NuageVspManager;
+import com.cloud.utils.exception.CloudRuntimeException;
+
+@APICommand(name = "deleteNuageVspDevice", responseObject = SuccessResponse.class, description = "delete a nuage vsp device")
+public class DeleteNuageVspDeviceCmd extends BaseAsyncCmd {
+    private static final String s_name = "deletenuagevspdeviceresponse";
+    @Inject
+    NuageVspManager _nuageVspManager;
+
+    /////////////////////////////////////////////////////
+    //////////////// API parameters /////////////////////
+    /////////////////////////////////////////////////////
+
+    @Parameter(name = VspConstants.NUAGE_VSP_DEVICE_ID, type = CommandType.UUID, entityType = NuageVspDeviceResponse.class, required = true, description = "Nuage device ID")
+    private Long nuageVspDeviceId;
+
+    /////////////////////////////////////////////////////
+    /////////////////// Accessors ///////////////////////
+    /////////////////////////////////////////////////////
+
+    public Long getNuageVspDeviceId() {
+        return nuageVspDeviceId;
+    }
+
+    /////////////////////////////////////////////////////
+    /////////////// API Implementation///////////////////
+    /////////////////////////////////////////////////////
+
+    @Override
+    public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException {
+        try {
+            boolean result = _nuageVspManager.deleteNuageVspDevice(this);
+            if (result) {
+                SuccessResponse response = new SuccessResponse(getCommandName());
+                response.setResponseName(getCommandName());
+                this.setResponseObject(response);
+            } else {
+                throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to delete Nuage device.");
+            }
+        } catch (InvalidParameterValueException invalidParamExcp) {
+            throw new ServerApiException(ApiErrorCode.PARAM_ERROR, invalidParamExcp.getMessage());
+        } catch (CloudRuntimeException runtimeExcp) {
+            throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, runtimeExcp.getMessage());
+        }
+    }
+
+    @Override
+    public String getCommandName() {
+        return s_name;
+    }
+
+    @Override
+    public long getEntityOwnerId() {
+        return CallContext.current().getCallingAccount().getId();
+    }
+
+    @Override
+    public String getEventType() {
+        return EventTypes.EVENT_EXTERNAL_VSP_VSD_DELETE;
+    }
+
+    @Override
+    public String getEventDescription() {
+        return "Deleting Nuage VSD";
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/IssueNuageVspResourceRequestCmd.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/IssueNuageVspResourceRequestCmd.java b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/IssueNuageVspResourceRequestCmd.java
new file mode 100644
index 0000000..f0e3ff8
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/IssueNuageVspResourceRequestCmd.java
@@ -0,0 +1,215 @@
+//
+// 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.api.commands;
+
+import java.util.List;
+
+import javax.inject.Inject;
+
+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.ServerApiException;
+import org.apache.cloudstack.api.response.NetworkOfferingResponse;
+import org.apache.cloudstack.api.response.PhysicalNetworkResponse;
+import org.apache.cloudstack.api.response.ZoneResponse;
+import org.apache.cloudstack.context.CallContext;
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.api.VspResourceAnswer;
+import com.cloud.agent.api.VspResourceCommand;
+import com.cloud.api.response.NuageVspResourceResponse;
+import com.cloud.domain.dao.DomainDao;
+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.host.HostVO;
+import com.cloud.host.dao.HostDao;
+import com.cloud.network.NuageVspDeviceVO;
+import com.cloud.network.dao.NuageVspDao;
+import com.cloud.offering.NetworkOffering;
+import com.cloud.user.Account;
+import com.cloud.user.AccountManager;
+
+@APICommand(name = "issueNuageVspResourceRequest", responseObject = NuageVspResourceResponse.class, description = "Issues a Nuage VSP REST API resource request")
+public class IssueNuageVspResourceRequestCmd extends BaseCmd {
+    private static final Logger s_logger = Logger.getLogger(IssueNuageVspResourceRequestCmd.class.getName());
+    private static final String s_name = "nuagevspresourceresponse";
+
+    @Inject
+    protected AccountManager _accountMgr;
+    @Inject
+    protected DomainDao _domainDao;
+    @Inject
+    protected NuageVspDao _nuageConfigDao;
+    @Inject
+    HostDao _hostDao;
+    @Inject
+    AgentManager _agentMgr;
+
+    /////////////////////////////////////////////////////
+    //////////////// API parameters /////////////////////
+    /////////////////////////////////////////////////////
+
+    @Parameter(name = ApiConstants.NETWORK_OFFERING_ID, type = CommandType.UUID, entityType = NetworkOfferingResponse.class, required = true, description = "the network offering id")
+    private Long networkOfferingId;
+
+    @Parameter(name = ApiConstants.ZONE_ID, type = CommandType.UUID, entityType = ZoneResponse.class, required = true, description = "the Zone ID for the network")
+    private Long zoneId;
+
+    @Parameter(name = ApiConstants.PHYSICAL_NETWORK_ID, type = CommandType.UUID, entityType = PhysicalNetworkResponse.class, description = "the ID of the physical network in to which Nuage VSP Controller is added")
+    private Long physicalNetworkId;
+
+    @Parameter(name = VspConstants.NUAGE_VSP_API_METHOD, type = CommandType.STRING, required = true, description = "the Nuage VSP REST API method type")
+    private String method;
+
+    @Parameter(name = VspConstants.NUAGE_VSP_API_RESOURCE, type = CommandType.STRING, required = true, description = "the resource in Nuage VSP")
+    private String resource;
+
+    @Parameter(name = VspConstants.NUAGE_VSP_API_RESOURCE_ID, type = CommandType.STRING, description = "the ID of the resource in Nuage VSP")
+    private String resourceId;
+
+    @Parameter(name = VspConstants.NUAGE_VSP_API_CHILD_RESOURCE, type = CommandType.STRING, description = "the child resource in Nuage VSP")
+    private String childResource;
+
+    @Parameter(name = VspConstants.NUAGE_VSP_API_RESOURCE_FILTER, type = CommandType.STRING, description = "the resource filter in Nuage VSP")
+    private String resourceFilter;
+
+    /////////////////////////////////////////////////////
+    /////////////// API Implementation///////////////////
+    /////////////////////////////////////////////////////
+
+    public Long getNetworkOfferingId() {
+        return networkOfferingId;
+    }
+
+    public Long getZoneId() {
+        Long physicalNetworkId = getPhysicalNetworkId();
+
+        if (physicalNetworkId == null && zoneId == null) {
+            throw new InvalidParameterValueException("Zone id is required");
+        }
+
+        return zoneId;
+    }
+
+    public Long getPhysicalNetworkId() {
+        if (physicalNetworkId != null) {
+            return physicalNetworkId;
+        }
+
+        NetworkOffering offering = _entityMgr.findById(NetworkOffering.class, networkOfferingId);
+        if (offering == null) {
+            throw new InvalidParameterValueException("Unable to find network offering by id " + networkOfferingId);
+        }
+
+        if (zoneId == null) {
+            throw new InvalidParameterValueException("ZoneId is required as physicalNetworkId is null");
+        }
+        return _networkService.findPhysicalNetworkId(zoneId, offering.getTags(), offering.getTrafficType());
+    }
+
+    public String getMethod() {
+        return method;
+    }
+
+    public void setMethod(String method) {
+        this.method = method;
+    }
+
+    public String getResource() {
+        return resource;
+    }
+
+    public void setResource(String resource) {
+        this.resource = resource;
+    }
+
+    public String getResourceId() {
+        return resourceId;
+    }
+
+    public void setResourceId(String resourceId) {
+        this.resourceId = resourceId;
+    }
+
+    public String getChildResource() {
+        return childResource;
+    }
+
+    public void setChildResource(String childResource) {
+        this.childResource = childResource;
+    }
+
+    public String getResourceFilter() {
+        return resourceFilter;
+    }
+
+    public void setResourceFilter(String resourceFilter) {
+        this.resourceFilter = resourceFilter;
+    }
+
+    @Override
+    public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException {
+        long accountId = CallContext.current().getCallingAccount().getAccountId();
+        Account account = _accountMgr.getAccount(accountId);
+
+        List<NuageVspDeviceVO> nuageVspDevices = _nuageConfigDao.listByPhysicalNetwork(getPhysicalNetworkId());
+        if (nuageVspDevices != null && (!nuageVspDevices.isEmpty())) {
+            NuageVspDeviceVO config = nuageVspDevices.iterator().next();
+            HostVO nuageVspHost = _hostDao.findById(config.getHostId());
+            VspResourceCommand cmd = new VspResourceCommand(method, resource, resourceId, childResource, null, resourceFilter, null, null);
+            VspResourceAnswer answer = (VspResourceAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+            if (answer == null || !answer.getResult()) {
+                s_logger.error("VspResourceCommand failed");
+                if ((null != answer) && (null != answer.getDetails())) {
+                    throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, answer.getDetails());
+                }
+            } else {
+                NuageVspResourceResponse response = new NuageVspResourceResponse();
+                response.setResourceInfo(StringUtils.isBlank(answer.getResourceInfo()) ? "" : answer.getResourceInfo());
+                response.setObjectName("nuagevspresource");
+                response.setResponseName(getCommandName());
+                this.setResponseObject(response);
+            }
+        } else {
+            String errorMessage = "No Nuage VSP Controller configured on physical network " + getPhysicalNetworkId();
+            s_logger.error(errorMessage);
+            throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, errorMessage);
+        }
+    }
+
+    @Override
+    public String getCommandName() {
+        return s_name;
+    }
+
+    @Override
+    public long getEntityOwnerId() {
+        return CallContext.current().getCallingAccount().getId();
+    }
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/ListNuageVspDevicesCmd.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/ListNuageVspDevicesCmd.java b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/ListNuageVspDevicesCmd.java
new file mode 100644
index 0000000..46797e0
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/ListNuageVspDevicesCmd.java
@@ -0,0 +1,107 @@
+//
+// 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.api.commands;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.inject.Inject;
+
+import org.apache.cloudstack.api.APICommand;
+import org.apache.cloudstack.api.ApiConstants;
+import org.apache.cloudstack.api.ApiErrorCode;
+import org.apache.cloudstack.api.BaseListCmd;
+import org.apache.cloudstack.api.Parameter;
+import org.apache.cloudstack.api.ServerApiException;
+import org.apache.cloudstack.api.response.ListResponse;
+import org.apache.cloudstack.api.response.PhysicalNetworkResponse;
+
+import com.cloud.api.response.NuageVspDeviceResponse;
+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.network.NuageVspDeviceVO;
+import com.cloud.network.manager.NuageVspManager;
+import com.cloud.utils.exception.CloudRuntimeException;
+
+@APICommand(name = "listNuageVspDevices", responseObject = NuageVspDeviceResponse.class, description = "Lists Nuage VSP devices")
+public class ListNuageVspDevicesCmd extends BaseListCmd {
+    private static final String s_name = "listnuagevspdeviceresponse";
+    @Inject
+    NuageVspManager _nuageVspManager;
+
+    /////////////////////////////////////////////////////
+    //////////////// API parameters /////////////////////
+    /////////////////////////////////////////////////////
+
+    @Parameter(name = ApiConstants.PHYSICAL_NETWORK_ID, type = CommandType.UUID, entityType = PhysicalNetworkResponse.class, description = "the Physical Network ID")
+    private Long physicalNetworkId;
+
+    @Parameter(name = VspConstants.NUAGE_VSP_DEVICE_ID, type = CommandType.UUID, entityType = NuageVspDeviceResponse.class, description = "the Nuage VSP device ID")
+    private Long nuageVspDeviceId;
+
+    /////////////////////////////////////////////////////
+    /////////////////// Accessors ///////////////////////
+    /////////////////////////////////////////////////////
+
+    public Long getNuageVspDeviceId() {
+        return nuageVspDeviceId;
+    }
+
+    public Long getPhysicalNetworkId() {
+        return physicalNetworkId;
+    }
+
+    /////////////////////////////////////////////////////
+    /////////////// API Implementation///////////////////
+    /////////////////////////////////////////////////////
+
+    @Override
+    public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException {
+        try {
+            List<NuageVspDeviceVO> nuageDevices = _nuageVspManager.listNuageVspDevices(this);
+            ListResponse<NuageVspDeviceResponse> response = new ListResponse<NuageVspDeviceResponse>();
+            List<NuageVspDeviceResponse> nuageDevicesResponse = new ArrayList<NuageVspDeviceResponse>();
+
+            if (nuageDevices != null && !nuageDevices.isEmpty()) {
+                for (NuageVspDeviceVO nuageDeviceVO : nuageDevices) {
+                    NuageVspDeviceResponse nuageDeviceResponse = _nuageVspManager.createNuageVspDeviceResponse(nuageDeviceVO);
+                    nuageDevicesResponse.add(nuageDeviceResponse);
+                }
+            }
+
+            response.setResponses(nuageDevicesResponse);
+            response.setResponseName(getCommandName());
+            this.setResponseObject(response);
+        } catch (InvalidParameterValueException invalidParamExcp) {
+            throw new ServerApiException(ApiErrorCode.PARAM_ERROR, invalidParamExcp.getMessage());
+        } catch (CloudRuntimeException runtimeExcp) {
+            throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, runtimeExcp.getMessage());
+        }
+    }
+
+    @Override
+    public String getCommandName() {
+        return s_name;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/VspConstants.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/VspConstants.java b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/VspConstants.java
new file mode 100644
index 0000000..2372890
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/api/commands/VspConstants.java
@@ -0,0 +1,35 @@
+//
+// 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.api.commands;
+
+public class VspConstants {
+    public static final String NUAGE_VSP_DEVICE_ID = "vspdeviceid";
+    public static final String NUAGE_VSP_DEVICE_NAME = "nuagedevicename";
+    public static final String NUAGE_VSP_API_PORT = "port";
+    public static final String NUAGE_VSP_API_VERSION = "apiversion";
+    public static final String NUAGE_VSP_API_RETRY_COUNT = "retrycount";
+    public static final String NUAGE_VSP_API_RETRY_INTERVAL = "retryinterval";
+    public static final String NUAGE_VSP_API_METHOD = "method";
+    public static final String NUAGE_VSP_API_RESOURCE = "resource";
+    public static final String NUAGE_VSP_API_RESOURCE_ID = "resourceid";
+    public static final String NUAGE_VSP_API_CHILD_RESOURCE = "childresource";
+    public static final String NUAGE_VSP_API_RESOURCE_FILTER = "resourcefilter";
+    public static final String NUAGE_VSP_API_RESOURCE_INFO = "resourceinfo";
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspDeviceResponse.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspDeviceResponse.java b/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspDeviceResponse.java
new file mode 100644
index 0000000..b0bbcc8
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspDeviceResponse.java
@@ -0,0 +1,105 @@
+//
+// 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.api.response;
+
+import com.cloud.api.commands.VspConstants;
+import com.cloud.network.NuageVspDeviceVO;
+import org.apache.cloudstack.api.ApiConstants;
+import org.apache.cloudstack.api.BaseResponse;
+import org.apache.cloudstack.api.EntityReference;
+
+import com.cloud.serializer.Param;
+import com.google.gson.annotations.SerializedName;
+
+@EntityReference(value = NuageVspDeviceVO.class)
+public class NuageVspDeviceResponse extends BaseResponse {
+    @SerializedName(VspConstants.NUAGE_VSP_DEVICE_ID)
+    @Param(description = "the device id of the Nuage VSD")
+    private String id;
+
+    @SerializedName(ApiConstants.PHYSICAL_NETWORK_ID)
+    @Param(description = "the ID of the physical network to which this Nuage VSP belongs to")
+    private String physicalNetworkId;
+
+    @SerializedName(ApiConstants.PROVIDER)
+    @Param(description = "the service provider name corresponding to this Nuage VSP device")
+    private String providerName;
+
+    @SerializedName(VspConstants.NUAGE_VSP_DEVICE_NAME)
+    @Param(description = "the name of the Nuage VSP device")
+    private String deviceName;
+
+    @SerializedName(VspConstants.NUAGE_VSP_API_PORT)
+    @Param(description = "the port to communicate to Nuage VSD")
+    private int port;
+
+    @SerializedName(ApiConstants.HOST_NAME)
+    @Param(description = "the hostname of the Nuage VSD")
+    private String hostName;
+
+    @SerializedName(VspConstants.NUAGE_VSP_API_VERSION)
+    @Param(description = "the version of the API to use to communicate to Nuage VSD")
+    private String apiVersion;
+
+    @SerializedName(VspConstants.NUAGE_VSP_API_RETRY_COUNT)
+    @Param(description = "the number of retries on failure to communicate to Nuage VSD")
+    private int apiRetryCount;
+
+    @SerializedName(VspConstants.NUAGE_VSP_API_RETRY_INTERVAL)
+    @Param(description = "the time to wait after failure before retrying to communicate to Nuage VSD")
+    private long apiRetryInterval;
+
+    public void setId(String vspDetailsId) {
+        this.id = vspDetailsId;
+    }
+
+    public void setPhysicalNetworkId(String physicalNetworkId) {
+        this.physicalNetworkId = physicalNetworkId;
+    }
+
+    public void setProviderName(String providerName) {
+        this.providerName = providerName;
+    }
+
+    public void setDeviceName(String deviceName) {
+        this.deviceName = deviceName;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+
+    public void setHostName(String hostName) {
+        this.hostName = hostName;
+    }
+
+    public void setApiVersion(String apiVersion) {
+        this.apiVersion = apiVersion;
+    }
+
+    public void setApiRetryCount(int apiRetryCount) {
+        this.apiRetryCount = apiRetryCount;
+    }
+
+    public void setApiRetryInterval(long apiRetryInterval) {
+        this.apiRetryInterval = apiRetryInterval;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspResourceResponse.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspResourceResponse.java b/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspResourceResponse.java
new file mode 100644
index 0000000..8e620ed
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/api/response/NuageVspResourceResponse.java
@@ -0,0 +1,41 @@
+//
+// 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.api.response;
+
+import com.cloud.api.commands.VspConstants;
+import org.apache.cloudstack.api.BaseResponse;
+
+import com.cloud.serializer.Param;
+import com.google.gson.annotations.SerializedName;
+
+public class NuageVspResourceResponse extends BaseResponse {
+    @SerializedName(VspConstants.NUAGE_VSP_API_RESOURCE_INFO)
+    @Param(description = "the details of the Nuage VSP resource")
+    private String resourceInfo;
+
+    public String getResourceInfo() {
+        return resourceInfo;
+    }
+
+    public void setResourceInfo(String resourceInfo) {
+        this.resourceInfo = resourceInfo;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/network/NuageVspDeviceVO.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/network/NuageVspDeviceVO.java b/plugins/network-elements/nuage-vsp/src/com/cloud/network/NuageVspDeviceVO.java
new file mode 100644
index 0000000..00cb1e4
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/network/NuageVspDeviceVO.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.network;
+
+import java.util.UUID;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+import org.apache.cloudstack.api.InternalIdentity;
+
+@Entity
+@Table(name = "external_nuage_vsp_devices")
+public class NuageVspDeviceVO implements InternalIdentity {
+
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private long id;
+
+    @Column(name = "uuid")
+    private String uuid;
+
+    @Column(name = "host_id")
+    private long hostId;
+
+    @Column(name = "physical_network_id")
+    private long physicalNetworkId;
+
+    @Column(name = "provider_name")
+    private String providerName;
+
+    @Column(name = "device_name")
+    private String deviceName;
+
+    public NuageVspDeviceVO() {
+        this.uuid = UUID.randomUUID().toString();
+    }
+
+    public NuageVspDeviceVO(long hostId, long physicalNetworkId,
+           String providerName, String deviceName){
+        super();
+        this.hostId = hostId;
+        this.physicalNetworkId = physicalNetworkId;
+        this.providerName = providerName;
+        this.deviceName = deviceName;
+        this.uuid = UUID.randomUUID().toString();
+    }
+
+    @Override
+    public long getId() {
+        return id;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+
+    public long getHostId() {
+        return hostId;
+    }
+
+    public long getPhysicalNetworkId() {
+        return physicalNetworkId;
+    }
+
+    public String getProviderName() {
+        return providerName;
+    }
+
+    public String getDeviceName() {
+        return deviceName;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDao.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDao.java b/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDao.java
new file mode 100644
index 0000000..6cf7e1a
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDao.java
@@ -0,0 +1,36 @@
+//
+// 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.dao;
+
+import com.cloud.network.NuageVspDeviceVO;
+import com.cloud.utils.db.GenericDao;
+
+import java.util.List;
+
+public interface NuageVspDao extends GenericDao<NuageVspDeviceVO, Long> {
+    /**
+     * List all the Nuage Vsp devices added in to this physical network
+     *
+     * @param physicalNetworkId physical Network Id
+     * @return list of NuageVspDeviceVO for this physical network.
+     */
+    List<NuageVspDeviceVO> listByPhysicalNetwork(long physicalNetworkId);
+
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDaoImpl.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDaoImpl.java b/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDaoImpl.java
new file mode 100644
index 0000000..bc55f43
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/network/dao/NuageVspDaoImpl.java
@@ -0,0 +1,52 @@
+//
+// 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.dao;
+
+import javax.ejb.Local;
+
+import com.cloud.network.NuageVspDeviceVO;
+import com.cloud.utils.db.SearchBuilder;
+import com.cloud.utils.db.SearchCriteria;
+import org.springframework.stereotype.Component;
+
+import com.cloud.utils.db.GenericDaoBase;
+
+import java.util.List;
+
+@Component
+@Local(value = NuageVspDao.class)
+public class NuageVspDaoImpl extends GenericDaoBase<NuageVspDeviceVO, Long>
+        implements NuageVspDao {
+
+    protected final SearchBuilder<NuageVspDeviceVO> physicalNetworkIdSearch;
+
+    public NuageVspDaoImpl() {
+        physicalNetworkIdSearch = createSearchBuilder();
+        physicalNetworkIdSearch.and("physicalNetworkId", physicalNetworkIdSearch.entity().getPhysicalNetworkId(), SearchCriteria.Op.EQ);
+        physicalNetworkIdSearch.done();
+    }
+
+    @Override
+    public List<NuageVspDeviceVO> listByPhysicalNetwork(long physicalNetworkId) {
+        SearchCriteria<NuageVspDeviceVO> sc = physicalNetworkIdSearch.create();
+        sc.setParameters("physicalNetworkId", physicalNetworkId);
+        return search(sc, null);
+    }
+}

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/network/element/NuageVspElement.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/network/element/NuageVspElement.java b/plugins/network-elements/nuage-vsp/src/com/cloud/network/element/NuageVspElement.java
new file mode 100644
index 0000000..06f9733
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/network/element/NuageVspElement.java
@@ -0,0 +1,534 @@
+//
+// 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.element;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.ejb.Local;
+import javax.inject.Inject;
+import javax.naming.ConfigurationException;
+
+import org.apache.cloudstack.api.InternalIdentity;
+import org.apache.cloudstack.network.ExternalNetworkDeviceManager;
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.api.StartupCommand;
+import com.cloud.agent.api.StartupVspCommand;
+import com.cloud.agent.api.element.ApplyAclRuleVspAnswer;
+import com.cloud.agent.api.element.ApplyAclRuleVspCommand;
+import com.cloud.agent.api.element.ApplyStaticNatVspAnswer;
+import com.cloud.agent.api.element.ApplyStaticNatVspCommand;
+import com.cloud.dc.VlanVO;
+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.dao.DomainDao;
+import com.cloud.exception.CloudException;
+import com.cloud.exception.ConcurrentOperationException;
+import com.cloud.exception.InsufficientCapacityException;
+import com.cloud.exception.ResourceUnavailableException;
+import com.cloud.host.Host;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDao;
+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.NetworkModel;
+import com.cloud.network.Networks;
+import com.cloud.network.NuageVspDeviceVO;
+import com.cloud.network.PhysicalNetworkServiceProvider;
+import com.cloud.network.PublicIpAddress;
+import com.cloud.network.dao.IPAddressDao;
+import com.cloud.network.dao.IPAddressVO;
+import com.cloud.network.dao.NetworkDao;
+import com.cloud.network.dao.NetworkServiceMapDao;
+import com.cloud.network.dao.NuageVspDao;
+import com.cloud.network.rules.FirewallRule;
+import com.cloud.network.rules.FirewallRule.FirewallRuleType;
+import com.cloud.network.rules.StaticNat;
+import com.cloud.network.vpc.NetworkACLItem;
+import com.cloud.network.vpc.Vpc;
+import com.cloud.network.vpc.dao.VpcDao;
+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.resource.ResourceManager;
+import com.cloud.resource.ResourceStateAdapter;
+import com.cloud.resource.ServerResource;
+import com.cloud.resource.UnableDeleteHostException;
+import com.cloud.utils.component.AdapterBase;
+import com.cloud.vm.NicProfile;
+import com.cloud.vm.NicVO;
+import com.cloud.vm.ReservationContext;
+import com.cloud.vm.VirtualMachineProfile;
+import com.cloud.vm.dao.NicDao;
+
+@Local(value = {NetworkElement.class, ConnectivityProvider.class, IpDeployer.class, SourceNatServiceProvider.class, StaticNatServiceProvider.class, FirewallServiceProvider.class,
+        DhcpServiceProvider.class, NetworkACLServiceProvider.class})
+public class NuageVspElement extends AdapterBase implements ConnectivityProvider, IpDeployer, SourceNatServiceProvider, StaticNatServiceProvider, FirewallServiceProvider,
+        DhcpServiceProvider, NetworkACLServiceProvider, ResourceStateAdapter {
+
+    private static final Logger s_logger = Logger.getLogger(NuageVspElement.class);
+
+    private static final Map<Service, Map<Capability, String>> capabilities = setCapabilities();
+
+    public static final ExternalNetworkDeviceManager.NetworkDevice NuageVspDevice = new ExternalNetworkDeviceManager.NetworkDevice("NuageVsp", Provider.NuageVsp.getName());
+
+    @Inject
+    ResourceManager _resourceMgr;
+    @Inject
+    HostDao _hostDao;
+    @Inject
+    NetworkModel _networkModel;
+    @Inject
+    NetworkServiceMapDao _ntwkSrvcDao;
+    @Inject
+    NuageVspDao _nuageVspDao;
+    @Inject
+    NetworkDao _networkDao;
+    @Inject
+    protected DomainDao _domainDao;
+    @Inject
+    protected DataCenterDao _dcDao;
+    @Inject
+    IPAddressDao _ipAddressDao;
+    @Inject
+    VlanDao _vlanDao;
+    @Inject
+    NicDao _nicDao;
+    @Inject
+    VpcDao _vpcDao;
+    @Inject
+    NetworkOfferingServiceMapDao _ntwkOfferingSrvcDao;
+    @Inject
+    AgentManager _agentMgr;
+    @Inject
+    NetworkOfferingDao _ntwkOfferingDao;
+
+    @Override
+    public boolean applyIps(Network network, List<? extends PublicIpAddress> ipAddress, Set<Service> service) throws ResourceUnavailableException {
+        return false;
+    }
+
+    @Override
+    public Map<Service, Map<Capability, String>> getCapabilities() {
+        return capabilities;
+    }
+
+    private static Map<Service, Map<Capability, String>> setCapabilities() {
+        Map<Service, Map<Capability, String>> capabilities = new HashMap<Service, Map<Capability, String>>();
+
+        // L2 Support : SDN provisioning
+        capabilities.put(Service.Connectivity, null);
+
+        // L3 Support : Generic
+        capabilities.put(Service.Gateway, null);
+
+        // L3 Support : SourceNat
+        Map<Capability, String> sourceNatCapabilities = new HashMap<Capability, String>();
+        sourceNatCapabilities.put(Capability.SupportedSourceNatTypes, "peraccount");
+        sourceNatCapabilities.put(Capability.RedundantRouter, "false");
+        capabilities.put(Service.SourceNat, sourceNatCapabilities);
+
+        // L3 support : StaticNat
+        capabilities.put(Service.StaticNat, null);
+
+        // Set capabilities for Firewall service
+        Map<Capability, String> firewallCapabilities = new HashMap<Capability, String>();
+        firewallCapabilities.put(Capability.TrafficStatistics, "per public ip");
+        firewallCapabilities.put(Capability.SupportedProtocols, "tcp,udp,icmp");
+        firewallCapabilities.put(Capability.SupportedEgressProtocols, "tcp,udp,icmp, all");
+        firewallCapabilities.put(Capability.SupportedTrafficDirection, "ingress, egress");
+        firewallCapabilities.put(Capability.MultipleIps, "true");
+        capabilities.put(Service.Firewall, firewallCapabilities);
+
+        // L3 Support : DHCP
+        Map<Capability, String> dhcpCapabilities = new HashMap<Capability, String>();
+        capabilities.put(Service.Dhcp, dhcpCapabilities);
+
+        //add network ACL capability
+        Map<Network.Capability, String> networkACLCapabilities = new HashMap<Network.Capability, String>();
+        networkACLCapabilities.put(Network.Capability.SupportedProtocols, "tcp,udp,icmp");
+        capabilities.put(Network.Service.NetworkACL, networkACLCapabilities);
+
+        return capabilities;
+    }
+
+    @Override
+    public Provider getProvider() {
+        return Provider.NuageVsp;
+    }
+
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+        super.configure(name, params);
+        _resourceMgr.registerResourceStateAdapter(name, this);
+        return true;
+    }
+
+    @Override
+    public boolean implement(Network network, NetworkOffering offering, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException,
+            ResourceUnavailableException, InsufficientCapacityException {
+        s_logger.debug("Entering NuageElement implement function for network " + network.getDisplayText() + " (state " + network.getState() + ")");
+
+        if (!canHandle(network, Service.Connectivity)) {
+            return false;
+        }
+
+        if (network.getBroadcastUri() == null) {
+            s_logger.error("Nic has no broadcast Uri with the virtual router IP");
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean prepare(Network network, NicProfile nic, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException,
+            ResourceUnavailableException, InsufficientCapacityException {
+        if (!canHandle(network, Service.Connectivity)) {
+            return false;
+        }
+
+        if (network.getBroadcastUri() == null) {
+            s_logger.error("Nic has no broadcast Uri with the virtual router IP");
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean release(Network network, NicProfile nic, VirtualMachineProfile vm, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException {
+        if (!canHandle(network, Service.Connectivity)) {
+            return false;
+        }
+
+        if (network.getBroadcastUri() == null) {
+            s_logger.error("Nic has no broadcast Uri with the virtual router IP");
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean shutdown(Network network, ReservationContext context, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException {
+        if (!canHandle(network, Service.Connectivity)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean isReady(PhysicalNetworkServiceProvider provider) {
+        return true;
+    }
+
+    @Override
+    public boolean shutdownProviderInstances(PhysicalNetworkServiceProvider provider, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException {
+        return true;
+    }
+
+    @Override
+    public boolean canEnableIndividualServices() {
+        return false;
+    }
+
+    @Override
+    public boolean destroy(Network network, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException {
+        if (!canHandle(network, Service.Connectivity)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean verifyServicesCombination(Set<Service> services) {
+        // This element can only function in a NuageVsp based
+        // SDN network, so Connectivity needs to be present here
+        if (!services.contains(Service.Connectivity)) {
+            s_logger.warn("Unable to support services combination without Connectivity service provided by Nuage VSP.");
+            return false;
+        }
+
+        if ((services.contains(Service.StaticNat)) && (!services.contains(Service.SourceNat))) {
+            s_logger.warn("Unable to provide StaticNat without the SourceNat service.");
+            return false;
+        }
+
+        if (services.contains(Service.Vpn) || services.contains(Service.Dns) || services.contains(Service.Lb) || services.contains(Service.PortForwarding)
+                || services.contains(Service.SecurityGroup)) {
+            // NuageVsp doesn't implement any of these services, and we don't
+            // want anyone else to do it for us. So if these services
+            // exist, we can't handle it.
+            s_logger.warn("Unable to support services combination. The services list contains service(s) not supported by Nuage VSP.");
+            return false;
+        }
+
+        return true;
+    }
+
+    protected boolean canHandle(Network network, Service service) {
+
+        if (network.getBroadcastDomainType() != Networks.BroadcastDomainType.Vsp) {
+            return false;
+        }
+
+        if (!_networkModel.isProviderForNetwork(getProvider(), network.getId())) {
+            s_logger.debug("NuageElement is not a provider for network " + network.getDisplayText());
+            return false;
+        }
+
+        if (service != null) {
+            if (!_ntwkSrvcDao.canProviderSupportServiceInNetwork(network.getId(), service, getProvider())) {
+                s_logger.debug("NuageElement can't provide the " + service.getName() + " service on network " + network.getDisplayText());
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean addDhcpEntry(Network network, NicProfile nic, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException,
+            InsufficientCapacityException, ResourceUnavailableException {
+        return true;
+    }
+
+    @Override
+    public boolean configDhcpSupportForSubnet(Network network, NicProfile nic, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context)
+            throws ConcurrentOperationException, InsufficientCapacityException, ResourceUnavailableException {
+        return true;
+    }
+
+    @Override
+    public boolean removeDhcpSupportForSubnet(Network network) throws ResourceUnavailableException {
+        return true;
+    }
+
+    @Override
+    public boolean applyStaticNats(Network config, List<? extends StaticNat> rules) throws ResourceUnavailableException {
+        //Check if the network is associated to a VPC
+        Long vpcId = config.getVpcId();
+        String vpcOrSubnetUuid = null;
+        if (vpcId != null) {
+            Vpc vpcObj = _vpcDao.findById(vpcId);
+            vpcOrSubnetUuid = vpcObj.getUuid();
+        } else {
+            vpcOrSubnetUuid = config.getUuid();
+        }
+        Domain networkDomain = _domainDao.findById(config.getDomainId());
+
+        long networkOfferingId = _ntwkOfferingDao.findById(config.getNetworkOfferingId()).getId();
+        boolean isL3Network = isL3Network(networkOfferingId);
+
+        List<Map<String, Object>> sourceNatDetails = new ArrayList<Map<String, Object>>();
+        for (StaticNat staticNat : rules) {
+            Map<String, Object> sourceNatDetail = new HashMap<String, Object>();
+            IPAddressVO sourceNatIp = _ipAddressDao.findById(staticNat.getSourceIpAddressId());
+            VlanVO sourceNatVan = _vlanDao.findById(sourceNatIp.getVlanId());
+            NicVO nicVO = _nicDao.findByIp4AddressAndNetworkId(staticNat.getDestIpAddress(), staticNat.getNetworkId());
+            //Just get all the information about the sourceNat which will be used by NuageVsp
+            //client to process the request
+            sourceNatDetail.put("sourceNatIpUuid", sourceNatIp.getUuid());
+            sourceNatDetail.put("sourceNatIpAddress", sourceNatIp.getAddress().addr());
+            sourceNatDetail.put("nicMacAddress", nicVO == null ? null : nicVO.getMacAddress());
+            sourceNatDetail.put("isRevoke", staticNat.isForRevoke());
+            sourceNatDetail.put("sourceNatVlanUuid", sourceNatVan.getUuid());
+            sourceNatDetail.put("sourceNatVlanGateway", sourceNatVan.getVlanGateway());
+            sourceNatDetail.put("sourceNatVlanNetmask", sourceNatVan.getVlanNetmask());
+            sourceNatDetails.add(sourceNatDetail);
+        }
+        try {
+            try {
+                HostVO nuageVspHost = getNuageVspHost(config.getPhysicalNetworkId());
+                ApplyStaticNatVspCommand cmd = new ApplyStaticNatVspCommand(networkDomain.getUuid(), vpcOrSubnetUuid, isL3Network, sourceNatDetails);
+                ApplyStaticNatVspAnswer answer = (ApplyStaticNatVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+                if (answer == null || !answer.getResult()) {
+                    s_logger.error("ApplyStaticNatNuageVspCommand for network " + config.getUuid() + " failed");
+                    if ((null != answer) && (null != answer.getDetails())) {
+                        throw new ResourceUnavailableException(answer.getDetails(), Network.class, config.getId());
+                    }
+                }
+            } catch (Exception e) {
+                s_logger.warn("Failed to apply static Nat in Vsp " + e.getMessage());
+            }
+        } catch (Exception e) {
+            throw new ResourceUnavailableException("Failed to apply Static NAT in VSP", Network.class, config.getId(), e);
+        }
+
+        return true;
+    }
+
+    @Override
+    public IpDeployer getIpDeployer(Network network) {
+        return this;
+    }
+
+    @Override
+    public boolean applyFWRules(Network network, List<? extends FirewallRule> rules) throws ResourceUnavailableException {
+        s_logger.debug("Handling applyFWRules for network " + network.getName() + " with " + rules.size() + " FWRules");
+        if (rules != null && rules.size() == 1 && rules.iterator().next().getType().equals(FirewallRuleType.System)) {
+            s_logger.debug("Default ACL added by CS as system is ignored for network " + network.getName() + " with rule " + rules);
+            return true;
+        }
+        return applyACLRules(network, rules, false);
+    }
+
+    @Override
+    public boolean applyNetworkACLs(Network network, List<? extends NetworkACLItem> rules) throws ResourceUnavailableException {
+        s_logger.debug("Handling applyNetworkACLs for network " + network.getName() + " with " + rules.size() + " Network ACLs");
+        if (rules == null || rules.isEmpty()) {
+            s_logger.debug("No rules to apply. So, delete all the existing ACL in VSP from Subnet with uuid " + network.getUuid());
+        } else {
+            s_logger.debug("New rules has to applied. So, delete all the existing ACL in VSP from Subnet with uuid " + network.getUuid());
+        }
+        applyACLRules(network, rules, true);
+        return true;
+    }
+
+    protected boolean applyACLRules(Network network, List<? extends InternalIdentity> rules, boolean isVpc) throws ResourceUnavailableException {
+        Domain networksDomain = _domainDao.findById(network.getDomainId());
+        NetworkOfferingVO networkOferringVO = _ntwkOfferingDao.findById(network.getNetworkOfferingId());
+        try {
+            Long vpcId = network.getVpcId();
+            String vpcOrSubnetUuid = null;
+            if (vpcId != null) {
+                Vpc vpcObj = _vpcDao.findById(vpcId);
+                vpcOrSubnetUuid = vpcObj.getUuid();
+            } else {
+                vpcOrSubnetUuid = network.getUuid();
+            }
+            boolean egressDefaultPolicy = networkOferringVO.getEgressDefaultPolicy();
+            List<Map<String, Object>> aclRules = new ArrayList<Map<String, Object>>();
+            for (InternalIdentity acl : rules) {
+                aclRules.add(getACLRuleDetails(acl, egressDefaultPolicy));
+            }
+
+            HostVO nuageVspHost = getNuageVspHost(network.getPhysicalNetworkId());
+            ApplyAclRuleVspCommand cmd = new ApplyAclRuleVspCommand(network.getUuid(), networksDomain.getUuid(), vpcOrSubnetUuid, isL3Network(networkOferringVO.getId()), aclRules,
+                    isVpc, network.getId());
+            ApplyAclRuleVspAnswer answer = (ApplyAclRuleVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+            if (answer == null || !answer.getResult()) {
+                s_logger.error("ApplyAclRuleNuageVspCommand for network " + network.getUuid() + " failed");
+                if ((null != answer) && (null != answer.getDetails())) {
+                    throw new ResourceUnavailableException(answer.getDetails(), Network.class, network.getId());
+                }
+            }
+
+        } catch (Exception e1) {
+            throw new ResourceUnavailableException(e1.getMessage(), Network.class, network.getId());
+        }
+
+        return true;
+    }
+
+    @Override
+    public HostVO createHostVOForConnectedAgent(HostVO host, StartupCommand[] cmd) {
+        return null;
+    }
+
+    @Override
+    public HostVO createHostVOForDirectConnectAgent(HostVO host, StartupCommand[] startup, ServerResource resource, Map<String, String> details, List<String> hostTags) {
+        if (!(startup[0] instanceof StartupVspCommand)) {
+            return null;
+        }
+        host.setType(Host.Type.L2Networking);
+        return host;
+    }
+
+    @Override
+    public DeleteHostAnswer deleteHost(HostVO host, boolean isForced, boolean isForceDeleteStorage) throws UnableDeleteHostException {
+        if (!(host.getType() == Host.Type.L2Networking)) {
+            return null;
+        }
+        return new DeleteHostAnswer(true);
+    }
+
+    protected HostVO getNuageVspHost(Long physicalNetworkId) throws CloudException {
+        HostVO nuageVspHost;
+        List<NuageVspDeviceVO> nuageVspDevices = _nuageVspDao.listByPhysicalNetwork(physicalNetworkId);
+        if (nuageVspDevices != null && (!nuageVspDevices.isEmpty())) {
+            NuageVspDeviceVO config = nuageVspDevices.iterator().next();
+            nuageVspHost = _hostDao.findById(config.getHostId());
+            _hostDao.loadDetails(nuageVspHost);
+        } else {
+            throw new CloudException("Nuage VSD is not configured on physical network " + physicalNetworkId);
+        }
+        return nuageVspHost;
+    }
+
+    protected boolean isL3Network(Long offeringId) {
+        return _ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(offeringId, Service.SourceNat)
+                || _ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(offeringId, Service.StaticNat);
+    }
+
+    private Map<String, Object> getACLRuleDetails(Object aclRule, boolean egressDefaultPolicy) {
+        Map<String, Object> aclDetails = new HashMap<String, Object>();
+        if (aclRule instanceof FirewallRule) {
+            FirewallRule firewallRule = (FirewallRule)aclRule;
+            aclDetails.put("sourceCidrList", firewallRule.getSourceCidrList());
+            aclDetails.put("uuid", firewallRule.getUuid());
+            aclDetails.put("protocol", firewallRule.getProtocol());
+            aclDetails.put("startPort", firewallRule.getSourcePortStart());
+            aclDetails.put("endPort", firewallRule.getSourcePortEnd());
+            aclDetails.put("state", firewallRule.getState().name());
+            aclDetails.put("trafficType", firewallRule.getTrafficType().name());
+            if (firewallRule.getSourceIpAddressId() != null) {
+                //add the source IP
+                IPAddressVO ipaddress = _ipAddressDao.findById(((FirewallRule)aclRule).getSourceIpAddressId());
+                aclDetails.put("sourceIpAddress", ipaddress != null ? ipaddress.getVmIp() + "/32" : null);
+            }
+            if (firewallRule.getTrafficType().equals(FirewallRule.TrafficType.Egress) && egressDefaultPolicy) {
+                aclDetails.put("action", "Deny");
+            } else {
+                aclDetails.put("action", "Allow");
+            }
+            aclDetails.put("priority", -1);
+            aclDetails.put("type", "Firewall");
+        } else {
+            NetworkACLItem networkAcl = (NetworkACLItem)aclRule;
+            aclDetails.put("sourceCidrList", networkAcl.getSourceCidrList());
+            aclDetails.put("uuid", networkAcl.getUuid());
+            aclDetails.put("protocol", networkAcl.getProtocol());
+            aclDetails.put("startPort", networkAcl.getSourcePortStart());
+            aclDetails.put("endPort", networkAcl.getSourcePortEnd());
+            aclDetails.put("state", networkAcl.getState().name());
+            aclDetails.put("trafficType", networkAcl.getTrafficType().name());
+            //Set sourceIP to null as it is not applicable
+            aclDetails.put("sourceIpAddress", null);
+            aclDetails.put("action", networkAcl.getAction().name());
+            aclDetails.put("priority", networkAcl.getNumber());
+            aclDetails.put("type", "NetworkACL");
+        }
+        return aclDetails;
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/network/guru/NuageVspGuestNetworkGuru.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/network/guru/NuageVspGuestNetworkGuru.java b/plugins/network-elements/nuage-vsp/src/com/cloud/network/guru/NuageVspGuestNetworkGuru.java
new file mode 100644
index 0000000..d9882ea
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/network/guru/NuageVspGuestNetworkGuru.java
@@ -0,0 +1,416 @@
+//
+// 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.guru;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.ejb.Local;
+import javax.inject.Inject;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.api.guru.DeallocateVmVspAnswer;
+import com.cloud.agent.api.guru.DeallocateVmVspCommand;
+import com.cloud.agent.api.guru.ImplementNetworkVspAnswer;
+import com.cloud.agent.api.guru.ImplementNetworkVspCommand;
+import com.cloud.agent.api.guru.ReleaseVmVspAnswer;
+import com.cloud.agent.api.guru.ReleaseVmVspCommand;
+import com.cloud.agent.api.guru.ReserveVmInterfaceVspAnswer;
+import com.cloud.agent.api.guru.ReserveVmInterfaceVspCommand;
+import com.cloud.agent.api.guru.TrashNetworkVspAnswer;
+import com.cloud.agent.api.guru.TrashNetworkVspCommand;
+import com.cloud.dc.DataCenter;
+import com.cloud.dc.DataCenter.NetworkType;
+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.exception.InsufficientAddressCapacityException;
+import com.cloud.exception.InsufficientVirtualNetworkCapacityException;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDao;
+import com.cloud.network.Network;
+import com.cloud.network.Network.GuestType;
+import com.cloud.network.Network.Service;
+import com.cloud.network.Network.State;
+import com.cloud.network.NetworkProfile;
+import com.cloud.network.Networks;
+import com.cloud.network.NuageVspDeviceVO;
+import com.cloud.network.PhysicalNetwork;
+import com.cloud.network.PhysicalNetwork.IsolationMethod;
+import com.cloud.network.dao.NetworkVO;
+import com.cloud.network.dao.NuageVspDao;
+import com.cloud.network.dao.PhysicalNetworkVO;
+import com.cloud.network.vpc.Vpc;
+import com.cloud.network.vpc.dao.VpcDao;
+import com.cloud.offering.NetworkOffering;
+import com.cloud.offerings.dao.NetworkOfferingDao;
+import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;
+import com.cloud.user.Account;
+import com.cloud.user.AccountVO;
+import com.cloud.user.dao.AccountDao;
+import com.cloud.utils.db.DB;
+import com.cloud.utils.net.NetUtils;
+import com.cloud.vm.NicProfile;
+import com.cloud.vm.NicVO;
+import com.cloud.vm.ReservationContext;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.VirtualMachineProfile;
+
+@Local(value = NetworkGuru.class)
+public class NuageVspGuestNetworkGuru extends GuestNetworkGuru {
+    public static final Logger s_logger = Logger.getLogger(NuageVspGuestNetworkGuru.class);
+
+    @Inject
+    NetworkOfferingServiceMapDao _ntwkOfferingSrvcDao;
+    @Inject
+    NetworkOfferingDao _ntwkOfferingDao;
+    @Inject
+    DomainDao _domainDao;
+    @Inject
+    AccountDao _accountDao;
+    @Inject
+    NuageVspDao _nuageVspDao;
+    @Inject
+    HostDao _hostDao;
+    @Inject
+    VpcDao _vpcDao;
+    @Inject
+    AgentManager _agentMgr;
+
+    public NuageVspGuestNetworkGuru() {
+        super();
+        _isolationMethods = new IsolationMethod[] {IsolationMethod.VSP};
+    }
+
+    @Override
+    public Network design(NetworkOffering offering, DeploymentPlan plan, Network userSpecified, Account owner) {
+        PhysicalNetworkVO physnet = _physicalNetworkDao.findById(plan.getPhysicalNetworkId());
+        DataCenter dc = _dcDao.findById(plan.getDataCenterId());
+        if (!canHandle(offering, dc.getNetworkType(), physnet)) {
+            s_logger.debug("Refusing to design this network");
+            return null;
+        }
+
+        NetworkVO networkObject = (NetworkVO)super.design(offering, plan, userSpecified, owner);
+        if (networkObject == null) {
+            return null;
+        }
+
+        networkObject.setBroadcastDomainType(Networks.BroadcastDomainType.Vsp);
+        return networkObject;
+    }
+
+    @Override
+    public Network implement(Network network, NetworkOffering offering, DeployDestination dest, ReservationContext context) throws InsufficientVirtualNetworkCapacityException {
+
+        assert (network.getState() == State.Implementing) : "Why are we implementing " + network;
+
+        long dcId = dest.getDataCenter().getId();
+        //Get physical network id
+        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 = _networkModel.findPhysicalNetworkId(dcId, offering.getTags(), offering.getTrafficType());
+        }
+        NetworkVO implemented = new NetworkVO(network.getTrafficType(), network.getMode(), network.getBroadcastDomainType(), network.getNetworkOfferingId(), State.Allocated,
+                network.getDataCenterId(), physicalNetworkId);
+        if (network.getGateway() != null) {
+            implemented.setGateway(network.getGateway());
+        }
+        if (network.getCidr() != null) {
+            implemented.setCidr(network.getCidr());
+        }
+        Collection<String> ipAddressRange = new ArrayList<String>();
+        String virtualRouterIp = getVirtualRouterIP(network, ipAddressRange);
+        String networkUuid = implemented.getUuid();
+        String tenantId = context.getDomain().getName() + "-" + context.getAccount().getAccountId();
+        String broadcastUriStr = networkUuid + "/" + virtualRouterIp;
+        implemented.setBroadcastUri(Networks.BroadcastDomainType.Vsp.toUri(broadcastUriStr));
+        implemented.setBroadcastDomainType(Networks.BroadcastDomainType.Vsp);
+        //Check if the network is associated to a VPC
+        Long vpcId = network.getVpcId();
+        boolean isVpc = (vpcId != null);
+        //Check owner of the Network
+        Domain networksDomain = _domainDao.findById(network.getDomainId());
+        //Get the Account details and find the type
+        AccountVO networksAccount = _accountDao.findById(network.getAccountId());
+        if (networksAccount.getType() == Account.ACCOUNT_TYPE_PROJECT) {
+            String errorMessage = "CS project support is not yet implemented in NuageVsp";
+            s_logger.debug(errorMessage);
+            throw new InsufficientVirtualNetworkCapacityException(errorMessage, Account.class, network.getAccountId());
+        }
+        boolean isL3Network = isL3Network(offering.getId());
+        String vpcName = null;
+        String vpcUuid = null;
+        if (isVpc) {
+            Vpc vpcObj = _vpcDao.findById(vpcId);
+            vpcName = vpcObj.getName();
+            vpcUuid = vpcObj.getUuid();
+        }
+
+        HostVO nuageVspHost = getNuageVspHost(physicalNetworkId);
+        ImplementNetworkVspCommand cmd = new ImplementNetworkVspCommand(networksDomain.getName(), networksDomain.getPath(), networksDomain.getUuid(),
+                networksAccount.getAccountName(), networksAccount.getUuid(), network.getName(), network.getCidr(), network.getGateway(), network.getUuid(), isL3Network, vpcName,
+                vpcUuid, offering.getEgressDefaultPolicy(), ipAddressRange);
+        ImplementNetworkVspAnswer answer = (ImplementNetworkVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+
+        if (answer == null || !answer.getResult()) {
+            s_logger.error("ImplementNetworkNuageVspCommand failed");
+            if ((null != answer) && (null != answer.getDetails())) {
+                s_logger.error(answer.getDetails());
+            }
+            return null;
+        }
+        s_logger.info("Implemented OK, network " + networkUuid + " in tenant " + tenantId + " linked to " + implemented.getBroadcastUri().toString());
+        return implemented;
+    }
+
+    @Override
+    public NicProfile allocate(Network network, NicProfile nic, VirtualMachineProfile vm) throws InsufficientVirtualNetworkCapacityException, InsufficientAddressCapacityException {
+
+        return super.allocate(network, nic, vm);
+    }
+
+    @Override
+    public void reserve(NicProfile nic, Network network, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context)
+            throws InsufficientVirtualNetworkCapacityException, InsufficientAddressCapacityException {
+        nic.setBroadcastUri(network.getBroadcastUri());
+        nic.setIsolationUri(network.getBroadcastUri());
+
+        s_logger.debug("Handling reserve() call back to with Create a new VM or add an interface to existing VM in network " + network.getName());
+        DataCenter dc = _dcDao.findById(network.getDataCenterId());
+        Account networksAccount = _accountDao.findById(network.getAccountId());
+        DomainVO networksDomain = _domainDao.findById(network.getDomainId());
+        //Get the Account details and find the type
+        long networkOwnedBy = network.getAccountId();
+        AccountVO neworkAccountDetails = _accountDao.findById(networkOwnedBy);
+        if (neworkAccountDetails.getType() == Account.ACCOUNT_TYPE_PROJECT) {
+            throw new InsufficientVirtualNetworkCapacityException("CS project support is " + "not yet implemented in NuageVsp", DataCenter.class, dc.getId());
+        }
+
+        //NicProfile does not contain the NIC UUID. We need this information to set it in the VMInterface and VPort
+        //that we create in VSP
+        NicVO nicFrmDB = _nicDao.findById(nic.getId());
+        long networkOfferingId = _ntwkOfferingDao.findById(network.getNetworkOfferingId()).getId();
+        boolean isL3Network = isL3Network(networkOfferingId);
+        Long vpcId = network.getVpcId();
+        String vpcUuid = null;
+        if (vpcId != null) {
+            Vpc vpcObj = _vpcDao.findById(vpcId);
+            vpcUuid = vpcObj.getUuid();
+        }
+        HostVO nuageVspHost = getNuageVspHost(network.getPhysicalNetworkId());
+        ReserveVmInterfaceVspCommand cmd = new ReserveVmInterfaceVspCommand(nicFrmDB.getUuid(), nic.getMacAddress(), network.getUuid(), isL3Network, vpcUuid,
+                networksDomain.getUuid(), networksAccount.getUuid(), vm.getType().equals(VirtualMachine.Type.DomainRouter), network.getBroadcastUri().getPath().substring(1),
+                vm.getInstanceName(), vm.getUuid(), networksDomain.getUuid(), networksAccount.getUuid());
+        ReserveVmInterfaceVspAnswer answer = (ReserveVmInterfaceVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+
+        if (answer == null || !answer.getResult()) {
+            s_logger.error("ReserveVmInterfaceNuageVspCommand failed");
+            if ((null != answer) && (null != answer.getDetails())) {
+                s_logger.error(answer.getDetails());
+            }
+            throw new InsufficientVirtualNetworkCapacityException("Failed to reserve VM in Nuage VSP.", Network.class, network.getId());
+        }
+        List<Map<String, String>> vmInterfacesDetails = answer.getInterfaceDetails();
+        setIPGatewayMaskInfo(network, nic, vmInterfacesDetails);
+    }
+
+    @Override
+    protected boolean canHandle(NetworkOffering offering, final NetworkType networkType, final PhysicalNetwork physicalNetwork) {
+        if (networkType == NetworkType.Advanced && isMyTrafficType(offering.getTrafficType()) && offering.getGuestType() == Network.GuestType.Isolated
+                && isMyIsolationMethod(physicalNetwork)) {
+            return true;
+        } else {
+            s_logger.trace("We only take care of Guest networks of type   " + GuestType.Isolated + " in zone of type " + NetworkType.Advanced);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean release(NicProfile nic, VirtualMachineProfile vm, String reservationId) {
+        long networkId = nic.getNetworkId();
+        Network network = _networkDao.findById(networkId);
+        s_logger.debug("Handling release() call back, which is called when a VM is stopped or destroyed, to delete the VM with state " + vm.getVirtualMachine().getState()
+                + " from netork " + network.getName());
+        if (vm.getVirtualMachine().getState().equals(VirtualMachine.State.Stopping)) {
+            try {
+                HostVO nuageVspHost = getNuageVspHost(network.getPhysicalNetworkId());
+                ReleaseVmVspCommand cmd = new ReleaseVmVspCommand(network.getUuid(), vm.getUuid(), vm.getInstanceName());
+                ReleaseVmVspAnswer answer = (ReleaseVmVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+                if (answer == null || !answer.getResult()) {
+                    s_logger.error("ReleaseVmNuageVspCommand for VM " + vm.getUuid() + " failed");
+                    if ((null != answer) && (null != answer.getDetails())) {
+                        s_logger.error(answer.getDetails());
+                    }
+                }
+            } catch (InsufficientVirtualNetworkCapacityException e) {
+                s_logger.debug("Handling release() call back. Failed to delete CS VM " + vm.getInstanceName() + " in VSP. " + e.getMessage());
+            }
+        } else {
+            s_logger.debug("Handling release() call back. VM " + vm.getInstanceName() + " is in " + vm.getVirtualMachine().getState() + " state. So, the CS VM is not deleted."
+                    + " This could be a case where VM interface is deleted. deallocate() call back should be called later");
+        }
+
+        return super.release(nic, vm, reservationId);
+    }
+
+    @Override
+    @DB
+    public void deallocate(Network network, NicProfile nic, VirtualMachineProfile vm) {
+
+        try {
+            s_logger.debug("Handling deallocate() call back, which is called when a VM is destroyed or interface is removed, " + "to delete VM Interface with IP "
+                    + nic.getIp4Address() + " from a VM " + vm.getInstanceName() + " with state " + vm.getVirtualMachine().getState());
+            DomainVO networksDomain = _domainDao.findById(network.getDomainId());
+            NicVO nicFrmDd = _nicDao.findById(nic.getId());
+            long networkOfferingId = _ntwkOfferingDao.findById(network.getNetworkOfferingId()).getId();
+            Long vpcId = network.getVpcId();
+            String vpcUuid = null;
+            if (vpcId != null) {
+                Vpc vpcObj = _vpcDao.findById(vpcId);
+                vpcUuid = vpcObj.getUuid();
+            }
+            HostVO nuageVspHost = getNuageVspHost(network.getPhysicalNetworkId());
+            DeallocateVmVspCommand cmd = new DeallocateVmVspCommand(network.getUuid(), nicFrmDd.getUuid(), nic.getMacAddress(), nic.getIp4Address(),
+                    isL3Network(networkOfferingId), vpcUuid, networksDomain.getUuid(), vm.getInstanceName(), vm.getUuid());
+            DeallocateVmVspAnswer answer = (DeallocateVmVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+            if (answer == null || !answer.getResult()) {
+                s_logger.error("DeallocateVmNuageVspCommand for VM " + vm.getUuid() + " failed");
+                if ((null != answer) && (null != answer.getDetails())) {
+                    s_logger.error(answer.getDetails());
+                }
+            }
+        } catch (InsufficientVirtualNetworkCapacityException e) {
+            s_logger.error("Handling deallocate(). VM " + vm.getInstanceName() + " with NIC IP " + nic.getIp4Address()
+                    + " is getting destroyed. REST API failed to update the VM state in NuageVsp", e);
+        }
+        super.deallocate(network, nic, vm);
+    }
+
+    @Override
+    public void shutdown(NetworkProfile profile, NetworkOffering offering) {
+        super.shutdown(profile, offering);
+    }
+
+    @Override
+    public boolean trash(Network network, NetworkOffering offering) {
+
+        s_logger.debug("Handling trash() call back to delete the network " + network.getName() + " with uuid " + network.getUuid() + " from VSP");
+        long domainId = network.getDomainId();
+        Domain domain = _domainDao.findById(domainId);
+        Long vpcId = network.getVpcId();
+        String vpcUuid = null;
+        if (vpcId != null) {
+            Vpc vpcObj = _vpcDao.findById(vpcId);
+            vpcUuid = vpcObj.getUuid();
+        }
+        try {
+            HostVO nuageVspHost = getNuageVspHost(network.getPhysicalNetworkId());
+            TrashNetworkVspCommand cmd = new TrashNetworkVspCommand(domain.getUuid(), network.getUuid(), isL3Network(offering.getId()), vpcUuid);
+            TrashNetworkVspAnswer answer = (TrashNetworkVspAnswer)_agentMgr.easySend(nuageVspHost.getId(), cmd);
+            if (answer == null || !answer.getResult()) {
+                s_logger.error("TrashNetworkNuageVspCommand for network " + network.getUuid() + " failed");
+                if ((null != answer) && (null != answer.getDetails())) {
+                    s_logger.error(answer.getDetails());
+                }
+            }
+        } catch (Exception e) {
+            s_logger.warn("Failed to clean up network information in Vsp " + e.getMessage());
+        }
+
+        return super.trash(network, offering);
+    }
+
+    private String getVirtualRouterIP(Network network, Collection<String> addressRange) throws InsufficientVirtualNetworkCapacityException {
+        String virtualRouterIp;
+        String subnet = NetUtils.getCidrSubNet(network.getCidr());
+        String netmask = NetUtils.getCidrNetmask(network.getCidr());
+        long cidrSize = NetUtils.getCidrSize(netmask);
+
+        Set<Long> allIPsInCidr = NetUtils.getAllIpsFromCidr(subnet, cidrSize, new HashSet<Long>());
+
+        if (allIPsInCidr.size() > 3) {
+            Iterator<Long> ipIterator = allIPsInCidr.iterator();
+            long vip = ipIterator.next();
+            if (NetUtils.ip2Long(network.getGateway()) == vip) {
+                s_logger.debug("Gateway of the Network(" + network.getUuid() + ") has the first IP " + NetUtils.long2Ip(vip));
+                vip = ipIterator.next();
+                virtualRouterIp = NetUtils.long2Ip(vip);
+                s_logger.debug("So, reserving the 2nd IP " + virtualRouterIp + " for the Virtual Router IP in Network(" + network.getUuid() + ")");
+            } else {
+                virtualRouterIp = NetUtils.long2Ip(vip);
+                s_logger.debug("1nd IP is not used as the gateway IP. So, reserving" + virtualRouterIp + " for the Virtual Router IP for " + "Network(" + network.getUuid() + ")");
+            }
+            addressRange.add(NetUtils.long2Ip(ipIterator.next()));
+            addressRange.add(NetUtils.long2Ip((Long)allIPsInCidr.toArray()[allIPsInCidr.size() - 1]));
+            return virtualRouterIp;
+        }
+
+        throw new InsufficientVirtualNetworkCapacityException("VSP allocates an IP for VirtualRouter." + " So, subnet should have atleast minimum 4 hosts ", Network.class,
+                network.getId());
+    }
+
+    private void setIPGatewayMaskInfo(Network network, NicProfile nic, List<Map<String, String>> vmInterfacesDetails) throws InsufficientVirtualNetworkCapacityException {
+        try {
+            for (Map<String, String> interfaces : vmInterfacesDetails) {
+                String macFromNuage = interfaces.get("mac");
+                if (StringUtils.equals(macFromNuage, nic.getMacAddress())) {
+                    nic.setIp4Address(interfaces.get("ip4Address"));
+                    nic.setGateway(interfaces.get("gateway"));
+                    nic.setNetmask(interfaces.get("netmask"));
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            s_logger.error("Failed to parse the VM interface Json response from VSP REST API. VM interface json string is  " + vmInterfacesDetails, e);
+            throw new InsufficientVirtualNetworkCapacityException("Failed to parse the VM interface Json response from VSP REST API. VM interface Json " + "string is  "
+                    + vmInterfacesDetails + ". So. failed to get IP for the VM from VSP address for network " + network, Network.class, network.getId());
+        }
+    }
+
+    private boolean isL3Network(Long offeringId) {
+        return _ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(offeringId, Service.SourceNat)
+                || _ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(offeringId, Service.StaticNat);
+    }
+
+    private HostVO getNuageVspHost(long physicalNetworkId) throws InsufficientVirtualNetworkCapacityException {
+        HostVO nuageVspHost;
+        List<NuageVspDeviceVO> nuageVspDevices = _nuageVspDao.listByPhysicalNetwork(physicalNetworkId);
+        if (nuageVspDevices != null && (!nuageVspDevices.isEmpty())) {
+            NuageVspDeviceVO config = nuageVspDevices.iterator().next();
+            nuageVspHost = _hostDao.findById(config.getHostId());
+            _hostDao.loadDetails(nuageVspHost);
+        } else {
+            throw new InsufficientVirtualNetworkCapacityException("Nuage VSD is not configured on physical network ", PhysicalNetwork.class, physicalNetworkId);
+        }
+        return nuageVspHost;
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/03de9cc3/plugins/network-elements/nuage-vsp/src/com/cloud/network/manager/NuageVspManager.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/nuage-vsp/src/com/cloud/network/manager/NuageVspManager.java b/plugins/network-elements/nuage-vsp/src/com/cloud/network/manager/NuageVspManager.java
new file mode 100644
index 0000000..2b4d2b5
--- /dev/null
+++ b/plugins/network-elements/nuage-vsp/src/com/cloud/network/manager/NuageVspManager.java
@@ -0,0 +1,55 @@
+//
+// 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.manager;
+
+import java.util.List;
+
+import org.apache.cloudstack.framework.config.ConfigKey;
+import org.apache.cloudstack.framework.config.ConfigKey.Scope;
+
+import com.cloud.api.commands.AddNuageVspDeviceCmd;
+import com.cloud.api.commands.DeleteNuageVspDeviceCmd;
+import com.cloud.api.commands.ListNuageVspDevicesCmd;
+import com.cloud.api.response.NuageVspDeviceResponse;
+import com.cloud.network.NuageVspDeviceVO;
+import com.cloud.utils.component.PluggableService;
+
+public interface NuageVspManager extends PluggableService {
+
+    static final String NUAGE_VPC_OFFERING_NAME = "Default VPC offering with NuageVsp";
+
+    static final String NUAGE_VPC_OFFERING_DISPLAY_TEXT = "Default VPC offering with NuageVsp";
+
+    static final ConfigKey<Integer> NuageVspSyncInterval = new ConfigKey<Integer>(Integer.class, "nuagevsp.sync.interval", "Advanced", "480",
+            "The interval (in minutes) to wait before running the next synchronization worker to synchronize the information between CloudStack and NuageVsp", false, Scope.Global,
+            1);
+
+    static final ConfigKey<Integer> NuageVspSyncWorkers = new ConfigKey<Integer>(Integer.class, "nuagevsp.sync.workers", "Advanced", "1",
+            "Number of workers to synchronize the information between CloudStack and NuageVsp", false, Scope.Global, 1);
+
+    NuageVspDeviceVO addNuageVspDevice(AddNuageVspDeviceCmd cmd);
+
+    NuageVspDeviceResponse createNuageVspDeviceResponse(NuageVspDeviceVO nuageVspDeviceVO);
+
+    boolean deleteNuageVspDevice(DeleteNuageVspDeviceCmd cmd);
+
+    List<NuageVspDeviceVO> listNuageVspDevices(ListNuageVspDevicesCmd cmd);
+
+}


Mime
View raw message