/*
* Copyright 2011 Martin Grotzke
*
* 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.
*/
package de.javakaffee.web.msm;
import static de.javakaffee.web.msm.integration.TestUtils.createSession;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import net.spy.memcached.MemcachedClient;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.couchbase.mock.CouchbaseMock;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import com.couchbase.client.CouchbaseClient;
import de.javakaffee.web.msm.BackupSessionTask.BackupResult;
import de.javakaffee.web.msm.integration.TestUtils;
import de.javakaffee.web.msm.integration.TomcatBuilder;
/**
* @author @author <a href="mailto:martin.grotzke@javakaffee.de">Martin Grotzke</a>
*/
public abstract class CouchbaseIntegrationTest {
private static final Log LOG = LogFactory.getLog(CouchbaseIntegrationTest.class);
private final List<Pair<CouchbaseMock, Thread>> cluster = new ArrayList<Pair<CouchbaseMock,Thread>>(2);
private MemcachedClient mc;
private TomcatBuilder<?> _tomcat1;
private final int _portTomcat1 = 18888;
private boolean couchbaseProvided;
private TranscoderService transcoderService;
abstract TestUtils<?> getTestUtils();
@BeforeMethod
public void setUp(final Method testMethod) throws Throwable {
couchbaseProvided = Boolean.parseBoolean(System.getProperty("couchbase.provided", "false"));
final int couchbasePort = Integer.parseInt(System.getProperty("couchbase.port", "18091"));
if(!couchbaseProvided) {
cluster.add(setupCouchbase(couchbasePort));
}
try {
System.setProperty( "org.apache.catalina.startup.EXIT_ON_INIT_FAILURE", "true" );
_tomcat1 = getTestUtils().tomcatBuilder().port(_portTomcat1).memcachedNodes("http://localhost:"+ couchbasePort +"/pools")
.sticky(true).memcachedProtocol("binary").username("default").buildAndStart();
} catch ( final Throwable e ) {
LOG.error( "could not start tomcat.", e );
throw e;
}
setupCouchbaseClient();
transcoderService = new TranscoderService(new JavaSerializationTranscoder(_tomcat1.getManager()));
}
@AfterMethod
public void tearDown() throws Exception {
mc.shutdown();
mc = null;
if(!couchbaseProvided) {
tearDownCouchbase();
}
_tomcat1.stop();
}
@Test
public void testBackupSessionInCouchbase() throws InterruptedException, ExecutionException {
final MemcachedSessionService service = _tomcat1.getService();
final MemcachedBackupSession session = createSession( service );
final String sessionId = "12345";
session.setId(sessionId);
session.setAttribute( "foo", "bar" );
final BackupResult backupResult = service.backupSession( session.getIdInternal(), false, null ).get();
assertEquals(backupResult.getStatus(), BackupResultStatus.SUCCESS);
final MemcachedBackupSession loadedSession = transcoderService.deserialize((byte[])mc.get(sessionId), _tomcat1.getManager());
checkSession(loadedSession, session);
}
@Test(enabled = false) // spurious failures
public void testBackupSessionInCouchbaseCluster() throws Exception {
final MemcachedSessionService service = _tomcat1.getService();
cluster.add(setupCouchbase(getMaxCouchbasePort() + 1));
service.setMemcachedNodes(getMemcachedNodesConfig(getURIs()));
setupCouchbaseClient();
waitForReconnect(service.getMemcached(), cluster.size(), 1000);
waitForReconnect(mc, cluster.size(), 1000);
final MemcachedBackupSession session = createSession( service );
final String sessionId = "12345";
session.setId(sessionId);
session.setAttribute( "foo", "bar" );
final BackupResult backupResult = service.backupSession( session.getIdInternal(), false, null ).get();
assertEquals(backupResult.getStatus(), BackupResultStatus.SUCCESS);
final MemcachedBackupSession loadedSession = transcoderService.deserialize((byte[])mc.get(sessionId), _tomcat1.getManager());
checkSession(loadedSession, session);
}
private void checkSession(final MemcachedBackupSession actual, final MemcachedBackupSession expected) {
assertNotNull(actual);
assertEquals(actual.getId(), expected.getId());
assertEquals(actual.getAttributesInternal(), expected.getAttributesInternal());
}
private void waitForReconnect( final MemcachedClient client, final int expectedServers, final long timeToWait )
throws InterruptedException, RuntimeException {
final long start = System.currentTimeMillis();
while( System.currentTimeMillis() < start + timeToWait ) {
if(client.getAvailableServers().size() == expectedServers) {
return;
}
Thread.sleep( 20 );
}
throw new RuntimeException( "MemcachedClient did not reconnect after " + timeToWait + " millis." );
}
private void setupCouchbaseClient() throws URISyntaxException, IOException {
if(mc != null) {
LOG.info("Closing existing couchbase client.");
mc.shutdown();
}
final List<URI> uris = getURIs();
LOG.info("Creating new couchbase client with uris " + uris);
mc = new CouchbaseClient(uris, "default", "");
}
private List<URI> getURIs() throws URISyntaxException {
final List<URI> uris = new ArrayList<URI>(cluster.size());
for (final Pair<CouchbaseMock, Thread> server : cluster) {
uris.add(new URI("http://localhost:"+ server.getFirst().getHttpPort() +"/pools"));
}
return uris;
}
private Pair<CouchbaseMock, Thread> setupCouchbase(final int couchbasePort) throws IOException {
final CouchbaseMock couchbase = new CouchbaseMock("localhost", couchbasePort, 1, 1);
couchbase.setRequiredHttpAuthorization(null);
final Thread thread = new Thread(couchbase);
thread.start();
return Pair.of(couchbase, thread);
}
private void tearDownCouchbase() throws InterruptedException {
for (final Pair<CouchbaseMock, Thread> server : cluster) {
server.getSecond().interrupt();
server.getSecond().join(1000);
server.getFirst().close();
}
cluster.clear();
}
private String getMemcachedNodesConfig(final List<URI> urIs) {
final StringBuilder sb = new StringBuilder();
for (final URI uri : urIs) {
if(sb.length() > 1) sb.append(",");
sb.append(uri.toString());
}
final String couchbaseNodes = sb.toString();
return couchbaseNodes;
}
private int getMaxCouchbasePort() {
return cluster.get(cluster.size() - 1).getFirst().getHttpPort();
}
}