org.jboss.arquillian.container.spi.client.container.LifecycleException Java Examples

protected void downloadTomcat(final File catalinaDirectory, final String tomcatVersion, final String defaultTempDir) throws LifecycleException {
    String source = null;

    try {
        int v = Integer.parseInt(tomcatVersion.substring(0, tomcatVersion.indexOf('.')));
        source = "http://archive.apache.org/dist/tomcat/tomcat-" + v + "/v" + v + "/bin/apache-tomcat-" + tomcatVersion + ".zip";
    } catch (final Exception e) {
        // no-op
    }

    if (source == null) {
        throw new LifecycleException("Unable to find URL for Tomcat " + tomcatVersion);
    }

    final File zipFile = Setup.downloadFile("org.apache.tomcat:tomcat:" + tomcatVersion + ":zip", source, defaultTempDir);
    Zips.unzip(zipFile, catalinaDirectory);
}
 

@Override
public void stop() throws LifecycleException {
    try {
        final Socket socket = new Socket(configuration.getStopHost(), configuration.getStopPort());
        final OutputStream out = socket.getOutputStream();
        out.write((configuration.getStopCommand() + Character.toString((char) 0)).getBytes());

        waitForShutdown(socket, 10);
    } catch (final Exception e) {
        throw new LifecycleException("Unable to stop TomEE", e);
    } finally {
        if (this.configuration.isUnsafeEjbd() && "-".equals(System.getProperty("tomee.serialization.class.blacklist"))) {
            System.clearProperty("tomee.serialization.class.blacklist");
        }
    }
}
 

@Override
public void stop() throws LifecycleException {
    try {
        server.stop();
    } catch (Exception e) {
        throw new LifecycleException("Unable to stop Jetty", e);
    }
    log.info("App Server stopped.");
}
 

@Override
public void stop() throws LifecycleException {
    if (isRemoteMode()) {
        log.info("Skip stopping undertow. We are in remote mode");
        return;
    }

    log.info("Stopping auth server.");
    sessionFactory.close();
    undertow.stop();
}
 

private void destroyKarafProcess() throws LifecycleException {
    if (process != null) {
        process.destroy();
        try {
            process.waitFor();
        } catch (InterruptedException e) {
            throw new LifecycleException("Cannot start Karaf container", e);
        }
    }
}
 

@Override
public void stop() throws LifecycleException {
    try {
        super.stop();
    } catch (LifecycleException ex) {
        log.info("Couldn't uninstall arquillian bundle. This should be non-blocking issue, proceeding with destroying karaf process.");
    }

    destroyKarafProcess();
}
 

@Override
public void stop() throws LifecycleException {
    container.destroy();
    try {
        container.waitFor(10, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
        container.destroyForcibly();
    }
}
 

@Override
public void start() throws LifecycleException {
    try {
        container = startContainer();
        waitForReadiness();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

public void startAuthContainer(@Observes(precedence = 0) StartSuiteContainers event) {
    //frontend-only (either load-balancer or auth-server)
    log.debug("Starting auth server before suite");

    try {
        startContainerEvent.fire(new StartContainer(suiteContext.getAuthServerInfo().getArquillianContainer()));
    } catch (Exception e) {
        // It is expected that server startup fails with migration-mode-manual
        if (e instanceof LifecycleException && handleManualMigration()) {
            log.info("Set log file checker to end of file.");
            try {
                // this will mitigate possible issues in manual server update tests
                // when the auth server started with not updated DB
                // e.g. Caused by: org.keycloak.ServerStartupError: Database not up-to-date, please migrate database with
                if (suiteContext.getServerLogChecker() == null) {
                    setServerLogChecker();
                }
                suiteContext.getServerLogChecker()
                    .updateLastCheckedPositionsOfAllFilesToEndOfFile();
            } catch (IOException ioe) {
                log.warn("Server log checker failed to update position:", ioe);
            }
            log.info("Starting server again after manual DB migration was finished");
            startContainerEvent.fire(new StartContainer(suiteContext.getAuthServerInfo().getArquillianContainer()));
            return;
        }

        // Just re-throw the exception
        throw e;
    }
}
 

@Override
public void stop() throws LifecycleException {
    ArquillianUtil.undeploy(this, containerArchives);

    // only stop the container if we started it
    if (shutdown) {
        try {
            Setup.removeArquillianBeanDiscoverer(tomeeHome);
            container.destroy();
        } finally {
            resetSerialization();
        }
    }
}
 

@Override
public void stop() throws LifecycleException {
    try {
        this.container.stop();
    } catch (final Exception e) {
        throw new LifecycleException("Unable to stop server", e);
    } finally {
        resetSerialization();
    }
}
 

@Override
public void start() throws LifecycleException {
    try {
        this.container.start();
        SystemInstance.get().setComponent(AdditionalBeanDiscoverer.class, new TestClassDiscoverer());
        // this property is not mandatory by default but depending the protocol it can be relevant so adding it by default
        SystemInstance.get().setProperty("org.apache.openejb.servlet.filters", ArquillianFilterRunner.class.getName() + "=/ArquillianServletRunner");
    } catch (final Exception e) {
        throw new LifecycleException("Something went wrong", e);
    }
}
 

@Override
public void stop() throws LifecycleException {
    // only stop the container if we started it
    if (shutdown) {
        try {
            Setup.removeArquillianBeanDiscoverer(openejbHome);
            container.destroy();
        } finally {
            resetSerialization();
        }
    }
}
 

private void cleanup()
{
   try
   {
      stop();
      start();
   }
   catch (LifecycleException e)
   {
      throw new RuntimeException("Failed to clean up after test case.", e);
   }
}
 

public void stop() throws LifecycleException {
    lifecycle(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            delegate.stop();
            return null;
        }
    });
}
 

public void start() throws LifecycleException {
    lifecycle(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            delegate.start();
            return null;
        }
    });
}
 

@Override
public synchronized ProtocolMetaData deploy(Archive<?> archive) throws DeploymentException {
    BootstrapUtil.convertSwarmSystemPropertiesToThorntail();

    StartupTimeout startupTimeout = this.testClass.getAnnotation(StartupTimeout.class);
    if (startupTimeout != null) {
        setTimeout(startupTimeout.value());
    }

    this.delegateContainer = new UberjarSimpleContainer(this.containerContext.get(), this.deploymentContext.get(), this.testClass);

    try {
        this.delegateContainer
                .setJavaVmArguments(this.getJavaVmArguments())
                .requestedMavenArtifacts(this.requestedMavenArtifacts)
                .start(archive);
        // start wants to connect to the remote container, which isn't up until now, so
        // we override start above and call it here instead
        super.start();

        ProtocolMetaData metaData = new ProtocolMetaData();
        metaData.addContext(createDeploymentContext(archive.getId()));

        return metaData;
    } catch (Throwable e) {
        if (e instanceof LifecycleException) {
            e = e.getCause();
        }
        throw new DeploymentException(e.getMessage(), e);
    }
}
 

public void setup(final ContainerConfiguration configuration) throws LifecycleException {
    lifecycle(new Callable<Void>() {
        @SuppressWarnings("unchecked")
        @Override
        public Void call() throws Exception {
            delegate.setup(configuration);
            return null;
        }
    });
}
 

@Override
public void start() throws LifecycleException {
    // Open up remote resources
    try {

        final long startTime = System.currentTimeMillis();
        final int secondsToWait = this.timeout;
        final long acceptableTime = startTime + 1000 * secondsToWait; // 10 seconds from now
        Socket socket = null;
        while (true) {
            try {
                // TODO Security Action
                socket = new Socket(remoteAddress.getHostString(), remoteAddress.getPort());
                if (log.isLoggable(Level.FINEST)) {
                    log.finest("Got connection to " + remoteAddress.toString());
                }
                break;
            } catch (final ConnectException ce) {
                if (log.isLoggable(Level.FINEST)) {
                    log.finest("No connection yet available to remote process");
                }
                final long currentTime = System.currentTimeMillis();
                // Time expired?
                if (currentTime > acceptableTime) {
                    throw new LifecycleException("Could not connect to the server at "
                                                         + remoteAddress.getHostString() + ":" + remoteAddress.getPort() + " in the allotted "
                                                         + secondsToWait + "s", ce);
                }
                // Sleep and try again
                try {
                    Thread.sleep(200);
                } catch (final InterruptedException e) {
                    Thread.interrupted();
                    throw new RuntimeException("No one should be interrupting us while we're waiting to connect", e);
                }
            }
        }
        assert socket != null : "Socket should have been connected";
        this.socket = socket;
        final OutputStream socketOutstream = socket.getOutputStream();
        this.socketOutstream = socketOutstream;
        final PrintWriter writer = new PrintWriter(new OutputStreamWriter(socketOutstream, WireProtocol.CHARSET),
                                                   true);
        this.writer = writer;
        final InputStream socketInstream = socket.getInputStream();
        this.socketInstream = socketInstream;
        final BufferedReader reader = new BufferedReader(new InputStreamReader(socketInstream));
        this.reader = reader;

        final StringBuilder builder = new StringBuilder();
        builder.append(WireProtocol.COMMAND_CHECK_DEPLOYMENT);
        builder.append(WireProtocol.COMMAND_EOF_DELIMITER);
        final String checkCommand = builder.toString();
        // Request
        writer.write(checkCommand);
        writer.flush();

        Throwable error = null;
        try {
            final ObjectInputStream response = new ObjectInputStream(socketInstream);
            error = (Throwable) response.readObject();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        if (error != null) {
            throw new LifecycleException(error.getMessage(), error);
        }
    } catch (final IOException ioe) {
        this.closeRemoteResources();
        throw new LifecycleException("Could not open connection to remote process", ioe);
    }

}
 

@Override
public void start() throws LifecycleException {
}
 

@Override
public void stop() throws LifecycleException {
    undertow.stop();
    log.info("App Server stopped.");
}
 

@Override
public void stop() throws LifecycleException {
    log.info("Going to stop loadbalancer");
    this.container.stop();
}
 

@Override
public void start() throws LifecycleException {
    this.container = new SimpleUndertowLoadBalancer(configuration.getBindAddress(), configuration.getBindHttpPort(), configuration.getBindHttpsPort(), configuration.getNodes());
    this.container.start();
}
 

@Override
public void stop() throws LifecycleException {
}
 

@Override
public void start() throws LifecycleException {
    // No-op
}
 

@Override
public void stop() throws LifecycleException {
    // No-op
}
 

private void testRealmExportImport() throws LifecycleException {
    testingClient.testing().exportImport().setAction(ExportImportConfig.ACTION_EXPORT);
    testingClient.testing().exportImport().setRealmName("test");

    testingClient.testing().exportImport().runExport();

    List<ComponentRepresentation> components = adminClient.realm("test").components().query();
    KeysMetadataRepresentation keyMetadata = adminClient.realm("test").keys().getKeyMetadata();
    String sampleRealmRoleId = adminClient.realm("test").roles().get("sample-realm-role").toRepresentation().getId();
    Map<String, List<String>> roleAttributes = adminClient.realm("test").roles().get("attribute-role").toRepresentation().getAttributes();
    String testAppId = adminClient.realm("test").clients().findByClientId("test-app").get(0).getId();
    String sampleClientRoleId = adminClient.realm("test").clients().get(testAppId).roles().get("sample-client-role").toRepresentation().getId();
    String sampleClientRoleAttribute = adminClient.realm("test").clients().get(testAppId).roles().get("sample-client-role").toRepresentation().getAttributes().get("sample-client-role-attribute").get(0);

    // Delete some realm (and some data in admin realm)
    adminClient.realm("test").remove();

    Assert.assertNames(adminClient.realms().findAll(), "test-realm", "master");

    assertNotAuthenticated("test", "test-user@localhost", "password");
    assertNotAuthenticated("test", "user1", "password");
    assertNotAuthenticated("test", "user2", "password");
    assertNotAuthenticated("test", "user3", "password");
    assertNotAuthenticated("test", "user-requiredOTP", "password");
    assertNotAuthenticated("test", "user-requiredWebAuthn", "password");

    // Configure import
    testingClient.testing().exportImport().setAction(ExportImportConfig.ACTION_IMPORT);

    testingClient.testing().exportImport().runImport();

    // Ensure data are imported back, but just for "test" realm
    Assert.assertNames(adminClient.realms().findAll(), "master", "test", "test-realm");

    assertAuthenticated("test", "test-user@localhost", "password");
    assertAuthenticated("test", "user1", "password");
    assertAuthenticated("test", "user2", "password");
    assertAuthenticated("test", "user3", "password");
    assertAuthenticated("test", "user-requiredOTP", "password");
    assertAuthenticated("test", "user-requiredWebAuthn", "password");

    RealmResource testRealmRealm = adminClient.realm("test");
    assertTrue(testRealmRealm.users().search("user-requiredOTP").get(0)
            .getRequiredActions().get(0).equals(UserModel.RequiredAction.CONFIGURE_TOTP.name()));
    assertTrue(testRealmRealm.users().search("user-requiredWebAuthn").get(0)
            .getRequiredActions().get(0).equals(WebAuthnRegisterFactory.PROVIDER_ID));


    List<ComponentRepresentation> componentsImported = adminClient.realm("test").components().query();
    assertComponents(components, componentsImported);

    KeysMetadataRepresentation keyMetadataImported = adminClient.realm("test").keys().getKeyMetadata();
    assertEquals(keyMetadata.getActive(), keyMetadataImported.getActive());

    String importedSampleRealmRoleId = adminClient.realm("test").roles().get("sample-realm-role").toRepresentation().getId();
    assertEquals(sampleRealmRoleId, importedSampleRealmRoleId);

    Map<String, List<String>> importedRoleAttributes = adminClient.realm("test").roles().get("attribute-role").toRepresentation().getAttributes();
    Assert.assertRoleAttributes(roleAttributes, importedRoleAttributes);

    String importedSampleClientRoleId = adminClient.realm("test").clients().get(testAppId).roles().get("sample-client-role").toRepresentation().getId();
    assertEquals(sampleClientRoleId, importedSampleClientRoleId);

    String importedSampleClientRoleAttribute = adminClient.realm("test").clients().get(testAppId).roles().get("sample-client-role").toRepresentation().getAttributes().get("sample-client-role-attribute").get(0);
    assertEquals(sampleClientRoleAttribute, importedSampleClientRoleAttribute);

    checkEventsConfig(adminClient.realm("test").getRealmEventsConfig());
}
 

private void testFullExportImport() throws LifecycleException {
    testingClient.testing().exportImport().setAction(ExportImportConfig.ACTION_EXPORT);
    testingClient.testing().exportImport().setRealmName("");

    testingClient.testing().exportImport().runExport();

    removeRealm("test");
    removeRealm("test-realm");
    Assert.assertNames(adminClient.realms().findAll(), "master");

    Map<String, RequiredActionProviderRepresentation> requiredActionsBeforeImport = new HashMap<>();
    adminClient.realm("master").flows().getRequiredActions().stream()
            .forEach(action -> {
                requiredActionsBeforeImport.put(action.getAlias(), action);
            });

    assertNotAuthenticated("test", "test-user@localhost", "password");
    assertNotAuthenticated("test", "user1", "password");
    assertNotAuthenticated("test", "user2", "password");
    assertNotAuthenticated("test", "user3", "password");
    assertNotAuthenticated("test", "user-requiredOTP", "password");
    assertNotAuthenticated("test", "user-requiredWebAuthn", "password");


    // Configure import
    testingClient.testing().exportImport().setAction(ExportImportConfig.ACTION_IMPORT);

    testingClient.testing().exportImport().runImport();

    // Ensure data are imported back
    Assert.assertNames(adminClient.realms().findAll(), "master", "test", "test-realm");

    assertAuthenticated("test", "test-user@localhost", "password");
    assertAuthenticated("test", "user1", "password");
    assertAuthenticated("test", "user2", "password");
    assertAuthenticated("test", "user3", "password");
    assertAuthenticated("test", "user-requiredOTP", "password");
    assertAuthenticated("test", "user-requiredWebAuthn", "password");

    RealmResource testRealmRealm = adminClient.realm("test");
    assertTrue(testRealmRealm.users().search("user-requiredOTP").get(0)
            .getRequiredActions().get(0).equals(UserModel.RequiredAction.CONFIGURE_TOTP.name()));
    assertTrue(testRealmRealm.users().search("user-requiredWebAuthn").get(0)
            .getRequiredActions().get(0).equals(WebAuthnRegisterFactory.PROVIDER_ID));

    // KEYCLOAK-6050 Check SMTP password is exported/imported
    assertEquals("secret", testingClient.server("test").fetch(RunHelpers.internalRealm()).getSmtpServer().get("password"));

    // KEYCLOAK-8176 Check required actions are exported/imported properly
    List<RequiredActionProviderRepresentation> requiredActionsAfterImport = adminClient.realm("master").flows().getRequiredActions();
    assertThat(requiredActionsAfterImport.size(), is(equalTo(requiredActionsBeforeImport.size())));
    requiredActionsAfterImport.stream()
            .forEach((action) -> {
                RequiredActionProviderRepresentation beforeImportAction = requiredActionsBeforeImport.get(action.getAlias());
                assertThat(action.getName(), is(equalTo(beforeImportAction.getName())));
                assertThat(action.getProviderId(), is(equalTo(beforeImportAction.getProviderId())));
                assertThat(action.getPriority(), is(equalTo(beforeImportAction.getPriority())));
            });
}
 

@After
public void clearExportImportProps() throws LifecycleException {
    clearExportImportProperties();
}
 

@Override
public void start() throws LifecycleException {
    // We don't start Piranha separately. Start and Deploy is one step.
}