Java tutorial
package org.csc.phynixx.connection; /* * #%L * phynixx-connection * %% * Copyright (C) 2014 csc * %% * Licensed 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. * #L% */ import junit.framework.AssertionFailedError; import junit.framework.TestCase; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import org.csc.phynixx.common.TestUtils; import org.csc.phynixx.common.TmpDirectory; import org.csc.phynixx.common.exceptions.DelegatedRuntimeException; import org.csc.phynixx.common.logger.IPhynixxLogger; import org.csc.phynixx.common.logger.PhynixxLogManager; import org.csc.phynixx.connection.loggersystem.IPhynixxLoggerSystemStrategy; import org.csc.phynixx.connection.loggersystem.LoggerPerTransactionStrategy; import org.csc.phynixx.loggersystem.logger.IDataLoggerFactory; import org.csc.phynixx.loggersystem.logger.channellogger.FileChannelDataLoggerFactory; import org.csc.phynixx.phynixx.testconnection.*; import java.util.*; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class MTPooledConnectionIT extends TestCase { private IPhynixxLogger logger = PhynixxLogManager.getLogger(this.getClass()); private PooledPhynixxManagedConnectionFactory<ITestConnection> factory = null; private static final int CONNECTION_POOL_SIZE = 20; private TmpDirectory tmpDir = null; protected void setUp() throws Exception { // configuring the log-system (e.g. log4j) TestUtils.configureLogging(); this.tmpDir = new TmpDirectory("howllogger"); // clears all existing file in dem tmp directory this.tmpDir.clear(); GenericObjectPoolConfig cfg = new GenericObjectPoolConfig(); cfg.setMaxTotal(CONNECTION_POOL_SIZE); this.factory = new PooledPhynixxManagedConnectionFactory(new TestConnectionFactory(), cfg); this.factory.setSynchronizeConnection(true); IDataLoggerFactory loggerFactory = new FileChannelDataLoggerFactory("pool", this.tmpDir.getDirectory()); LoggerPerTransactionStrategy strategy = new LoggerPerTransactionStrategy(loggerFactory); this.factory.setLoggerSystemStrategy(strategy); } protected void tearDown() throws Exception { TestConnectionStatusManager.clear(); this.factory.close(); // delete all tmp files ... this.tmpDir.delete(); this.factory = null; } private static interface IActOnConnection { Object doWork(ITestConnection con); } private static List<Exception> exceptions = Collections.synchronizedList(new ArrayList()); private class Caller implements Callable<Object> { private IActOnConnection actOnConnection = null; private int repeats = 1; private long msecsDelay = -1; public Caller(IActOnConnection actOnConnection) { this(actOnConnection, 1); } public Caller(IActOnConnection actOnConnection, int repeats) { this.actOnConnection = actOnConnection; this.repeats = repeats; } public Object call() { ITestConnection con = null; Object conId = null; try { for (int i = 0; i < repeats; i++) { try { con = MTPooledConnectionIT.this.factory.getConnection(); conId = con.getConnectionId(); if (msecsDelay > 0) { Thread.currentThread().sleep(msecsDelay); } try { this.actOnConnection.doWork(con); } catch (ActionInterruptedException e) { } catch (DelegatedRuntimeException e) { if (!(e.getRootCause() instanceof ActionInterruptedException)) { throw e; } } } finally { if (con != null) { //con.close(); } } } } catch (Throwable ex) { ex.printStackTrace(); exceptions.add(new DelegatedRuntimeException("Thread " + Thread.currentThread(), ex)); } return conId; } } private void startRunners(IActOnConnection actOnConnection, int numThreads) throws Exception { exceptions.clear(); ExecutorService executorService = Executors.newFixedThreadPool(numThreads); for (int i = 0; i < numThreads; i++) { Callable<Object> task = new Caller(actOnConnection); executorService.submit(task); } executorService.shutdown(); // 10 seconds per execution boolean inTime = executorService.awaitTermination(10000 * CONNECTION_POOL_SIZE, TimeUnit.SECONDS); if (!inTime) { if (!executorService.isShutdown()) { List<Runnable> runnables = executorService.shutdownNow(); } throw new IllegalStateException( "Execution was stopped after " + 10 * CONNECTION_POOL_SIZE + " seconds"); } if (exceptions.size() > 0) { for (int i = 0; i < exceptions.size(); i++) { Exception ex = (Exception) exceptions.get(i); ex.printStackTrace(); } throw new IllegalStateException("Error occurred", exceptions.get(0)); } } public void testGoodCase() throws Exception { IActOnConnection actOnConnection = new IActOnConnection() { public Object doWork(ITestConnection con) { try { con.act(5); con.act(7); con.rollback(); } finally { con.close(); } return con.getConnectionId(); } }; this.startRunners(actOnConnection, CONNECTION_POOL_SIZE * 2); // nothing has to be recoverd ... } public void testInterruptedRollback() throws Exception { final int[] counter = new int[1]; IActOnConnection actOnConnection = new IActOnConnection() { public Object doWork(ITestConnection con) { Object conId = con.getConnectionId(); try { con.act(5); con.setInterruptFlag(TestInterruptionPoint.ACT); con.act(7); con.rollback(); } finally { con.close(); return conId; } } }; this.startRunners(actOnConnection, CONNECTION_POOL_SIZE * 2); this.factory.close(); PhynixxRecovery<ITestConnection> recovery = new PhynixxRecovery<ITestConnection>( new TestConnectionFactory()); IPhynixxLoggerSystemStrategy<ITestConnection> loggerStrategy = this.factory.getLoggerSystemStrategy(); loggerStrategy.close(); recovery.setLoggerSystemStrategy(loggerStrategy); recovery.recover(null); // TestStatusStack statusStack= TestConnectionStatusManager.getStatusStack(con.) } private Properties loadHowlConfig() throws Exception { Properties howlprop = new Properties(); howlprop.put("listConfig", "false"); howlprop.put("bufferSize", "32"); howlprop.put("minBuffers", "1"); howlprop.put("maxBuffers", "1"); howlprop.put("maxBlocksPerFile", "100"); howlprop.put("logFileDir", this.tmpDir.getDirectory().getAbsolutePath()); howlprop.put("logFileName", "test1"); howlprop.put("maxLogFiles", "2"); return howlprop; } }