KestrelClientIT.java

package net.rubyeye.xmemcached.test.unittest;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.CyclicBarrier;

import junit.framework.Assert;
import junit.framework.TestCase;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.command.KestrelCommandFactory;
import net.rubyeye.xmemcached.utils.AddrUtil;

import com.google.code.yanf4j.util.ResourcesUtils;

public class KestrelClientIT extends TestCase {
	static class UserDefinedClass implements Serializable {
		private String name;

		public UserDefinedClass(String name) {
			super();
			this.name = name;
		}

	}

	Properties properties;
	private MemcachedClient memcachedClient;

	@Override
	public void setUp() throws Exception {
		this.properties = ResourcesUtils
				.getResourceAsProperties("test.properties");
		MemcachedClientBuilder builder = newBuilder();
		builder.setConnectionPoolSize(5);
		//builder.getConfiguration().setSessionIdleTimeout(5);
		this.memcachedClient = builder.build();
		this.memcachedClient.flushAll();
	}

	private MemcachedClientBuilder newBuilder() {
		MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil
				.getAddresses(this.properties
						.getProperty("test.kestrel.servers")));
		// Use kestrel command factory
		builder.setCommandFactory(new KestrelCommandFactory());
		return builder;
	}

	public void testPrimitiveAsString() throws Exception {
		this.memcachedClient.setPrimitiveAsString(true);
		// store integer
		for (int i = 0; i < 1000; i++) {
			this.memcachedClient.set("queue1", 0, i);
		}
		// but get string
		for (int i = 0; i < 1000; i++) {
			Assert.assertEquals(String.valueOf(i), this.memcachedClient
					.get("queue1"));
		}

		this.memcachedClient.setPrimitiveAsString(false);
		// store integer
		for (int i = 0; i < 1000; i++) {
			this.memcachedClient.set("queue1", 0, i);
		}
		// still get integer
		for (int i = 0; i < 1000; i++) {
			Assert.assertEquals(i, this.memcachedClient.get("queue1"));
		}
	}

	@Override
	public void tearDown() throws IOException {
		this.memcachedClient.shutdown();
	}

	public void testNormalSetAndGet() throws Exception {
		Assert.assertNull(this.memcachedClient.get("queue1"));

		Assert.assertTrue(this.memcachedClient.set("queue1", 0, "hello world"));
		Assert.assertEquals("hello world", this.memcachedClient.get("queue1"));

		Assert.assertNull(this.memcachedClient.get("queue1"));
	}

	public void testNormalSetAndGetMore() throws Exception {
		Assert.assertNull(this.memcachedClient.get("queue1"));
		for (int i = 0; i < 10; i++) {
			Assert.assertTrue(this.memcachedClient.set("queue1", 0, i));
		}
		for (int i = 0; i < 10; i++) {
			Assert.assertEquals(i, this.memcachedClient.get("queue1"));
		}
		Assert.assertNull(this.memcachedClient.get("queue1"));
	}

	public void testSetAndGetObject() throws Exception {
		Map<String, String> map = new HashMap<String, String>();
		map.put("a", "a");
		map.put("b", "b");
		map.put("c", "c");
		Assert.assertTrue(this.memcachedClient.set("queue1", 0, map));

		Map<String, String> mapFromMQ = (Map<String, String>) this.memcachedClient
				.get("queue1");

		Assert.assertEquals(3, mapFromMQ.size());
		Assert.assertEquals("a", mapFromMQ.get("a"));
		Assert.assertEquals("b", mapFromMQ.get("b"));
		Assert.assertEquals("c", mapFromMQ.get("c"));
		Assert.assertNull(this.memcachedClient.get("queue1"));

		List<UserDefinedClass> userDefinedClassList = new ArrayList<UserDefinedClass>();
		userDefinedClassList.add(new UserDefinedClass("a"));
		userDefinedClassList.add(new UserDefinedClass("b"));
		userDefinedClassList.add(new UserDefinedClass("c"));

		Assert.assertTrue(this.memcachedClient.set("queue1", 0,
				userDefinedClassList));
		List<UserDefinedClass> userDefinedClassListFromMQ = (List<UserDefinedClass>) this.memcachedClient
				.get("queue1");

		Assert.assertEquals(3, userDefinedClassListFromMQ.size());

	}

	public void testBlockingFetch() throws Exception {
		this.memcachedClient.setOpTimeout(60000);
		long start = System.currentTimeMillis();
		// blocking read 1 second
		Assert.assertNull(this.memcachedClient.get("queue1/t=1000"));
		Assert.assertEquals(1000, System.currentTimeMillis() - start, 100);

		Assert.assertTrue(this.memcachedClient.set("queue1", 0, "hello world"));
		Assert.assertEquals("hello world", this.memcachedClient
				.get("queue1/t=1000"));

	}
	
	public void testPeek()throws Exception{
		Assert.assertNull(this.memcachedClient.get("queue1/peek"));
		this.memcachedClient.set("queue1", 0, 1);
		Assert.assertEquals(1,this.memcachedClient.get("queue1/peek"));
		this.memcachedClient.set("queue1", 0, 10);
		Assert.assertEquals(1,this.memcachedClient.get("queue1/peek"));
		this.memcachedClient.set("queue1", 0, 11);
		Assert.assertEquals(1,this.memcachedClient.get("queue1/peek"));
		
		Assert.assertEquals(1,this.memcachedClient.get("queue1"));
		Assert.assertEquals(10,this.memcachedClient.get("queue1/peek"));
		Assert.assertEquals(10,this.memcachedClient.get("queue1"));
		Assert.assertEquals(11,this.memcachedClient.get("queue1/peek"));
		Assert.assertEquals(11,this.memcachedClient.get("queue1"));
		Assert.assertNull(this.memcachedClient.get("queue1/peek"));
	}

	public void testDelete() throws Exception {
		Assert.assertNull(this.memcachedClient.get("queue1"));
		for (int i = 0; i < 10; i++) {
			Assert.assertTrue(this.memcachedClient.set("queue1", 0, i));
		}
		this.memcachedClient.delete("queue1");
		for (int i = 0; i < 10; i++) {
			Assert.assertNull(this.memcachedClient.get("queue1"));
		}
	}

	public void testReliableFetch() throws Exception {
		Assert.assertTrue(this.memcachedClient.set("queue1", 0, "hello world"));
		Assert.assertEquals("hello world", this.memcachedClient
				.get("queue1/open"));
		// close connection
		this.memcachedClient.shutdown();
		// still can fetch it
		MemcachedClient newClient = newBuilder().build();
		newClient.setOptimizeGet(false);
		// begin transaction
		Assert.assertEquals("hello world", newClient.get("queue1/open"));
		// confirm
		Assert.assertNull(newClient.get("queue1/close"));
		Assert.assertNull(newClient.get("queue1"));

		// test abort,for kestrel 1.2
		Assert.assertTrue(newClient.set("queue1", 0, "hello world"));
		Assert.assertEquals("hello world", newClient.get("queue1/open"));
		// abort
		Assert.assertNull(newClient.get("queue1/abort"));
		// still alive
		Assert.assertEquals("hello world", newClient.get("queue1/open"));
		// confirm
		Assert.assertNull(newClient.get("queue1/close"));
		// null
		Assert.assertNull(newClient.get("queue1"));

		newClient.shutdown();
	}

	public void testPerformance() throws Exception {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) {
			this.memcachedClient.set("queue1", 0, "hello");
		}
		System.out.println("push 10000 message:"
				+ (System.currentTimeMillis() - start) + "ms");

		start = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) {
			this.memcachedClient.get("queue1");
		}
		System.out.println("fetch 10000 message:"
				+ (System.currentTimeMillis() - start) + "ms");
	}

	class AccessThread extends Thread {
		private CyclicBarrier cyclicBarrier;

		public AccessThread(CyclicBarrier cyclicBarrier) {
			super();
			this.cyclicBarrier = cyclicBarrier;
		}

		@Override
		public void run() {
			try {
				this.cyclicBarrier.await();
				for (int i = 0; i < 10000; i++) {
					KestrelClientIT.this.memcachedClient.set("queue1", 0,
							"hello");
				}
				for (int i = 0; i < 10000; i++) {
					KestrelClientIT.this.memcachedClient.get("queue1");
				}
				this.cyclicBarrier.await();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	
	public void ignoreTestConcurrentAccess() throws Exception {
		int threadCount = 100;
		CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount + 1);
		for (int i = 0; i < threadCount; i++) {
			new AccessThread(cyclicBarrier).start();
		}
		cyclicBarrier.await();
		cyclicBarrier.await();

	}
	
	public void testHearBeat()throws Exception{
		Thread.sleep(30*1000);
		this.memcachedClient.set("queue1", 0, "hello");
		assertEquals("hello",this.memcachedClient.get("queue1"));
	}

}