Ravi Nori has uploaded a new change for review.

Change subject: restapi : Add /clusters sub-collection under 
/datacenters/xxx(#674521)
......................................................................

restapi : Add /clusters sub-collection under /datacenters/xxx(#674521)

Adds datacenters/clusters links to see specific data center clusters.

Change-Id: I6b27ef501324d890efbe0e8b914d9db47653f146
Bug-Url: https://bugzilla.redhat.com/show_bug.cgi?id=674521
Signed-off-by: Ravi Nori <rn...@redhat.com>
---
M 
backend/manager/modules/restapi/interface/definition/src/main/java/org/ovirt/engine/api/resource/DataCenterResource.java
A 
backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResource.java
M 
backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterResource.java
M 
backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCentersResource.java
A 
backend/manager/modules/restapi/jaxrs/src/test/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResourceTest.java
5 files changed, 438 insertions(+), 1 deletion(-)


  git pull ssh://gerrit.ovirt.org:29418/ovirt-engine refs/changes/18/11618/1

diff --git 
a/backend/manager/modules/restapi/interface/definition/src/main/java/org/ovirt/engine/api/resource/DataCenterResource.java
 
b/backend/manager/modules/restapi/interface/definition/src/main/java/org/ovirt/engine/api/resource/DataCenterResource.java
index c2ee5e1..c4cdc89 100644
--- 
a/backend/manager/modules/restapi/interface/definition/src/main/java/org/ovirt/engine/api/resource/DataCenterResource.java
+++ 
b/backend/manager/modules/restapi/interface/definition/src/main/java/org/ovirt/engine/api/resource/DataCenterResource.java
@@ -27,6 +27,9 @@
     @Path("storagedomains")
     public AttachedStorageDomainsResource getAttachedStorageDomainsResource();
 
+    @Path("clusters")
+    public ClustersResource getClustersResource();
+
     @Path("permissions")
     public AssignedPermissionsResource getPermissionsResource();
 
diff --git 
a/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResource.java
 
b/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResource.java
new file mode 100644
index 0000000..2c8fb086
--- /dev/null
+++ 
b/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResource.java
@@ -0,0 +1,90 @@
+package org.ovirt.engine.api.restapi.resource;
+
+import static 
org.ovirt.engine.api.restapi.resource.BackendDataCenterResource.getStoragePool;
+
+import java.util.List;
+
+import javax.ws.rs.core.Response;
+
+import org.ovirt.engine.api.model.Cluster;
+import org.ovirt.engine.api.model.Clusters;
+import org.ovirt.engine.api.resource.ClusterResource;
+import org.ovirt.engine.api.resource.ClustersResource;
+import org.ovirt.engine.core.common.action.VdcActionType;
+import org.ovirt.engine.core.common.action.VdsGroupOperationParameters;
+import org.ovirt.engine.core.common.action.VdsGroupParametersBase;
+import org.ovirt.engine.core.common.businessentities.VDSGroup;
+import org.ovirt.engine.core.common.businessentities.storage_pool;
+import org.ovirt.engine.core.common.queries.GetVdsGroupByIdParameters;
+import org.ovirt.engine.core.common.queries.StoragePoolQueryParametersBase;
+import org.ovirt.engine.core.common.queries.VdcQueryType;
+import org.ovirt.engine.core.compat.Guid;
+
+public class BackendDataCenterClustersResource extends 
AbstractBackendCollectionResource<Cluster, VDSGroup>
+        implements ClustersResource {
+
+    static final String[] SUB_COLLECTIONS = { "networks", "permissions", 
"glustervolumes" };
+    static final String VIRT_ONLY_MODE_COLLECTIONS_TO_HIDE = "glustervolumes";
+    protected Guid dataCenterId;
+    public BackendDataCenterClustersResource(String dataCenterId) {
+        super(Cluster.class, VDSGroup.class, SUB_COLLECTIONS);
+        this.dataCenterId = asGuid(dataCenterId);
+    }
+
+    @Override
+    public Clusters list() {
+        return 
mapCollection(getBackendCollection(VdcQueryType.GetVdsGroupsByStoragePoolId,
+                    new StoragePoolQueryParametersBase(dataCenterId)));
+    }
+
+    @Override
+    @SingleEntityResource
+    public ClusterResource getClusterSubResource(String id) {
+        return inject(new BackendClusterResource(id));
+    }
+
+    @Override
+    public Response add(Cluster cluster) {
+        validateParameters(cluster, "name", "dataCenter.name|id");
+        validateEnums(Cluster.class, cluster);
+        storage_pool pool = getStoragePool(cluster, this);
+        VDSGroup entity = map(cluster, map(pool));
+        return performCreate(VdcActionType.AddVdsGroup,
+                new VdsGroupOperationParameters(entity),
+                new QueryIdResolver<Guid>(VdcQueryType.GetVdsGroupById, 
GetVdsGroupByIdParameters.class));
+    }
+
+    @Override
+    public Response performRemove(String id) {
+        return performAction(VdcActionType.RemoveVdsGroup, new 
VdsGroupParametersBase(asGuid(id)));
+    }
+
+    private Clusters mapCollection(List<VDSGroup> entities) {
+        Clusters collection = new Clusters();
+        for (org.ovirt.engine.core.common.businessentities.VDSGroup entity : 
entities) {
+            collection.getClusters().add(addLinks(map(entity)));
+        }
+        return collection;
+    }
+
+    private Clusters mapVirtOnlyCollection(List<VDSGroup> entities) {
+        Clusters collection = new Clusters();
+        for (org.ovirt.engine.core.common.businessentities.VDSGroup entity : 
entities) {
+            collection.getClusters().add(addLinks(map(entity), 
VIRT_ONLY_MODE_COLLECTIONS_TO_HIDE));
+        }
+        return collection;
+    }
+
+    /**
+     * Map the storage pool (i.e. datacenter entity) to a VDSGroup instance
+     * with the same compatibility version
+     */
+    protected VDSGroup map(storage_pool pool) {
+        return getMapper(storage_pool.class, VDSGroup.class).map(pool, null);
+    }
+
+    @Override
+    protected Cluster doPopulate(Cluster model, VDSGroup entity) {
+        return model;
+    }
+}
diff --git 
a/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterResource.java
 
b/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterResource.java
index 3d089ac..004308a 100644
--- 
a/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterResource.java
+++ 
b/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterResource.java
@@ -7,6 +7,7 @@
 import org.ovirt.engine.api.model.DataCenter;
 import org.ovirt.engine.api.resource.AssignedPermissionsResource;
 import org.ovirt.engine.api.resource.AttachedStorageDomainsResource;
+import org.ovirt.engine.api.resource.ClustersResource;
 import org.ovirt.engine.api.resource.DataCenterResource;
 import org.ovirt.engine.api.resource.QuotasResource;
 import org.ovirt.engine.core.common.VdcObjectType;
@@ -62,6 +63,11 @@
     }
 
     @Override
+    public ClustersResource getClustersResource() {
+        return inject(new BackendDataCenterClustersResource(id));
+    }
+
+    @Override
     public QuotasResource getQuotasResource() {
          return inject(new BackendQuotasResource(id));
     }
diff --git 
a/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCentersResource.java
 
b/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCentersResource.java
index 130bc7e..1948f70 100644
--- 
a/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCentersResource.java
+++ 
b/backend/manager/modules/restapi/jaxrs/src/main/java/org/ovirt/engine/api/restapi/resource/BackendDataCentersResource.java
@@ -27,7 +27,7 @@
 public class BackendDataCentersResource extends
         AbstractBackendCollectionResource<DataCenter, storage_pool> implements 
DataCentersResource {
 
-    static final String[] SUB_COLLECTIONS = {"storagedomains", "permissions", 
"quotas"};
+    static final String[] SUB_COLLECTIONS = {"storagedomains", "clusters", 
"permissions", "quotas"};
 
     public BackendDataCentersResource() {
         super(DataCenter.class, storage_pool.class, SUB_COLLECTIONS);
diff --git 
a/backend/manager/modules/restapi/jaxrs/src/test/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResourceTest.java
 
b/backend/manager/modules/restapi/jaxrs/src/test/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResourceTest.java
new file mode 100644
index 0000000..6c82395
--- /dev/null
+++ 
b/backend/manager/modules/restapi/jaxrs/src/test/java/org/ovirt/engine/api/restapi/resource/BackendDataCenterClustersResourceTest.java
@@ -0,0 +1,338 @@
+package org.ovirt.engine.api.restapi.resource;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+
+import org.junit.Test;
+
+import org.ovirt.engine.api.model.CPU;
+import org.ovirt.engine.api.model.Cluster;
+import org.ovirt.engine.api.model.DataCenter;
+import org.ovirt.engine.api.model.Version;
+import org.ovirt.engine.core.common.interfaces.SearchType;
+import org.ovirt.engine.core.common.queries.GetVdsGroupByIdParameters;
+import org.ovirt.engine.core.common.queries.StoragePoolQueryParametersBase;
+import org.ovirt.engine.core.common.queries.VdcQueryType;
+import org.ovirt.engine.core.common.action.VdcActionType;
+import org.ovirt.engine.core.common.action.VdsGroupOperationParameters;
+import org.ovirt.engine.core.common.action.VdsGroupParametersBase;
+import org.ovirt.engine.core.common.businessentities.VDSGroup;
+import org.ovirt.engine.core.common.businessentities.storage_pool;
+import org.ovirt.engine.core.compat.Guid;
+
+import static org.easymock.classextension.EasyMock.expect;
+
+public class BackendDataCenterClustersResourceTest extends
+        AbstractBackendCollectionResourceTest<Cluster, VDSGroup, 
BackendDataCenterClustersResource> {
+
+    static Guid dataCenterId = GUIDS[1];
+
+    public BackendDataCenterClustersResourceTest() {
+        super(new BackendDataCenterClustersResource(dataCenterId.toString()), 
null, "");
+    }
+
+    @Test
+    public void testRemove() throws Exception {
+        setUpGetEntityExpectations();
+        setUriInfo(setUpActionExpectations(VdcActionType.RemoveVdsGroup,
+                                           VdsGroupParametersBase.class,
+                                           new String[] { "VdsGroupId" },
+                                           new Object[] { GUIDS[0] },
+                                           true,
+                                           true));
+        verifyRemove(collection.remove(GUIDS[0].toString()));
+    }
+
+    @Test
+    public void testRemoveNonExistant() throws Exception{
+        setUpGetEntityExpectations(NON_EXISTANT_GUID, true);
+        control.replay();
+        try {
+            collection.remove(NON_EXISTANT_GUID.toString());
+            fail("expected WebApplicationException");
+        } catch (WebApplicationException wae) {
+            assertNotNull(wae.getResponse());
+            assertEquals(404, wae.getResponse().getStatus());
+        }
+    }
+
+    private void setUpGetEntityExpectations(Guid entityId, Boolean returnNull) 
throws Exception {
+        setUpGetEntityExpectations(VdcQueryType.GetVdsGroupById,
+                GetVdsGroupByIdParameters.class,
+                new String[] { "VdsId" },
+                new Object[] { entityId },
+                returnNull ? null : getEntity(0));
+    }
+
+    private void setUpGetEntityExpectations() throws Exception {
+        setUpGetEntityExpectations(GUIDS[0], false);
+    }
+
+    @Test
+    public void testRemoveCantDo() throws Exception {
+        setUpGetEntityExpectations();
+        doTestBadRemove(false, true, CANT_DO);
+    }
+
+    @Test
+    public void testRemoveFailed() throws Exception {
+        setUpGetEntityExpectations();
+        doTestBadRemove(true, false, FAILURE);
+    }
+
+    protected void doTestBadRemove(boolean canDo, boolean success, String 
detail) throws Exception {
+        setUriInfo(setUpActionExpectations(VdcActionType.RemoveVdsGroup,
+                                           VdsGroupParametersBase.class,
+                                           new String[] { "VdsGroupId" },
+                                           new Object[] { GUIDS[0] },
+                                           canDo,
+                                           success));
+        try {
+            collection.remove(GUIDS[0].toString());
+            fail("expected WebApplicationException");
+        } catch (WebApplicationException wae) {
+            verifyFault(wae, detail);
+        }
+    }
+
+    @Test
+    public void testAddClusterFallbackVersion() throws Exception {
+        setUriInfo(setUpBasicUriExpectations());
+        setUpGetEntityExpectations(VdcQueryType.GetStoragePoolById,
+                                   StoragePoolQueryParametersBase.class,
+                                   new String[] { "StoragePoolId" },
+                                   new Object[] { GUIDS[1] },
+                                   setUpStoragePool(-1));
+
+        setUpCreationExpectations(VdcActionType.AddVdsGroup,
+                                  VdsGroupOperationParameters.class,
+                                  new String[] { 
"VdsGroup.compatibility_version" },
+                                  new Object[] { new 
org.ovirt.engine.core.compat.Version(2, 2) },
+                                  true,
+                                  true,
+                                  GUIDS[0],
+                                  VdcQueryType.GetVdsGroupById,
+                                  GetVdsGroupByIdParameters.class,
+                                  new String[] { "VdsId" },
+                                  new Object[] { GUIDS[0] },
+                                  getEntity(0));
+
+        Cluster model = getModel(0);
+        model.getDataCenter().setId(GUIDS[1].toString());
+
+        Response response = collection.add(model);
+        assertEquals(201, response.getStatus());
+        assertTrue(response.getEntity() instanceof Cluster);
+        verifyModel((Cluster) response.getEntity(), 0);
+    }
+
+    @Test
+    public void testAddClusterSpecificVersion() throws Exception {
+        setUriInfo(setUpBasicUriExpectations());
+        setUpGetEntityExpectations(VdcQueryType.GetStoragePoolById,
+                                   StoragePoolQueryParametersBase.class,
+                                   new String[] { "StoragePoolId" },
+                                   new Object[] { GUIDS[1] },
+                                   setUpStoragePool(-1));
+
+        setUpCreationExpectations(VdcActionType.AddVdsGroup,
+                                  VdsGroupOperationParameters.class,
+                                  new String[] { 
"VdsGroup.compatibility_version" },
+                                  new Object[] { new 
org.ovirt.engine.core.compat.Version(2, 3) },
+                                  true,
+                                  true,
+                                  GUIDS[0],
+                                  VdcQueryType.GetVdsGroupById,
+                                  GetVdsGroupByIdParameters.class,
+                                  new String[] { "VdsId" },
+                                  new Object[] { GUIDS[0] },
+                                  getEntity(0));
+
+        Cluster model = getModel(0);
+        model.getDataCenter().setId(GUIDS[1].toString());
+        model.setVersion(new Version());
+        model.getVersion().setMajor(2);
+        model.getVersion().setMinor(3);
+
+        Response response = collection.add(model);
+        assertEquals(201, response.getStatus());
+        assertTrue(response.getEntity() instanceof Cluster);
+        verifyModel((Cluster) response.getEntity(), 0);
+    }
+
+    @Test
+    public void testAddClusterCantDo() throws Exception {
+        doTestBadAddCluster(false, true, CANT_DO);
+    }
+
+    @Test
+    public void testAddClusterFailure() throws Exception {
+        doTestBadAddCluster(true, false, FAILURE);
+    }
+
+    private void doTestBadAddCluster(boolean canDo, boolean success, String 
detail)
+            throws Exception {
+        setUpGetEntityExpectations(VdcQueryType.GetStoragePoolById,
+                                   StoragePoolQueryParametersBase.class,
+                                   new String[] { "StoragePoolId" },
+                                   new Object[] { GUIDS[1] },
+                                   setUpStoragePool(-1));
+
+        setUriInfo(setUpActionExpectations(VdcActionType.AddVdsGroup,
+                                           VdsGroupOperationParameters.class,
+                                           new String[] {},
+                                           new Object[] {},
+                                           canDo,
+                                           success));
+        Cluster model = getModel(0);
+        model.getDataCenter().setId(GUIDS[1].toString());
+
+        try {
+            collection.add(model);
+            fail("expected WebApplicationException");
+        } catch (WebApplicationException wae) {
+            verifyFault(wae, detail);
+        }
+    }
+
+    @Test
+    public void testAddClusterNamedDataCenter() throws Exception {
+        setUriInfo(setUpBasicUriExpectations());
+        setUpGetEntityExpectations("Datacenter: name=" + NAMES[1],
+                                   SearchType.StoragePool,
+                                   setUpStoragePool(1));
+
+        setUpCreationExpectations(VdcActionType.AddVdsGroup,
+                                  VdsGroupOperationParameters.class,
+                                  new String[] {},
+                                  new Object[] {},
+                                  true,
+                                  true,
+                                  GUIDS[0],
+                                  VdcQueryType.GetVdsGroupById,
+                                  GetVdsGroupByIdParameters.class,
+                                  new String[] { "VdsId" },
+                                  new Object[] { GUIDS[0] },
+                                  getEntity(0));
+
+        Cluster model = getModel(0);
+        model.getDataCenter().setName(NAMES[1]);
+
+        Response response = collection.add(model);
+        assertEquals(201, response.getStatus());
+        assertTrue(response.getEntity() instanceof Cluster);
+        verifyModel((Cluster) response.getEntity(), 0);
+    }
+
+    @Test
+    public void testAddClusterCantDoNamedDataCenter() throws Exception {
+        doTestBadAddClusterNamedDataCenter(false, true, CANT_DO);
+    }
+
+    @Test
+    public void testAddClusterFailureNamedDataCenter() throws Exception {
+        doTestBadAddClusterNamedDataCenter(true, false, FAILURE);
+    }
+
+    private void doTestBadAddClusterNamedDataCenter(boolean canDo, boolean 
success, String detail)
+            throws Exception {
+        setUpGetEntityExpectations("Datacenter: name=" + NAMES[1],
+                                   SearchType.StoragePool,
+                                   setUpStoragePool(1));
+
+        setUriInfo(setUpActionExpectations(VdcActionType.AddVdsGroup,
+                                           VdsGroupOperationParameters.class,
+                                           new String[] {},
+                                           new Object[] {},
+                                           canDo,
+                                           success));
+        Cluster model = getModel(0);
+        model.getDataCenter().setName(NAMES[1]);
+
+        try {
+            collection.add(model);
+            fail("expected WebApplicationException");
+        } catch (WebApplicationException wae) {
+            verifyFault(wae, detail);
+        }
+    }
+
+    @Test
+    public void testAddIncompleteParameters() throws Exception {
+        Cluster model = new Cluster();
+        model.setName(NAMES[0]);
+        setUriInfo(setUpBasicUriExpectations());
+        control.replay();
+        try {
+            collection.add(model);
+            fail("expected WebApplicationException on incomplete parameters");
+        } catch (WebApplicationException wae) {
+             verifyIncompleteException(wae, "Cluster", "add", 
"dataCenter.name|id");
+        }
+    }
+
+    @Override
+    protected void setUpQueryExpectations(String query) throws Exception {
+        setUpQueryExpectations(query, null);
+    }
+
+    @Override
+    protected void setUpQueryExpectations(String query, Object failure) throws 
Exception {
+        setUpEntityQueryExpectations(VdcQueryType.GetVdsGroupsByStoragePoolId,
+                                     StoragePoolQueryParametersBase.class,
+                                     new String[] { "StoragePoolId" },
+                                     new Object[] { GUIDS[1] },
+                                     setUpVDSGroups(),
+                                     failure);
+
+        control.replay();
+    }
+
+    protected List<VDSGroup> setUpVDSGroups() {
+        List<VDSGroup> entities = new ArrayList<VDSGroup>();
+        for (int i = 0; i < NAMES.length; i++) {
+            entities.add(getEntity(i));
+        }
+        return entities;
+    }
+
+    protected storage_pool setUpStoragePool(int index) {
+        storage_pool pool = control.createMock(storage_pool.class);
+        org.ovirt.engine.core.compat.Version version =
+            new org.ovirt.engine.core.compat.Version(2, 2);
+        if (index != -1) {
+            expect(pool.getId()).andReturn(GUIDS[index]).anyTimes();
+        }
+        expect(pool.getcompatibility_version()).andReturn(version).anyTimes();
+        return pool;
+    }
+
+    protected VDSGroup getEntity(int index) {
+        return setUpEntityExpectations(control.createMock(VDSGroup.class), 
index);
+    }
+
+    static VDSGroup setUpEntityExpectations(VDSGroup entity, int index) {
+        expect(entity.getId()).andReturn(GUIDS[index]).anyTimes();
+        expect(entity.getname()).andReturn(NAMES[index]).anyTimes();
+        
expect(entity.getdescription()).andReturn(DESCRIPTIONS[index]).anyTimes();
+        return entity;
+    }
+
+    static Cluster getModel(int index) {
+        Cluster model = new Cluster();
+        model.setName(NAMES[index]);
+        model.setDescription(DESCRIPTIONS[index]);
+        model.setDataCenter(new DataCenter());
+        model.setCpu(new CPU());
+        model.getCpu().setId("Intel Xeon");
+        return model;
+    }
+
+    protected List<Cluster> getCollection() {
+        return collection.list().getClusters();
+    }
+
+}


--
To view, visit http://gerrit.ovirt.org/11618
To unsubscribe, visit http://gerrit.ovirt.org/settings

Gerrit-MessageType: newchange
Gerrit-Change-Id: I6b27ef501324d890efbe0e8b914d9db47653f146
Gerrit-PatchSet: 1
Gerrit-Project: ovirt-engine
Gerrit-Branch: master
Gerrit-Owner: Ravi Nori <rn...@redhat.com>
_______________________________________________
Engine-patches mailing list
Engine-patches@ovirt.org
http://lists.ovirt.org/mailman/listinfo/engine-patches

Reply via email to