| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.ace.client.rest.itest; |
| |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createAssociationA2F; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createAssociationD2T; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createAssociationF2D; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createBundleArtifact; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createClient; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createConfiguration; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createDistribution; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createFeature; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createResourceProcessor; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createTarget; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createTmpConfigOnDisk; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.createWorkspace; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.deleteResources; |
| import static org.apache.ace.client.rest.itest.ClientRestUtils.ensureCleanStore; |
| import static org.apache.ace.test.utils.FileUtils.createEmptyBundle; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.URI; |
| import java.util.Date; |
| import java.util.Enumeration; |
| |
| import org.apache.ace.client.repository.helper.bundle.BundleHelper; |
| import org.apache.ace.http.listener.constants.HttpConstants; |
| import org.apache.ace.it.IntegrationTestBase; |
| import org.apache.ace.test.constants.TestConstants; |
| import org.apache.felix.dm.Component; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.Version; |
| import org.osgi.service.log.LogEntry; |
| import org.osgi.service.log.LogReaderService; |
| import org.osgi.service.useradmin.Role; |
| import org.osgi.service.useradmin.User; |
| import org.osgi.service.useradmin.UserAdmin; |
| |
| import com.google.gson.Gson; |
| import com.sun.jersey.api.client.Client; |
| import com.sun.jersey.api.client.ClientResponse; |
| import com.sun.jersey.api.client.UniformInterfaceException; |
| import com.sun.jersey.api.client.WebResource; |
| |
| public class RESTClientTest extends IntegrationTestBase { |
| // From: ConfigurationHelper (somehow directly using them here fails) |
| public static final String KEY_FILENAME = "filename"; |
| public static final String MIMETYPE = "application/xml:osgi-autoconf"; |
| public static final String PROCESSOR = "org.osgi.deployment.rp.autoconf"; |
| |
| private static final String STOREPATH = "generated/store"; |
| private static final String HOST = "http://localhost:" + TestConstants.PORT; |
| private static final Version V1_0_0 = new Version(1, 0, 0); |
| |
| private static boolean m_hasBeenSetup = false; |
| private static int m_testRunCount = 0; |
| private static int m_totalTestCount = 0; |
| |
| private volatile BundleContext m_context; |
| private volatile UserAdmin m_user; |
| private volatile LogReaderService m_logReader; |
| |
| /** |
| * Creates and deletes a number of workspaces. |
| */ |
| public void testCreateAndDeleteMultipleWorkspaces() throws Exception { |
| Client client = createClient(); |
| try { |
| int nr = 10; |
| for (int i = 0; i < nr; i++) { |
| WebResource w1 = createWorkspace(HOST, client); |
| w1.delete(); |
| } |
| WebResource[] w = new WebResource[nr]; |
| for (int i = 0; i < w.length; i++) { |
| w[i] = createWorkspace(HOST, client); |
| } |
| for (int i = 0; i < w.length; i++) { |
| w[i].delete(); |
| } |
| } |
| catch (Exception e) { |
| showBundles(); |
| showLog(); |
| throw e; |
| } |
| } |
| |
| /** |
| * Creates a new workspace, ensures it works correctly by asking for a list of entity types, then deletes the |
| * workspace again and ensures it's no longer available. |
| */ |
| public void testCreateAndDestroyRESTSession() throws Exception { |
| Client client = createClient(); |
| try { |
| WebResource r = client.resource(HOST.concat("/client/work")); |
| try { |
| r.post(String.class, ""); |
| fail("We should have been redirected to a new workspace."); |
| } |
| catch (UniformInterfaceException e) { |
| ClientResponse response = e.getResponse(); |
| URI location = response.getLocation(); |
| assertTrue(location.toString().startsWith(HOST.concat("/client/work/rest-"))); |
| WebResource r2 = client.resource(location); |
| r2.get(String.class); |
| r2.delete(); |
| try { |
| r2.get(String.class); |
| } |
| catch (UniformInterfaceException e2) { |
| assertEquals(404, e2.getResponse().getStatus()); |
| } |
| } |
| } |
| catch (Exception e) { |
| showBundles(); |
| showLog(); |
| throw e; |
| } |
| } |
| |
| /** |
| * Creates two bundles, artifacts an a single target and then in a loop creates two features that link to the bundle |
| * artifacts, one distribution and links all of that to the target. Even though we create a lot of entities that |
| * way, all of them will result in the two bundles being deployed to the target so we end up with only a single |
| * deployment version. |
| */ |
| public void testCreateLotsOfEntities() throws Exception { |
| Client client = createClient(); |
| Gson gson = new Gson(); |
| try { |
| int nr = 20; |
| File b1 = createEmptyBundle("bar.b1", V1_0_0); |
| File b2 = createEmptyBundle("bar.b2", V1_0_0); |
| |
| WebResource w1 = createWorkspace(HOST, client); |
| deleteResources(gson, w1); |
| createBundleArtifact(client, w1, "bar.a1", "bar.b1", "1.0.0", b1); |
| createBundleArtifact(client, w1, "bar.a2", "bar.b2", "1.0.0", b2); |
| createTarget(client, w1, "bar.t1"); |
| w1.post(); |
| w1.delete(); |
| |
| for (int i = 0; i < nr; i++) { |
| WebResource w2 = createWorkspace(HOST, client); |
| createAssociationA2F(client, w2, "bar.a1", "feat-1-" + i); |
| createAssociationA2F(client, w2, "bar.a2", "feat-2-" + i); |
| createFeature(client, w2, "feat-1-" + i); |
| createFeature(client, w2, "feat-2-" + i); |
| createAssociationF2D(client, w2, "feat-1-" + i, "dist-" + i); |
| createAssociationF2D(client, w2, "feat-2-" + i, "dist-" + i); |
| createDistribution(client, w2, "dist-" + i); |
| createAssociationD2T(client, w2, "dist-" + i, "bar.t1"); |
| w2.post(); |
| w2.delete(); |
| } |
| WebResource t1versions = client.resource(HOST.concat("/deployment/bar.t1/versions")); |
| assertEquals("1.0.0\n", t1versions.get(String.class)); |
| } |
| catch (Exception e) { |
| showBundles(); |
| showLog(); |
| throw e; |
| } |
| } |
| |
| /** |
| * Creates a workspace, three bundle artifacts that are associated to three features. The features are all grouped |
| * into a single distribution, and the distribution is associated with a target. This workspace is then committed |
| * and a new workspace is opened. From this new workspace, we read back the entities we committed before. Then, we |
| * check if this has indeed led to a new version of the software for this target. |
| */ |
| public void testDeployBundlesToTarget() throws Exception { |
| Client client = createClient(); |
| Gson gson = new Gson(); |
| try { |
| File b1 = createEmptyBundle("foo.b1", V1_0_0); |
| File b2 = createEmptyBundle("foo.b2", V1_0_0); |
| File b3 = createEmptyBundle("foo.b3", V1_0_0); |
| |
| WebResource w1 = createWorkspace(HOST, client); |
| deleteResources(gson, w1); |
| |
| WebResource a1 = createBundleArtifact(client, w1, "foo.a1", "foo.b1", "1.0.0", b1); |
| WebResource a2 = createBundleArtifact(client, w1, "foo.a2", "foo.b2", "1.0.0", b2); |
| WebResource a3 = createBundleArtifact(client, w1, "foo.a3", "foo.b3", "1.0.0", b3); |
| assertEntitiesExist(a1, a2, a3); |
| WebResource a1f1 = createAssociationA2F(client, w1, "foo.a1", "foo.f1"); |
| WebResource a2f2 = createAssociationA2F(client, w1, "foo.a2", "foo.f2"); |
| WebResource a3f3 = createAssociationA2F(client, w1, "foo.a3", "foo.f3"); |
| assertEntitiesExist(a1f1, a2f2, a3f3); |
| WebResource f1 = createFeature(client, w1, "foo.f1"); |
| WebResource f2 = createFeature(client, w1, "foo.f2"); |
| WebResource f3 = createFeature(client, w1, "foo.f3"); |
| assertEntitiesExist(f1, f2, f3); |
| WebResource f1d1 = createAssociationF2D(client, w1, "foo.f1", "foo.d1"); |
| WebResource f2d1 = createAssociationF2D(client, w1, "foo.f2", "foo.d1"); |
| WebResource f3d1 = createAssociationF2D(client, w1, "foo.f3", "foo.d1"); |
| assertEntitiesExist(f1d1, f2d1, f3d1); |
| WebResource d1 = createDistribution(client, w1, "foo.d1"); |
| assertEntitiesExist(d1); |
| WebResource d1t1 = createAssociationD2T(client, w1, "foo.d1", "foo.t1"); |
| assertEntitiesExist(d1t1); |
| WebResource t1 = createTarget(client, w1, "foo.t1"); |
| assertEntitiesExist(t1); |
| w1.post(); |
| w1.delete(); |
| |
| WebResource w2 = createWorkspace(HOST, client); |
| assertResources(gson, w2, "artifact", 3); |
| assertResources(gson, w2, "artifact2feature", 3); |
| assertResources(gson, w2, "feature", 3); |
| assertResources(gson, w2, "feature2distribution", 3); |
| assertResources(gson, w2, "distribution", 1); |
| assertResources(gson, w2, "distribution2target", 1); |
| assertResources(gson, w2, "target", 1); |
| w2.post(); |
| w2.delete(); |
| |
| WebResource t1versions = client.resource(HOST.concat("/deployment/foo.t1/versions")); |
| assertEquals("1.0.0\n", t1versions.get(String.class)); |
| } |
| catch (Exception e) { |
| showBundles(); |
| showLog(); |
| throw e; |
| } |
| } |
| |
| public void testDeployConfigurationTemplateToTargets() throws Exception { |
| Client client = createClient(); |
| Gson gson = new Gson(); |
| try { |
| File bundle = createEmptyBundle("rp", V1_0_0, BundleHelper.KEY_RESOURCE_PROCESSOR_PID, PROCESSOR, "DeploymentPackage-Customizer", "true"); |
| File config = createTmpConfigOnDisk( |
| "<MetaData xmlns='http://www.osgi.org/xmlns/metatype/v1.0.0'>\n" + |
| " <OCD name='ocd' id='ocd'>\n" + |
| " <AD id='name' type='STRING' cardinality='0' />\n" + |
| " </OCD>\n" + |
| " <Designate pid='simple' bundle='osgi-dp:location'>\n" + |
| " <Object ocdref='ocd'>\n" + |
| " <Attribute adref='name'>\n" + |
| " <Value><![CDATA[${context.test}]]></Value>\n" + |
| " </Attribute>\n" + |
| " </Object>\n" + |
| " </Designate>\n" + |
| "</MetaData>\n" |
| ); |
| |
| WebResource w1 = createWorkspace(HOST, client); |
| deleteResources(gson, w1); |
| |
| createResourceProcessor(client, w1, "rp", "resourceprocessor", "1.0.0", bundle.toURI().toURL().toString(), BundleHelper.MIMETYPE, PROCESSOR); |
| createConfiguration(client, w1, "c1", config.toURI().toURL().toString(), MIMETYPE, "template.xml", PROCESSOR); |
| createAssociationA2F(client, w1, "c1", "f4"); |
| createFeature(client, w1, "f4"); |
| createAssociationF2D(client, w1, "f4", "d2"); |
| createDistribution(client, w1, "d2"); |
| createAssociationD2T(client, w1, "d2", "t4"); |
| createAssociationD2T(client, w1, "d2", "t5"); |
| createAssociationD2T(client, w1, "d2", "t6"); |
| createTarget(client, w1, "t4", "test", "one"); |
| createTarget(client, w1, "t5", "test", "two"); |
| createTarget(client, w1, "t6", "test", "three"); |
| w1.post(); |
| w1.delete(); |
| |
| WebResource w2 = createWorkspace(HOST, client); |
| assertResources(gson, w2, "artifact", 1); |
| assertResources(gson, w2, "artifact2feature", 1); |
| assertResources(gson, w2, "feature", 1); |
| assertResources(gson, w2, "feature2distribution", 1); |
| assertResources(gson, w2, "distribution", 1); |
| assertResources(gson, w2, "distribution2target", 3); |
| assertResources(gson, w2, "target", 3); |
| w2.delete(); |
| |
| WebResource t1versions = client.resource(HOST.concat("/deployment/t4/versions")); |
| assertEquals("1.0.0\n", t1versions.get(String.class)); |
| } |
| catch (Exception e) { |
| showBundles(); |
| showLog(); |
| throw e; |
| } |
| } |
| |
| @Override |
| protected void configureAdditionalServices() throws Exception { |
| // there is some setup we only want to do once, before the first test we run, and since we cannot |
| // predict which one that is, we use a static flag |
| if (!m_hasBeenSetup) { |
| setAutoDeleteTrackedConfigurations(false); |
| // count the number of tests, so we can determine when to clean up... |
| m_totalTestCount = getTestCount(); |
| |
| ensureCleanStore(STOREPATH); |
| configureServer(); |
| createServerUser(); |
| m_hasBeenSetup = true; |
| } |
| |
| m_testRunCount++; |
| } |
| |
| @Override |
| protected void doTearDown() throws Exception { |
| if (m_testRunCount == m_totalTestCount) { |
| setAutoDeleteTrackedConfigurations(true); |
| } |
| } |
| |
| @Override |
| protected Component[] getDependencies() { |
| return new Component[] { |
| createComponent() |
| .setImplementation(this) |
| .add(createServiceDependency().setService(UserAdmin.class).setRequired(true)) |
| .add(createServiceDependency().setService(LogReaderService.class).setRequired(true)) |
| }; |
| } |
| |
| /** Asserts that a list of entities exist by trying to GET them. */ |
| private void assertEntitiesExist(WebResource... entities) throws Exception { |
| for (WebResource r : entities) { |
| System.out.println(r.getURI().toString()); |
| r.get(String.class); |
| } |
| } |
| |
| /** |
| * Asserts that a collection of resources exist by trying to GET the list, validate the number of items and finally |
| * GET each item. |
| */ |
| private void assertResources(Gson gson, WebResource w2, String type, int number) { |
| String[] artifacts = gson.fromJson(w2.path(type).get(String.class), String[].class); |
| assertEquals("Wrong number of " + type + "s", number, artifacts.length); |
| for (String id : artifacts) { |
| w2.path(type + "/" + id).get(String.class); |
| } |
| } |
| |
| private void configureServer() throws IOException { |
| configure("org.apache.ace.client.repository", |
| "obrlocation", HOST.concat("/obr/")); |
| |
| configure("org.apache.ace.client.rest", |
| "org.apache.ace.server.servlet.endpoint", "/client", |
| "repository.url", HOST.concat("/repository"), |
| "authentication.enabled", "false"); |
| |
| configure("org.apache.ace.deployment.servlet", |
| "org.apache.ace.server.servlet.endpoint", "/deployment", |
| "authentication.enabled", "false"); |
| |
| configure("org.apache.ace.repository.servlet.RepositoryServlet", |
| "org.apache.ace.server.servlet.endpoint", "/repository", |
| "authentication.enabled", "false"); |
| |
| configure("org.apache.ace.obr.servlet", |
| "org.apache.ace.server.servlet.endpoint", "/obr", |
| "authentication.enabled", "false"); |
| |
| configure("org.apache.ace.obr.storage.file", |
| "fileLocation", STOREPATH); |
| |
| configure("org.apache.ace.deployment.provider.repositorybased", |
| "url", HOST.concat("/repository"), |
| "name", "deployment", |
| "customer", "apache"); |
| |
| configure("org.apache.ace.discovery.property", |
| "serverURL", HOST); |
| |
| configure("org.apache.ace.identification.property", |
| "targetID", "target-test"); |
| |
| configure("org.apache.ace.client.workspace", |
| "repository.url", HOST.concat("/repository"), |
| "authentication.enabled", "false", |
| "user.name", "d", |
| "customer.name", "apache", |
| "store.repository.name", "shop", |
| "distribution.repository.name", "target", |
| "deployment.repository.name", "deployment"); |
| |
| configureFactory("org.apache.ace.log.server.servlet.factory", |
| "name", "auditlog", |
| HttpConstants.ENDPOINT, "/auditlog", |
| "authentication.enabled", "false"); |
| |
| configureFactory("org.apache.ace.log.server.store.factory", |
| "name", "auditlog"); |
| |
| configureFactory("org.apache.ace.server.repository.factory", |
| "name", "user", |
| "customer", "apache", |
| "master", "true"); |
| |
| configureFactory("org.apache.ace.server.repository.factory", |
| "name", "shop", |
| "customer", "apache", |
| "master", "true"); |
| |
| configureFactory("org.apache.ace.server.repository.factory", |
| "name", "deployment", |
| "customer", "apache", |
| "master", "true"); |
| |
| configureFactory("org.apache.ace.server.repository.factory", |
| "name", "target", |
| "customer", "apache", |
| "master", "true"); |
| |
| configureFactory("org.apache.ace.server.repository.factory", |
| "name", "users", |
| "customer", "apache", |
| "master", "true"); |
| |
| configure("org.apache.ace.configurator.useradmin.task.UpdateUserAdminTask", |
| "repositoryLocation", HOST.concat("/repository"), |
| "repositoryCustomer", "apache", |
| "repositoryName", "user"); |
| } |
| |
| /** Create a user so we can log in to the server. */ |
| private void createServerUser() { |
| User user = (User) m_user.createRole("d", Role.USER); |
| user.getProperties().put("username", "d"); |
| user.getCredentials().put("password", "f"); |
| } |
| |
| /** Shows all bundles in the framework. */ |
| private void showBundles() { |
| for (Bundle b : m_context.getBundles()) { |
| System.out.println(" * [" + b.getBundleId() + "] " + b.getState() + " - " + b.getSymbolicName() + " " + b.getVersion()); |
| } |
| } |
| |
| /** Shows all log messages in the OSGi log service. */ |
| private void showLog() { |
| Enumeration<?> e = m_logReader.getLog(); |
| System.out.println("Log:"); |
| while (e.hasMoreElements()) { |
| LogEntry entry = (LogEntry) e.nextElement(); |
| System.out.println(" * " + (new Date(entry.getTime())) + " - " + entry.getMessage() + " - " + entry.getBundle().getBundleId() + " - " + entry.getException()); |
| if (entry.getException() != null) { |
| entry.getException().printStackTrace(); |
| } |
| } |
| } |
| } |