| <%# |
| * 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 <%= polygene.packageName %>.app; |
| |
| import <%= polygene.packageName %>.bootstrap.<%= polygene.name %>ApplicationAssembler; |
| |
| import <%= polygene.packageName %>.bootstrap.config.ConfigModule; |
| import <%= polygene.packageName %>.bootstrap.config.ConfigurationLayer; |
| import javax.json.Json; |
| import javax.json.JsonWriter; |
| |
| import org.apache.polygene.api.structure.Application; |
| import org.apache.polygene.api.structure.ApplicationDescriptor; |
| import org.apache.polygene.bootstrap.ApplicationAssembly; |
| import org.apache.polygene.bootstrap.AssemblyException; |
| import org.apache.polygene.bootstrap.ModuleAssembly; |
| import org.apache.polygene.bootstrap.layered.LayeredApplicationAssembler; |
| import org.apache.polygene.tools.model.descriptor.ApplicationDetailDescriptor; |
| import org.apache.polygene.tools.model.descriptor.ApplicationDetailDescriptorBuilder; |
| <% |
| polygene.needsDelayChecker = false; |
| polygene.needsDocker = ['Cassandra', 'MySQL', 'PostgreSQL', 'Redis', 'Riak', 'MongoDB'].indexOf(polygene.entitystore) != -1 || ['Memcache'].indexOf(polygene.caching) != -1; |
| |
| if( polygene.entitystore === 'MySQL' ) { |
| %>import java.util.HashMap; |
| <% |
| } |
| if( polygene.entitystore !== 'Memory' && polygene.entitystore !== 'Preferences' ) { |
| if( polygene.entitystore.indexOf('SQL') < 0 ) { |
| %>import org.apache.polygene.entitystore.<%= polygene.entitystore.toLowerCase() %>.<%= polygene.entitystore %>EntityStoreConfiguration; |
| <% } else { |
| %>import org.apache.polygene.entitystore.sql.SQLEntityStoreConfiguration; |
| <% |
| } |
| } |
| if( polygene.caching === 'Memcache' ) { |
| %>import org.apache.polygene.cache.memcache.MemcacheConfiguration; |
| <% |
| } |
| if( polygene.needsDocker ) { |
| %> |
| import com.spotify.docker.client.DefaultDockerClient; |
| import pl.domzal.junit.docker.rule.DockerRule; |
| import pl.domzal.junit.docker.rule.DockerRuleBuilder; |
| import pl.domzal.junit.docker.rule.WaitFor; |
| import pl.domzal.junit.docker.rule.wait.StartCondition; |
| import pl.domzal.junit.docker.rule.wait.StartConditionCheck; |
| |
| import org.junit.rules.TestRule; |
| import org.junit.runner.Description; |
| import org.junit.runners.model.Statement; |
| import org.junit.Assume; |
| import org.junit.ClassRule; |
| <% |
| } |
| %> |
| import org.junit.Ignore; |
| import org.junit.Test; |
| |
| public class BootstrapTest |
| { |
| @Test @Ignore( "TODO: Testcase doesn't work for all combinations yet. Docker issues?" ) |
| public void applicationBootstrapSucceeds() |
| throws Exception |
| { |
| <%= polygene.name %>Launcher launcher = new <%= polygene.name %>Launcher() |
| { |
| @Override |
| protected LayeredApplicationAssembler createApplicationAssembler() |
| throws AssemblyException |
| { |
| <% if( polygene.hasFeature( 'security' ) ) { |
| %> DevelopmentKeyManagement.initializeKeyStore(); |
| <% } |
| %> return new <%= polygene.name %>ApplicationAssembler( "LaunchTest", "0", Application.Mode.development, BootstrapTest.this::setupTest ) |
| { |
| @Override |
| protected void onModelCreated( ApplicationDescriptor model ) |
| { |
| ApplicationDetailDescriptor modelDescription = ApplicationDetailDescriptorBuilder.createApplicationDetailDescriptor( model ); |
| System.out.println( "Application Model" ); |
| JsonWriter writer = Json.createWriter( System.out ); |
| System.out.println(); |
| writer.writeObject( modelDescription.toJson() ); |
| super.onModelCreated( model ); |
| } |
| }; |
| } |
| }; |
| launcher.initialize(); |
| System.out.println("Application Launched..."); |
| // Thread.sleep( 3600000L ); |
| launcher.shutdown(); |
| } |
| |
| private void setupTest( ApplicationAssembly assembly ) |
| { |
| entityStoreSetup( assembly ); |
| <% |
| if( polygene.caching === 'Memcache' ) { |
| %> |
| cacheSetup( assembly ); |
| <% |
| } |
| %> |
| } |
| <% |
| if( polygene.entitystore === 'Cassandra' ) { |
| %> |
| private void entityStoreSetup( ApplicationAssembly assembly ) |
| { |
| ModuleAssembly config = assembly.layer( ConfigurationLayer.NAME ).module( ConfigModule.NAME ); |
| CassandraEntityStoreConfiguration defaults = config.forMixin( CassandraEntityStoreConfiguration.class ).declareDefaults(); |
| String host = ES_DOCKER.getDockerHost(); |
| int port = Integer.valueOf( ES_DOCKER.getExposedContainerPort( "9042/tcp" ) ); |
| System.out.println("Cassandra: " + host + ":" + port); |
| defaults.hostnames().set( host + ':' + port ); |
| defaults.createIfMissing().set( true ); |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule ES_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "cassandra:3.10" ) |
| .publishAllPorts( true ) |
| .waitForTimeout( 120 ) |
| .waitFor( WaitFor.logMessageSequence( "Starting listening for CQL clients" ) ) ); |
| <% } |
| if( polygene.entitystore === 'DerbySQL' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'File' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'Geode' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'H2SQL' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'Hazelcast' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'JClouds' ) { |
| %> |
| private void entityStoreSetup( ApplicationAssembly assembly ) |
| { |
| // Assembly use a transient JClouds provider |
| } |
| <% } |
| if( polygene.entitystore === 'Jdbm' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'LevelDB' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'Memory' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'MongoDB' ) { |
| %> |
| private void entityStoreSetup( ApplicationAssembly assembly ) |
| { |
| ModuleAssembly config = assembly.layer( ConfigurationLayer.NAME ).module( ConfigModule.NAME ); |
| MongoDBEntityStoreConfiguration mongoConfig = config.forMixin( MongoDBEntityStoreConfiguration.class ).declareDefaults(); |
| mongoConfig.hostname().set( ES_DOCKER.getDockerHost() ); |
| mongoConfig.port().set( Integer.valueOf( ES_DOCKER.getExposedContainerPort( "27017/tcp" ) ) ); |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule ES_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "mongo:3.5.8" ) |
| .expose( "27017" ) |
| .waitForTimeout( 120 ) |
| .waitFor( WaitFor.tcpPort(27017) ) ); |
| <% } |
| if( polygene.entitystore === 'MySQL' ) { |
| polygene.needsDelayChecker = true; |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule ES_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "mariadb:10.1.21" ) |
| .publishAllPorts( true ) |
| .waitForTimeout( 120 ) |
| .env("MYSQL_ROOT_PASSWORD", "") |
| .env("MYSQL_ALLOW_EMPTY_PASSWORD", "yes") |
| .env("MYSQL_DATABASE", "jdbc_test_db") |
| .env("MYSQL_ROOT_HOST", "172.17.0.1") |
| // .waitFor( WaitFor.logMessageSequence( "mysqld: ready for connections" ) ) TODO: add this after next release of tdomzal/junit-docker-rule |
| .waitFor( new DelayChecker( 30000L ) ) ); |
| <% } |
| if( polygene.entitystore === 'PostgreSQL' ) { |
| polygene.needsDelayChecker = true; |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule ES_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "<%= polygene.packagename %>-postgresql" ) |
| .publishAllPorts( true ) |
| .waitForTimeout( 120 ) |
| .waitFor( WaitFor.logMessageSequence( "PostgreSQL init process complete; ready for start up." ) ) |
| .waitFor( new DelayChecker( 3000L ) ) ); |
| <% } |
| if( polygene.entitystore === 'Preferences' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.entitystore === 'Redis' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule ES_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "redis:3.2.8-alpine" ) |
| .publishAllPorts( true ) |
| .waitForTimeout( 120 ) |
| .waitFor( pl.domzal.junit.docker.rule.WaitFor.tcpPort( 6379 ) ) ); |
| <% } |
| if( polygene.entitystore === 'Riak' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule ES_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "basho/riak-kv:ubuntu-2.2.3" ) |
| .publishAllPorts( true ) |
| .waitForTimeout( 120 ) |
| .waitFor( WaitFor.logMessageSequence( "riak_auth_mods started on node" ) ) ); |
| <% } |
| if( polygene.entitystore === 'SQLite' ) { |
| %> |
| private void entityStoreSetup(ApplicationAssembly assembly ) |
| { |
| } |
| <% } |
| if( polygene.caching === 'Memcache' ) { |
| %> |
| |
| private void cacheSetup( ApplicationAssembly assembly ) |
| { |
| ModuleAssembly config = assembly.layer( ConfigurationLayer.NAME ).module( ConfigModule.NAME ); |
| |
| MemcacheConfiguration memcacheConfig = config.forMixin( MemcacheConfiguration.class ).declareDefaults(); |
| memcacheConfig.addresses().set( CACHE_DOCKER.getDockerHost() + ":" + CACHE_DOCKER.getExposedContainerPort( "11211/tcp" ) ); |
| } |
| |
| @ClassRule |
| public static final OptionalDockerRule CACHE_DOCKER = new OptionalDockerRule( DockerRule.builder() |
| .imageName( "memcached:1.4.36-alpine" ) |
| .expose( "11211" ) |
| .waitForTimeout( 120 ) |
| .waitFor( WaitFor.tcpPort( 11211 ) ) ); |
| |
| <% |
| } |
| %> |
| |
| <% |
| if( polygene.needsDocker ) { |
| %> |
| /** |
| * This JUnit Rule will skip tests if no Docker service is available. |
| */ |
| public static class OptionalDockerRule implements TestRule |
| { |
| private final DockerRuleBuilder dockerRuleBuilder; |
| private DockerRule dockerRule; |
| |
| private OptionalDockerRule( DockerRuleBuilder dockerRuleBuilder ) |
| { |
| this.dockerRuleBuilder = dockerRuleBuilder; |
| } |
| |
| @Override |
| public Statement apply( Statement base, Description description ) |
| { |
| try |
| { |
| DefaultDockerClient.fromEnv().build().listImages(); |
| } |
| catch( Throwable ex ) |
| { |
| Assume.assumeNoException( ex ); |
| } |
| |
| dockerRule = dockerRuleBuilder.build(); |
| return dockerRule.apply( base, description ); |
| } |
| |
| public String getDockerHost() |
| { |
| return dockerRule.getDockerHost(); |
| } |
| |
| public String getExposedContainerPort( String containerPort ) |
| { |
| return dockerRule.getExposedContainerPort( containerPort ); |
| } |
| } |
| <% |
| } |
| %> |
| |
| <% |
| if( polygene.needsDelayChecker ) { |
| %> |
| private static class DelayChecker |
| implements StartCondition |
| { |
| private final long millis; |
| private final long doneAt; |
| |
| DelayChecker( long millis ) |
| { |
| this.millis = millis; |
| this.doneAt = System.currentTimeMillis() + millis; |
| } |
| |
| @Override |
| public StartConditionCheck build( DockerRule currentRule ) |
| { |
| return new StartConditionCheck() |
| { |
| @Override |
| public boolean check() |
| { |
| return System.currentTimeMillis() > doneAt; |
| } |
| |
| @Override |
| public String describe() |
| { |
| return String.format( "delay check %d ms", millis ); |
| } |
| |
| @Override |
| public void after() |
| { |
| } |
| }; |
| } |
| } |
| <% } |
| %>} |