Unnamed: 0
int64
0
3.76k
func
stringlengths
25
81.8k
target
bool
2 classes
project
stringlengths
52
140
0
public class PlaceHolder { }
false
hazelcast-all_src_main_java_com_hazelcast_PlaceHolder.java
1
public abstract class AbstractTextCommand implements TextCommand { protected final TextCommandType type; private SocketTextReader socketTextReader; private SocketTextWriter socketTextWriter; private long requestId = -1; protected AbstractTextCommand(TextCommandType type) { this.type = type; } @Override public TextCommandType getType() { return type; } @Override public SocketTextReader getSocketTextReader() { return socketTextReader; } @Override public SocketTextWriter getSocketTextWriter() { return socketTextWriter; } @Override public long getRequestId() { return requestId; } @Override public void init(SocketTextReader socketTextReader, long requestId) { this.socketTextReader = socketTextReader; this.requestId = requestId; this.socketTextWriter = socketTextReader.getSocketTextWriter(); } @Override public boolean isUrgent() { return false; } @Override public boolean shouldReply() { return true; } @Override public String toString() { return "AbstractTextCommand[" + type + "]{" + "requestId=" + requestId + '}'; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_AbstractTextCommand.java
2
public abstract class AbstractTextCommandProcessor<T> implements TextCommandProcessor<T>, TextCommandConstants { protected final TextCommandService textCommandService; protected AbstractTextCommandProcessor(TextCommandService textCommandService) { this.textCommandService = textCommandService; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_AbstractTextCommandProcessor.java
3
public interface CommandParser extends TextCommandConstants { TextCommand parser(SocketTextReader socketTextReader, String cmd, int space); }
false
hazelcast_src_main_java_com_hazelcast_ascii_CommandParser.java
4
@RunWith(HazelcastSerialClassRunner.class) @Category(SlowTest.class) public class MemcacheTest { final static Config config = new XmlConfigBuilder().build(); @BeforeClass @AfterClass public static void killAllHazelcastInstances() throws IOException { Hazelcast.shutdownAll(); } public MemcachedClient getMemcacheClient(HazelcastInstance instance) throws IOException { final LinkedList<InetSocketAddress> addresses = new LinkedList<InetSocketAddress>(); addresses.add(instance.getCluster().getLocalMember().getInetSocketAddress()); final ConnectionFactory factory = new ConnectionFactoryBuilder().setOpTimeout(60 * 60 * 60).setDaemon(true).setFailureMode(FailureMode.Retry).build(); return new MemcachedClient(factory, addresses); } @Test public void testMemcacheSimple() throws IOException, ExecutionException, InterruptedException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); MemcachedClient client = getMemcacheClient(instance); try { for (int i = 0; i < 100; i++) { final OperationFuture<Boolean> future = client.set(String.valueOf(i), 0, i); assertEquals(Boolean.TRUE, future.get()); } for (int i = 0; i < 100; i++) { assertEquals(i, client.get(String.valueOf(i))); } for (int i = 0; i < 100; i++) { final OperationFuture<Boolean> future = client.add(String.valueOf(i), 0, i * 100); assertEquals(Boolean.FALSE, future.get()); } for (int i = 0; i < 100; i++) { assertEquals(i, client.get(String.valueOf(i))); } for (int i = 100; i < 200; i++) { final OperationFuture<Boolean> future = client.add(String.valueOf(i), 0, i); assertEquals(Boolean.TRUE, future.get()); } for (int i = 0; i < 200; i++) { assertEquals(i, client.get(String.valueOf(i))); } for (int i = 0; i < 200; i++) { final OperationFuture<Boolean> future = client.replace(String.valueOf(i), 0, i * 10); assertEquals(Boolean.TRUE, future.get()); } for (int i = 0; i < 200; i++) { assertEquals(i * 10, client.get(String.valueOf(i))); } for (int i = 200; i < 400; i++) { final OperationFuture<Boolean> future = client.replace(String.valueOf(i), 0, i); assertEquals(Boolean.FALSE, future.get()); } for (int i = 200; i < 400; i++) { assertEquals(null, client.get(String.valueOf(i))); } for (int i = 100; i < 200; i++) { final OperationFuture<Boolean> future = client.delete(String.valueOf(i)); assertEquals(Boolean.TRUE, future.get()); } for (int i = 100; i < 200; i++) { assertEquals(null, client.get(String.valueOf(100))); } for (int i = 100; i < 200; i++) { final OperationFuture<Boolean> future = client.delete(String.valueOf(i)); assertEquals(Boolean.FALSE, future.get()); } final LinkedList<String> keys = new LinkedList<String>(); for (int i = 0; i < 100; i++) { keys.add(String.valueOf(i)); } final Map<String, Object> bulk = client.getBulk(keys); for (int i = 0; i < 100; i++) { assertEquals(i * 10, bulk.get(String.valueOf(i))); } // STATS final Map<String, String> stats = client.getStats().get(instance.getCluster().getLocalMember().getInetSocketAddress()); assertEquals("700", stats.get("cmd_set")); assertEquals("1000", stats.get("cmd_get")); assertEquals("700", stats.get("get_hits")); assertEquals("300", stats.get("get_misses")); assertEquals("100", stats.get("delete_hits")); assertEquals("100", stats.get("delete_misses")); } finally { client.shutdown(); } } @Test public void testMemcacheWithIMap() throws IOException, InterruptedException, ExecutionException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); MemcachedClient client = getMemcacheClient(instance); final String prefix = "testMemcacheWithIMap:"; try { final IMap<String, Object> map = instance.getMap("hz_memcache_testMemcacheWithIMap"); for (int i = 0; i < 100; i++) { map.put(String.valueOf(i), String.valueOf(i)); } for (int i = 0; i < 100; i++) { assertEquals(String.valueOf(i), client.get(prefix + String.valueOf(i))); final OperationFuture<Boolean> future = client.set(prefix + String.valueOf(i), 0, String.valueOf(i * 10)); future.get(); } for (int i = 0; i < 100; i++) { final MemcacheEntry memcacheEntry = (MemcacheEntry) map.get(String.valueOf(i)); final MemcacheEntry expected = new MemcacheEntry(prefix + String.valueOf(i), String.valueOf(i * 10).getBytes(), 0); assertEquals(expected, memcacheEntry); } final OperationFuture<Boolean> future = client.delete(prefix); future.get(); for (int i = 0; i < 100; i++) { assertEquals(null, client.get(prefix + String.valueOf(i))); } } finally { client.shutdown(); } } @Test public void testIncrementAndDecrement() throws IOException, ExecutionException, InterruptedException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); MemcachedClient client = getMemcacheClient(instance); try { for (int i = 0; i < 100; i++) { final OperationFuture<Boolean> future = client.set(String.valueOf(i), 0, i); future.get(); } for (int i = 0; i < 100; i++) { assertEquals(i * 2, client.incr(String.valueOf(i), i)); } for (int i = 100; i < 120; i++) { assertEquals(-1, client.incr(String.valueOf(i), i)); } for (int i = 0; i < 100; i++) { assertEquals(i, client.decr(String.valueOf(i), i)); } for (int i = 100; i < 130; i++) { assertEquals(-1, client.decr(String.valueOf(i), i)); } for (int i = 0; i < 100; i++) { assertEquals(i, client.get(String.valueOf(i))); } final Map<String, String> stats = client.getStats().get(instance.getCluster().getLocalMember().getInetSocketAddress()); assertEquals("100", stats.get("cmd_set")); assertEquals("100", stats.get("cmd_get")); assertEquals("100", stats.get("incr_hits")); assertEquals("20", stats.get("incr_misses")); assertEquals("100", stats.get("decr_hits")); assertEquals("30", stats.get("decr_misses")); } finally { client.shutdown(); } } @Test public void testMemcacheAppendPrepend() throws IOException, ExecutionException, InterruptedException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); MemcachedClient client = getMemcacheClient(instance); try { for (int i = 0; i < 100; i++) { final OperationFuture<Boolean> future = client.set(String.valueOf(i), 0, String.valueOf(i)); future.get(); } for (int i = 0; i < 100; i++) { final OperationFuture<Boolean> future = client.append(0, String.valueOf(i), "append"); assertEquals(Boolean.TRUE, future.get()); } for (int i = 0; i < 100; i++) { final OperationFuture<Boolean> future = client.prepend(0, String.valueOf(i), "prepend"); assertEquals(Boolean.TRUE, future.get()); } for (int i = 1; i < 100; i++) { assertEquals("prepend" + String.valueOf(i) + "append", client.get(String.valueOf(i))); } } finally { client.shutdown(); } } @Test public void testQuit() throws IOException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); MemcachedClient client = getMemcacheClient(instance); client.shutdown(); } @Test public void testMemcacheTTL() throws IOException, ExecutionException, InterruptedException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); MemcachedClient client = getMemcacheClient(instance); try { OperationFuture<Boolean> future = client.set(String.valueOf(0), 3, 10); future.get(); assertEquals(10, client.get(String.valueOf(0))); Thread.sleep(6000); assertEquals(null, client.get(String.valueOf(0))); } finally { client.shutdown(); } } }
false
hazelcast_src_test_java_com_hazelcast_ascii_MemcacheTest.java
5
public class NoOpCommand extends AbstractTextCommand { final ByteBuffer response; public NoOpCommand(byte[] response) { super(TextCommandType.NO_OP); this.response = ByteBuffer.wrap(response); } public boolean readFrom(ByteBuffer cb) { return true; } public boolean writeTo(ByteBuffer bb) { while (bb.hasRemaining() && response.hasRemaining()) { bb.put(response.get()); } return !response.hasRemaining(); } @Override public String toString() { return "NoOpCommand {" + bytesToString(response.array()) + "}"; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_NoOpCommand.java
6
public class NoOpCommandProcessor extends AbstractTextCommandProcessor<NoOpCommand> { public NoOpCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(NoOpCommand command) { textCommandService.sendResponse(command); } public void handleRejection(NoOpCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_NoOpCommandProcessor.java
7
@RunWith(HazelcastSerialClassRunner.class) @Category(SlowTest.class) public class RestTest { final static Config config = new XmlConfigBuilder().build(); @Before @After public void killAllHazelcastInstances() throws IOException { Hazelcast.shutdownAll(); } @Test public void testTtl_issue1783() throws IOException, InterruptedException { final Config conf = new Config(); String name = "map"; final CountDownLatch latch = new CountDownLatch(1); final MapConfig mapConfig = conf.getMapConfig(name); mapConfig.setTimeToLiveSeconds(3); mapConfig.addEntryListenerConfig(new EntryListenerConfig() .setImplementation(new EntryAdapter() { @Override public void entryEvicted(EntryEvent event) { latch.countDown(); } })); final HazelcastInstance instance = Hazelcast.newHazelcastInstance(conf); final HTTPCommunicator communicator = new HTTPCommunicator(instance); communicator.put(name, "key", "value"); String value = communicator.get(name, "key"); assertNotNull(value); assertEquals("value", value); assertTrue(latch.await(30, TimeUnit.SECONDS)); value = communicator.get(name, "key"); assertTrue(value.isEmpty()); } @Test public void testRestSimple() throws IOException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); final HTTPCommunicator communicator = new HTTPCommunicator(instance); final String name = "testRestSimple"; for (int i = 0; i < 100; i++) { assertEquals(HttpURLConnection.HTTP_OK, communicator.put(name, String.valueOf(i), String.valueOf(i * 10))); } for (int i = 0; i < 100; i++) { String actual = communicator.get(name, String.valueOf(i)); assertEquals(String.valueOf(i * 10), actual); } communicator.deleteAll(name); for (int i = 0; i < 100; i++) { String actual = communicator.get(name, String.valueOf(i)); assertEquals("", actual); } for (int i = 0; i < 100; i++) { assertEquals(HttpURLConnection.HTTP_OK, communicator.put(name, String.valueOf(i), String.valueOf(i * 10))); } for (int i = 0; i < 100; i++) { assertEquals(String.valueOf(i * 10), communicator.get(name, String.valueOf(i))); } for (int i = 0; i < 100; i++) { assertEquals(HttpURLConnection.HTTP_OK, communicator.delete(name, String.valueOf(i))); } for (int i = 0; i < 100; i++) { assertEquals("", communicator.get(name, String.valueOf(i))); } for (int i = 0; i < 100; i++) { assertEquals(HttpURLConnection.HTTP_OK, communicator.offer(name, String.valueOf(i))); } for (int i = 0; i < 100; i++) { assertEquals(String.valueOf(i), communicator.poll(name, 2)); } } @Test public void testQueueSizeEmpty() throws IOException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); final HTTPCommunicator communicator = new HTTPCommunicator(instance); final String name = "testQueueSizeEmpty"; IQueue queue = instance.getQueue(name); Assert.assertEquals(queue.size(), communicator.size(name)); } @Test public void testQueueSizeNonEmpty() throws IOException { final HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); final HTTPCommunicator communicator = new HTTPCommunicator(instance); final String name = "testQueueSizeNotEmpty"; final int num_items = 100; IQueue queue = instance.getQueue(name); for (int i = 0; i < num_items; i++) { queue.add(i); } Assert.assertEquals(queue.size(), communicator.size(name)); } private class HTTPCommunicator { final HazelcastInstance instance; final String address; HTTPCommunicator(HazelcastInstance instance) { this.instance = instance; this.address = "http:/" + instance.getCluster().getLocalMember().getInetSocketAddress().toString() + "/hazelcast/rest/"; } public String poll(String queueName, long timeout) { String url = address + "queues/" + queueName + "/" + String.valueOf(timeout); String result = doGet(url); return result; } public int size(String queueName) { String url = address + "queues/" + queueName + "/size"; Integer result = Integer.parseInt(doGet(url)); return result; } public int offer(String queueName, String data) throws IOException { String url = address + "queues/" + queueName; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("POST"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); /** post the data */ OutputStream out = null; out = urlConnection.getOutputStream(); Writer writer = new OutputStreamWriter(out, "UTF-8"); writer.write(data); writer.close(); out.close(); return urlConnection.getResponseCode(); } public String get(String mapName, String key) { String url = address + "maps/" + mapName + "/" + key; String result = doGet(url); return result; } public int put(String mapName, String key, String value) throws IOException { String url = address + "maps/" + mapName + "/" + key; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("POST"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); /** post the data */ OutputStream out = urlConnection.getOutputStream(); Writer writer = new OutputStreamWriter(out, "UTF-8"); writer.write(value); writer.close(); out.close(); return urlConnection.getResponseCode(); } public int deleteAll(String mapName) throws IOException { String url = address + "maps/" + mapName; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("DELETE"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); return urlConnection.getResponseCode(); } public int delete(String mapName, String key) throws IOException { String url = address + "maps/" + mapName + "/" + key; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("DELETE"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); return urlConnection.getResponseCode(); } private String doGet(final String url) { String result = null; try { HttpURLConnection httpUrlConnection = (HttpURLConnection) (new URL(url)).openConnection(); BufferedReader rd = new BufferedReader(new InputStreamReader(httpUrlConnection.getInputStream())); StringBuilder data = new StringBuilder(150); String line; while ((line = rd.readLine()) != null) data.append(line); rd.close(); result = data.toString(); httpUrlConnection.disconnect(); } catch (Exception e) { e.printStackTrace(); } return result; } } }
false
hazelcast_src_test_java_com_hazelcast_ascii_RestTest.java
8
.setImplementation(new EntryAdapter() { @Override public void entryEvicted(EntryEvent event) { latch.countDown(); } }));
false
hazelcast_src_test_java_com_hazelcast_ascii_RestTest.java
9
private class HTTPCommunicator { final HazelcastInstance instance; final String address; HTTPCommunicator(HazelcastInstance instance) { this.instance = instance; this.address = "http:/" + instance.getCluster().getLocalMember().getInetSocketAddress().toString() + "/hazelcast/rest/"; } public String poll(String queueName, long timeout) { String url = address + "queues/" + queueName + "/" + String.valueOf(timeout); String result = doGet(url); return result; } public int size(String queueName) { String url = address + "queues/" + queueName + "/size"; Integer result = Integer.parseInt(doGet(url)); return result; } public int offer(String queueName, String data) throws IOException { String url = address + "queues/" + queueName; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("POST"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); /** post the data */ OutputStream out = null; out = urlConnection.getOutputStream(); Writer writer = new OutputStreamWriter(out, "UTF-8"); writer.write(data); writer.close(); out.close(); return urlConnection.getResponseCode(); } public String get(String mapName, String key) { String url = address + "maps/" + mapName + "/" + key; String result = doGet(url); return result; } public int put(String mapName, String key, String value) throws IOException { String url = address + "maps/" + mapName + "/" + key; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("POST"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); /** post the data */ OutputStream out = urlConnection.getOutputStream(); Writer writer = new OutputStreamWriter(out, "UTF-8"); writer.write(value); writer.close(); out.close(); return urlConnection.getResponseCode(); } public int deleteAll(String mapName) throws IOException { String url = address + "maps/" + mapName; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("DELETE"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); return urlConnection.getResponseCode(); } public int delete(String mapName, String key) throws IOException { String url = address + "maps/" + mapName + "/" + key; /** set up the http connection parameters */ HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection(); urlConnection.setRequestMethod("DELETE"); urlConnection.setDoOutput(true); urlConnection.setDoInput(true); urlConnection.setUseCaches(false); urlConnection.setAllowUserInteraction(false); urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8"); return urlConnection.getResponseCode(); } private String doGet(final String url) { String result = null; try { HttpURLConnection httpUrlConnection = (HttpURLConnection) (new URL(url)).openConnection(); BufferedReader rd = new BufferedReader(new InputStreamReader(httpUrlConnection.getInputStream())); StringBuilder data = new StringBuilder(150); String line; while ((line = rd.readLine()) != null) data.append(line); rd.close(); result = data.toString(); httpUrlConnection.disconnect(); } catch (Exception e) { e.printStackTrace(); } return result; } }
false
hazelcast_src_test_java_com_hazelcast_ascii_RestTest.java
10
public interface TextCommand extends TextCommandConstants, SocketWritable, SocketReadable { TextCommandType getType(); void init(SocketTextReader socketTextReader, long requestId); SocketTextReader getSocketTextReader(); SocketTextWriter getSocketTextWriter(); long getRequestId(); boolean shouldReply(); }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommand.java
11
@edu.umd.cs.findbugs.annotations.SuppressWarnings("MS_OOI_PKGPROTECT") public interface TextCommandConstants { int MONTH_SECONDS = 60 * 60 * 24 * 30; byte[] SPACE = stringToBytes(" "); byte[] RETURN = stringToBytes("\r\n"); byte[] FLAG_ZERO = stringToBytes(" 0 "); byte[] VALUE_SPACE = stringToBytes("VALUE "); byte[] DELETED = stringToBytes("DELETED\r\n"); byte[] STORED = stringToBytes("STORED\r\n"); byte[] TOUCHED = stringToBytes("TOUCHED\r\n"); byte[] NOT_STORED = stringToBytes("NOT_STORED\r\n"); byte[] NOT_FOUND = stringToBytes("NOT_FOUND\r\n"); byte[] RETURN_END = stringToBytes("\r\nEND\r\n"); byte[] END = stringToBytes("END\r\n"); byte[] ERROR = stringToBytes("ERROR"); byte[] CLIENT_ERROR = stringToBytes("CLIENT_ERROR "); byte[] SERVER_ERROR = stringToBytes("SERVER_ERROR "); enum TextCommandType { GET((byte) 0), PARTIAL_GET((byte) 1), GETS((byte) 2), SET((byte) 3), APPEND((byte) 4), PREPEND((byte) 5), ADD((byte) 6), REPLACE((byte) 7), DELETE((byte) 8), QUIT((byte) 9), STATS((byte) 10), GET_END((byte) 11), ERROR_CLIENT((byte) 12), ERROR_SERVER((byte) 13), UNKNOWN((byte) 14), VERSION((byte) 15), TOUCH((byte) 16), INCREMENT((byte) 17), DECREMENT((byte) 18), HTTP_GET((byte) 30), HTTP_POST((byte) 31), HTTP_PUT((byte) 32), HTTP_DELETE((byte) 33), NO_OP((byte) 98), STOP((byte) 99); final byte value; TextCommandType(byte type) { value = type; } public byte getValue() { return value; } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandConstants.java
12
enum TextCommandType { GET((byte) 0), PARTIAL_GET((byte) 1), GETS((byte) 2), SET((byte) 3), APPEND((byte) 4), PREPEND((byte) 5), ADD((byte) 6), REPLACE((byte) 7), DELETE((byte) 8), QUIT((byte) 9), STATS((byte) 10), GET_END((byte) 11), ERROR_CLIENT((byte) 12), ERROR_SERVER((byte) 13), UNKNOWN((byte) 14), VERSION((byte) 15), TOUCH((byte) 16), INCREMENT((byte) 17), DECREMENT((byte) 18), HTTP_GET((byte) 30), HTTP_POST((byte) 31), HTTP_PUT((byte) 32), HTTP_DELETE((byte) 33), NO_OP((byte) 98), STOP((byte) 99); final byte value; TextCommandType(byte type) { value = type; } public byte getValue() { return value; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandConstants.java
13
public interface TextCommandProcessor<T> { void handle(T request); void handleRejection(T request); }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandProcessor.java
14
public interface TextCommandService { boolean offer(String queueName, Object value); Object poll(String queueName, int seconds); Object poll(String queueName); void processRequest(TextCommand command); void sendResponse(TextCommand textCommand); Object get(String mapName, String key); byte[] getByteArray(String mapName, String key); Object put(String mapName, String key, Object value); Object put(String mapName, String key, Object value, int ttlSeconds); Object putIfAbsent(String mapName, String key, Object value, int ttlSeconds); Object replace(String mapName, String key, Object value); void lock(String mapName, String key) throws InterruptedException; void unlock(String mapName, String key); int getAdjustedTTLSeconds(int ttl); long incrementDeleteHitCount(int inc); long incrementDeleteMissCount(); long incrementGetHitCount(); long incrementGetMissCount(); long incrementSetCount(); long incrementIncHitCount(); long incrementIncMissCount(); long incrementDecrHitCount(); long incrementDecrMissCount(); long incrementTouchCount(); /** * Returns the size of the distributed queue instance with the specified name * @param queueName name of the distributed queue * @return the size of the distributed queue instance with the specified name */ int size(String queueName); Object delete(String mapName, String key); void deleteAll(String mapName); Stats getStats(); Node getNode(); byte[] toByteArray(Object value); }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandService.java
15
public class TextCommandServiceImpl implements TextCommandService, TextCommandConstants { private final Node node; private final TextCommandProcessor[] textCommandProcessors = new TextCommandProcessor[100]; private final HazelcastInstance hazelcast; private final AtomicLong sets = new AtomicLong(); private final AtomicLong touches = new AtomicLong(); private final AtomicLong getHits = new AtomicLong(); private final AtomicLong getMisses = new AtomicLong(); private final AtomicLong deleteMisses = new AtomicLong(); private final AtomicLong deleteHits = new AtomicLong(); private final AtomicLong incrementHits = new AtomicLong(); private final AtomicLong incrementMisses = new AtomicLong(); private final AtomicLong decrementHits = new AtomicLong(); private final AtomicLong decrementMisses = new AtomicLong(); private final long startTime = Clock.currentTimeMillis(); private final ILogger logger; private volatile ResponseThreadRunnable responseThreadRunnable; private volatile boolean running = true; public TextCommandServiceImpl(Node node) { this.node = node; this.hazelcast = node.hazelcastInstance; this.logger = node.getLogger(this.getClass().getName()); textCommandProcessors[GET.getValue()] = new GetCommandProcessor(this, true); textCommandProcessors[PARTIAL_GET.getValue()] = new GetCommandProcessor(this, false); textCommandProcessors[SET.getValue()] = new SetCommandProcessor(this); textCommandProcessors[APPEND.getValue()] = new SetCommandProcessor(this); textCommandProcessors[PREPEND.getValue()] = new SetCommandProcessor(this); textCommandProcessors[ADD.getValue()] = new SetCommandProcessor(this); textCommandProcessors[REPLACE.getValue()] = new SetCommandProcessor(this); textCommandProcessors[GET_END.getValue()] = new NoOpCommandProcessor(this); textCommandProcessors[DELETE.getValue()] = new DeleteCommandProcessor(this); textCommandProcessors[QUIT.getValue()] = new SimpleCommandProcessor(this); textCommandProcessors[STATS.getValue()] = new StatsCommandProcessor(this); textCommandProcessors[UNKNOWN.getValue()] = new ErrorCommandProcessor(this); textCommandProcessors[VERSION.getValue()] = new VersionCommandProcessor(this); textCommandProcessors[TOUCH.getValue()] = new TouchCommandProcessor(this); textCommandProcessors[INCREMENT.getValue()] = new IncrementCommandProcessor(this); textCommandProcessors[DECREMENT.getValue()] = new IncrementCommandProcessor(this); textCommandProcessors[ERROR_CLIENT.getValue()] = new ErrorCommandProcessor(this); textCommandProcessors[ERROR_SERVER.getValue()] = new ErrorCommandProcessor(this); textCommandProcessors[HTTP_GET.getValue()] = new HttpGetCommandProcessor(this); textCommandProcessors[HTTP_POST.getValue()] = new HttpPostCommandProcessor(this); textCommandProcessors[HTTP_PUT.getValue()] = new HttpPostCommandProcessor(this); textCommandProcessors[HTTP_DELETE.getValue()] = new HttpDeleteCommandProcessor(this); textCommandProcessors[NO_OP.getValue()] = new NoOpCommandProcessor(this); } @Override public Node getNode() { return node; } @Override public byte[] toByteArray(Object value) { Data data = node.getSerializationService().toData(value); return data.getBuffer(); } @Override public Stats getStats() { Stats stats = new Stats(); stats.uptime = (int) ((Clock.currentTimeMillis() - startTime) / 1000); stats.cmd_get = getMisses.get() + getHits.get(); stats.cmd_set = sets.get(); stats.cmd_touch = touches.get(); stats.get_hits = getHits.get(); stats.get_misses = getMisses.get(); stats.delete_hits = deleteHits.get(); stats.delete_misses = deleteMisses.get(); stats.incr_hits = incrementHits.get(); stats.incr_misses = incrementMisses.get(); stats.decr_hits = decrementHits.get(); stats.decr_misses = decrementMisses.get(); stats.curr_connections = node.connectionManager.getCurrentClientConnections(); stats.total_connections = node.connectionManager.getAllTextConnections(); return stats; } @Override public long incrementDeleteHitCount(int inc) { return deleteHits.addAndGet(inc); } @Override public long incrementDeleteMissCount() { return deleteMisses.incrementAndGet(); } @Override public long incrementGetHitCount() { return getHits.incrementAndGet(); } @Override public long incrementGetMissCount() { return getMisses.incrementAndGet(); } @Override public long incrementSetCount() { return sets.incrementAndGet(); } @Override public long incrementIncHitCount() { return incrementHits.incrementAndGet(); } @Override public long incrementIncMissCount() { return incrementMisses.incrementAndGet(); } @Override public long incrementDecrHitCount() { return decrementHits.incrementAndGet(); } @Override public long incrementDecrMissCount() { return decrementMisses.incrementAndGet(); } @Override public long incrementTouchCount() { return touches.incrementAndGet(); } @Override public void processRequest(TextCommand command) { if (responseThreadRunnable == null) { synchronized (this) { if (responseThreadRunnable == null) { responseThreadRunnable = new ResponseThreadRunnable(); String threadNamePrefix = node.getThreadNamePrefix("ascii.service.response"); Thread thread = new Thread(node.threadGroup, responseThreadRunnable, threadNamePrefix); thread.start(); } } } node.nodeEngine.getExecutionService().execute("hz:text", new CommandExecutor(command)); } @Override public Object get(String mapName, String key) { return hazelcast.getMap(mapName).get(key); } @Override public int getAdjustedTTLSeconds(int ttl) { if (ttl <= MONTH_SECONDS) { return ttl; } else { return ttl - (int) (Clock.currentTimeMillis() / 1000); } } @Override public byte[] getByteArray(String mapName, String key) { Object value = hazelcast.getMap(mapName).get(key); byte[] result = null; if (value != null) { if (value instanceof RestValue) { RestValue restValue = (RestValue) value; result = restValue.getValue(); } else if (value instanceof byte[]) { result = (byte[]) value; } else { result = toByteArray(value); } } return result; } @Override public Object put(String mapName, String key, Object value) { return hazelcast.getMap(mapName).put(key, value); } @Override public Object put(String mapName, String key, Object value, int ttlSeconds) { return hazelcast.getMap(mapName).put(key, value, ttlSeconds, TimeUnit.SECONDS); } @Override public Object putIfAbsent(String mapName, String key, Object value, int ttlSeconds) { return hazelcast.getMap(mapName).putIfAbsent(key, value, ttlSeconds, TimeUnit.SECONDS); } @Override public Object replace(String mapName, String key, Object value) { return hazelcast.getMap(mapName).replace(key, value); } @Override public void lock(String mapName, String key) throws InterruptedException { if (!hazelcast.getMap(mapName).tryLock(key, 1, TimeUnit.MINUTES)) { throw new RuntimeException("Memcache client could not get the lock for map:" + mapName + " key:" + key + " in 1 minute"); } } @Override public void unlock(String mapName, String key) { hazelcast.getMap(mapName).unlock(key); } @Override public void deleteAll(String mapName) { final IMap<Object, Object> map = hazelcast.getMap(mapName); map.clear(); } @Override public Object delete(String mapName, String key) { return hazelcast.getMap(mapName).remove(key); } @Override public boolean offer(String queueName, Object value) { return hazelcast.getQueue(queueName).offer(value); } @Override public Object poll(String queueName, int seconds) { try { return hazelcast.getQueue(queueName).poll(seconds, TimeUnit.SECONDS); } catch (InterruptedException e) { return null; } } @Override public Object poll(String queueName) { return hazelcast.getQueue(queueName).poll(); } @Override public int size(String queueName) { return hazelcast.getQueue(queueName).size(); } @Override public void sendResponse(TextCommand textCommand) { if (!textCommand.shouldReply() || textCommand.getRequestId() == -1) { throw new RuntimeException("Shouldn't reply " + textCommand); } responseThreadRunnable.sendResponse(textCommand); } public void stop() { final ResponseThreadRunnable rtr = responseThreadRunnable; if (rtr != null) { rtr.stop(); } } class CommandExecutor implements Runnable { final TextCommand command; CommandExecutor(TextCommand command) { this.command = command; } @Override public void run() { try { TextCommandType type = command.getType(); TextCommandProcessor textCommandProcessor = textCommandProcessors[type.getValue()]; textCommandProcessor.handle(command); } catch (Throwable e) { logger.warning(e); } } } private class ResponseThreadRunnable implements Runnable { private final BlockingQueue<TextCommand> blockingQueue = new ArrayBlockingQueue<TextCommand>(200); private final Object stopObject = new Object(); @edu.umd.cs.findbugs.annotations.SuppressWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE") public void sendResponse(TextCommand textCommand) { blockingQueue.offer(textCommand); } @Override public void run() { while (running) { try { TextCommand textCommand = blockingQueue.take(); if (TextCommandConstants.TextCommandType.STOP == textCommand.getType()) { synchronized (stopObject) { stopObject.notify(); } } else { SocketTextWriter socketTextWriter = textCommand.getSocketTextWriter(); socketTextWriter.enqueue(textCommand); } } catch (InterruptedException e) { return; } catch (OutOfMemoryError e) { OutOfMemoryErrorDispatcher.onOutOfMemory(e); throw e; } } } @edu.umd.cs.findbugs.annotations.SuppressWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE") void stop() { running = false; synchronized (stopObject) { try { blockingQueue.offer(new AbstractTextCommand(TextCommandConstants.TextCommandType.STOP) { @Override public boolean readFrom(ByteBuffer cb) { return true; } @Override public boolean writeTo(ByteBuffer bb) { return true; } }); //noinspection WaitNotInLoop stopObject.wait(1000); } catch (Exception ignored) { } } } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandServiceImpl.java
16
class CommandExecutor implements Runnable { final TextCommand command; CommandExecutor(TextCommand command) { this.command = command; } @Override public void run() { try { TextCommandType type = command.getType(); TextCommandProcessor textCommandProcessor = textCommandProcessors[type.getValue()]; textCommandProcessor.handle(command); } catch (Throwable e) { logger.warning(e); } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandServiceImpl.java
17
private class ResponseThreadRunnable implements Runnable { private final BlockingQueue<TextCommand> blockingQueue = new ArrayBlockingQueue<TextCommand>(200); private final Object stopObject = new Object(); @edu.umd.cs.findbugs.annotations.SuppressWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE") public void sendResponse(TextCommand textCommand) { blockingQueue.offer(textCommand); } @Override public void run() { while (running) { try { TextCommand textCommand = blockingQueue.take(); if (TextCommandConstants.TextCommandType.STOP == textCommand.getType()) { synchronized (stopObject) { stopObject.notify(); } } else { SocketTextWriter socketTextWriter = textCommand.getSocketTextWriter(); socketTextWriter.enqueue(textCommand); } } catch (InterruptedException e) { return; } catch (OutOfMemoryError e) { OutOfMemoryErrorDispatcher.onOutOfMemory(e); throw e; } } } @edu.umd.cs.findbugs.annotations.SuppressWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE") void stop() { running = false; synchronized (stopObject) { try { blockingQueue.offer(new AbstractTextCommand(TextCommandConstants.TextCommandType.STOP) { @Override public boolean readFrom(ByteBuffer cb) { return true; } @Override public boolean writeTo(ByteBuffer bb) { return true; } }); //noinspection WaitNotInLoop stopObject.wait(1000); } catch (Exception ignored) { } } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandServiceImpl.java
18
blockingQueue.offer(new AbstractTextCommand(TextCommandConstants.TextCommandType.STOP) { @Override public boolean readFrom(ByteBuffer cb) { return true; } @Override public boolean writeTo(ByteBuffer bb) { return true; } });
false
hazelcast_src_main_java_com_hazelcast_ascii_TextCommandServiceImpl.java
19
public abstract class TypeAwareCommandParser implements CommandParser { protected final TextCommandConstants.TextCommandType type; protected TypeAwareCommandParser(TextCommandConstants.TextCommandType type) { this.type = type; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_TypeAwareCommandParser.java
20
public class DeleteCommand extends AbstractTextCommand { ByteBuffer response; private final String key; private final int expiration; private final boolean noreply; public DeleteCommand(String key, int expiration, boolean noreply) { super(TextCommandType.DELETE); this.key = key; this.expiration = expiration; this.noreply = noreply; } public boolean readFrom(ByteBuffer cb) { return true; } public void setResponse(byte[] value) { this.response = ByteBuffer.wrap(value); } public boolean writeTo(ByteBuffer bb) { if (response == null) { response = ByteBuffer.wrap(STORED); } while (bb.hasRemaining() && response.hasRemaining()) { bb.put(response.get()); } return !response.hasRemaining(); } public boolean shouldReply() { return !noreply; } public int getExpiration() { return expiration; } public String getKey() { return key; } @Override public String toString() { return "DeleteCommand [" + type + "]{" + "key='" + key + '\'' + ", expiration=" + expiration + ", noreply=" + noreply + '}' + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_DeleteCommand.java
21
public class DeleteCommandParser implements CommandParser { public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String key = null; int expiration = 0; boolean noReply = false; if (st.hasMoreTokens()) { key = st.nextToken(); } if (st.hasMoreTokens()) { expiration = Integer.parseInt(st.nextToken()); } if (st.hasMoreTokens()) { noReply = "noreply".equals(st.nextToken()); } return new DeleteCommand(key, expiration, noReply); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_DeleteCommandParser.java
22
public class DeleteCommandProcessor extends MemcacheCommandProcessor<DeleteCommand> { public DeleteCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(DeleteCommand command) { String key; try { key = URLDecoder.decode(command.getKey(), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(format("failed to decode key [%s] using UTF-8", command.getKey())); } String mapName = DEFAULT_MAP_NAME; int index = key.indexOf(':'); if (index != -1) { mapName = MAP_NAME_PRECEDER + key.substring(0, index); key = key.substring(index + 1); } if (key.equals("")) { textCommandService.deleteAll(mapName); } else { final Object oldValue = textCommandService.delete(mapName, key); if (oldValue == null) { textCommandService.incrementDeleteMissCount(); command.setResponse(NOT_FOUND); } else { textCommandService.incrementDeleteHitCount(1); command.setResponse(DELETED); } } if (command.shouldReply()) { textCommandService.sendResponse(command); } } public void handleRejection(DeleteCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_DeleteCommandProcessor.java
23
public class EndCommand extends NoOpCommand { public EndCommand() { super(END); } @Override public String toString() { return "EndCommand{}"; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_EndCommand.java
24
public class ErrorCommand extends AbstractTextCommand { ByteBuffer response; private final String message; public ErrorCommand(TextCommandType type) { this(type, null); } public ErrorCommand(TextCommandType type, String message) { super(type); byte[] error = ERROR; if (type == TextCommandType.ERROR_CLIENT) { error = CLIENT_ERROR; } else if (type == TextCommandType.ERROR_SERVER) { error = SERVER_ERROR; } this.message = message; byte[] msg = (message == null) ? null : stringToBytes(message); int total = error.length; if (msg != null) { total += msg.length; } total += 2; response = ByteBuffer.allocate(total); response.put(error); if (msg != null) { response.put(msg); } response.put(RETURN); response.flip(); } public boolean readFrom(ByteBuffer cb) { return true; } public boolean writeTo(ByteBuffer bb) { IOUtil.copyToHeapBuffer(response, bb); return !response.hasRemaining(); } @Override public String toString() { return "ErrorCommand{" + "type=" + type + ", msg=" + message + '}' + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_ErrorCommand.java
25
public class ErrorCommandProcessor extends AbstractTextCommandProcessor<ErrorCommand> { public ErrorCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(ErrorCommand command) { textCommandService.sendResponse(command); } public void handleRejection(ErrorCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_ErrorCommandProcessor.java
26
public class GetCommand extends AbstractTextCommand { final String key; ByteBuffer value; ByteBuffer lastOne; public GetCommand(TextCommandType type, String key) { super(type); this.key = key; } public GetCommand(String key) { this(TextCommandType.GET, key); } public String getKey() { return key; } public boolean readFrom(ByteBuffer cb) { return true; } public void setValue(MemcacheEntry entry, boolean singleGet) { if (entry != null) { value = entry.toNewBuffer(); } lastOne = (singleGet) ? ByteBuffer.wrap(END) : null; } public boolean writeTo(ByteBuffer bb) { if (value != null) { IOUtil.copyToHeapBuffer(value, bb); } if (lastOne != null) { IOUtil.copyToHeapBuffer(lastOne, bb); } return !((value != null && value.hasRemaining()) || (lastOne != null && lastOne.hasRemaining())); } @Override public String toString() { return "GetCommand{" + "key='" + key + ", value=" + value + '\'' + "} " + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_GetCommand.java
27
public class GetCommandParser implements CommandParser { public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { String key = cmd.substring(space + 1); if (key.indexOf(' ') == -1) { GetCommand r = new GetCommand(key); socketTextReader.publishRequest(r); } else { StringTokenizer st = new StringTokenizer(key); while (st.hasMoreTokens()) { PartialGetCommand r = new PartialGetCommand(st.nextToken()); socketTextReader.publishRequest(r); } socketTextReader.publishRequest(new EndCommand()); } return null; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_GetCommandParser.java
28
public class GetCommandProcessor extends MemcacheCommandProcessor<GetCommand> { final boolean single; private final ILogger logger; public GetCommandProcessor(TextCommandService textCommandService, boolean single) { super(textCommandService); this.single = single; logger = textCommandService.getNode().getLogger(this.getClass().getName()); } public void handle(GetCommand getCommand) { String key = null; try { key = URLDecoder.decode(getCommand.getKey(), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new HazelcastException(e); } String mapName = DEFAULT_MAP_NAME; int index = key.indexOf(':'); if (index != -1) { mapName = MAP_NAME_PRECEDER + key.substring(0, index); key = key.substring(index + 1); } Object value = textCommandService.get(mapName, key); MemcacheEntry entry = null; if (value != null) { if (value instanceof MemcacheEntry) { entry = (MemcacheEntry) value; } else if (value instanceof byte[]) { entry = new MemcacheEntry(getCommand.getKey(), ((byte[]) value), 0); } else if (value instanceof String) { entry = new MemcacheEntry(getCommand.getKey(), stringToBytes((String) value), 0); } else { try { entry = new MemcacheEntry(getCommand.getKey(), textCommandService.toByteArray(value), 0); } catch (Exception e) { logger.warning(e); } } } if (entry != null) { textCommandService.incrementGetHitCount(); } else { textCommandService.incrementGetMissCount(); } getCommand.setValue(entry, single); textCommandService.sendResponse(getCommand); } public void handleRejection(GetCommand getCommand) { getCommand.setValue(null, single); textCommandService.sendResponse(getCommand); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_GetCommandProcessor.java
29
public class IncrementCommand extends AbstractTextCommand { String key; int value; boolean noreply; ByteBuffer response; public IncrementCommand(TextCommandType type, String key, int value, boolean noReply) { super(type); this.key = key; this.value = value; this.noreply = noReply; } public boolean writeTo(ByteBuffer destination) { while (destination.hasRemaining() && response.hasRemaining()) { destination.put(response.get()); } return !response.hasRemaining(); } public boolean readFrom(ByteBuffer source) { return true; } public boolean shouldReply() { return !noreply; } public String getKey() { return key; } public int getValue() { return value; } public void setResponse(byte[] value) { this.response = ByteBuffer.wrap(value); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_IncrementCommand.java
30
public class IncrementCommandParser extends TypeAwareCommandParser { public IncrementCommandParser(TextCommandType type) { super(type); } public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String key = null; int value = 0; boolean noReply = false; if (st.hasMoreTokens()) { key = st.nextToken(); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { value = Integer.parseInt(st.nextToken()); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { noReply = "noreply".equals(st.nextToken()); } return new IncrementCommand(type, key, value, noReply); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_IncrementCommandParser.java
31
public class IncrementCommandProcessor extends MemcacheCommandProcessor<IncrementCommand> { private final ILogger logger; public IncrementCommandProcessor(TextCommandServiceImpl textCommandService) { super(textCommandService); logger = textCommandService.getNode().getLogger(this.getClass().getName()); } public void handle(IncrementCommand incrementCommand) { String key = null; try { key = URLDecoder.decode(incrementCommand.getKey(), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new HazelcastException(e); } String mapName = DEFAULT_MAP_NAME; int index = key.indexOf(':'); if (index != -1) { mapName = MAP_NAME_PRECEDER + key.substring(0, index); key = key.substring(index + 1); } try { textCommandService.lock(mapName, key); } catch (Exception e) { incrementCommand.setResponse(NOT_FOUND); if (incrementCommand.shouldReply()) { textCommandService.sendResponse(incrementCommand); } return; } Object value = textCommandService.get(mapName, key); MemcacheEntry entry = null; if (value != null) { if (value instanceof MemcacheEntry) { entry = (MemcacheEntry) value; } else if (value instanceof byte[]) { entry = new MemcacheEntry(incrementCommand.getKey(), (byte[]) value, 0); } else if (value instanceof String) { entry = new MemcacheEntry(incrementCommand.getKey(), stringToBytes((String) value), 0); } else { try { entry = new MemcacheEntry(incrementCommand.getKey(), textCommandService.toByteArray(value), 0); } catch (Exception e) { throw ExceptionUtil.rethrow(e); } } final byte[] value1 = entry.getValue(); final long current = (value1 == null || value1.length == 0) ? 0 : byteArrayToLong(value1); long result = -1; if (incrementCommand.getType() == TextCommandType.INCREMENT) { result = current + incrementCommand.getValue(); result = 0 > result ? Long.MAX_VALUE : result; textCommandService.incrementIncHitCount(); } else if (incrementCommand.getType() == TextCommandType.DECREMENT) { result = current - incrementCommand.getValue(); result = 0 > result ? 0 : result; textCommandService.incrementDecrHitCount(); } incrementCommand.setResponse(ByteUtil.concatenate(stringToBytes(String.valueOf(result)), RETURN)); MemcacheEntry newValue = new MemcacheEntry(key, longToByteArray(result), entry.getFlag()); textCommandService.put(mapName, key, newValue); } else { if (incrementCommand.getType() == TextCommandType.INCREMENT) { textCommandService.incrementIncMissCount(); } else { textCommandService.incrementDecrMissCount(); } incrementCommand.setResponse(NOT_FOUND); } textCommandService.unlock(mapName, key); if (incrementCommand.shouldReply()) { textCommandService.sendResponse(incrementCommand); } } public void handleRejection(IncrementCommand incrementCommand) { incrementCommand.setResponse(NOT_FOUND); if (incrementCommand.shouldReply()) { textCommandService.sendResponse(incrementCommand); } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_IncrementCommandProcessor.java
32
public abstract class MemcacheCommandProcessor<T> extends AbstractTextCommandProcessor<T> { public static final String MAP_NAME_PRECEDER = "hz_memcache_"; public static final String DEFAULT_MAP_NAME = "hz_memcache_default"; protected MemcacheCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public static byte[] longToByteArray(long v) { int len = (int) (v / 256) + 1; final byte[] bytes = new byte[len]; for (int i = len - 1; i >= 0; i--) { final long t = v % 256; bytes[i] = t < 128 ? (byte) t : (byte) (t - 256); v = (v - t) / 256; } return bytes; } public static int byteArrayToLong(byte[] v) { if (v.length > 8) { return -1; } int r = 0; for (int i = 0; i < v.length; i++) { int t = (int) v[i]; t = t >= 0 ? t : t + 256; r = r * 256 + t; } return r; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_MemcacheCommandProcessor.java
33
@edu.umd.cs.findbugs.annotations.SuppressWarnings("EI_EXPOSE_REP") public class MemcacheEntry implements DataSerializable, TextCommandConstants { private byte[] bytes; private byte[] value; private int flag; public MemcacheEntry(String key, byte[] value, int flag) { byte[] flagBytes = stringToBytes(" " + flag + " "); byte[] valueLen = stringToBytes(String.valueOf(value.length)); byte[] keyBytes = stringToBytes(key); this.value = value.clone(); int size = VALUE_SPACE.length + keyBytes.length + flagBytes.length + valueLen.length + RETURN.length + value.length + RETURN.length; ByteBuffer entryBuffer = ByteBuffer.allocate(size); entryBuffer.put(VALUE_SPACE); entryBuffer.put(keyBytes); entryBuffer.put(flagBytes); entryBuffer.put(valueLen); entryBuffer.put(RETURN); entryBuffer.put(value); entryBuffer.put(RETURN); this.bytes = entryBuffer.array(); this.flag = flag; } public MemcacheEntry() { } public void readData(ObjectDataInput in) throws IOException { int size = in.readInt(); bytes = new byte[size]; in.readFully(bytes); size = in.readInt(); value = new byte[size]; in.readFully(value); flag = in.readInt(); } public void writeData(ObjectDataOutput out) throws IOException { out.writeInt(bytes.length); out.write(bytes); out.writeInt(value.length); out.write(value); out.writeInt(flag); } public ByteBuffer toNewBuffer() { return ByteBuffer.wrap(bytes); } public int getFlag() { return flag; } public byte[] getBytes() { return bytes; } public byte[] getValue() { return value; } public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } MemcacheEntry that = (MemcacheEntry) o; if (flag != that.flag) { return false; } if (!Arrays.equals(bytes, that.bytes)) { return false; } if (!Arrays.equals(value, that.value)) { return false; } return true; } public int hashCode() { int result = bytes != null ? Arrays.hashCode(bytes) : 0; result = 31 * result + (value != null ? Arrays.hashCode(value) : 0); result = 31 * result + flag; return result; } public String toString() { return "MemcacheEntry{" + "bytes=" + bytesToString(bytes) + ", flag=" + flag + '}'; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_MemcacheEntry.java
34
public class PartialGetCommand extends GetCommand { public PartialGetCommand(String key) { super(TextCommandType.PARTIAL_GET, key); } @Override public String toString() { return "PartialGetCommand{" + "key='" + key + '\'' + '}'; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_PartialGetCommand.java
35
public class SetCommand extends AbstractTextCommand { ByteBuffer response; private final String key; private final int flag; private final int expiration; private final int valueLen; private final boolean noreply; private final ByteBuffer bbValue; public SetCommand(TextCommandType type, String key, int flag, int expiration, int valueLen, boolean noreply) { super(type); this.key = key; this.flag = flag; this.expiration = expiration; this.valueLen = valueLen; this.noreply = noreply; bbValue = ByteBuffer.allocate(valueLen); } public boolean readFrom(ByteBuffer cb) { copy(cb); if (!bbValue.hasRemaining()) { while (cb.hasRemaining()) { char c = (char) cb.get(); if (c == '\n') { bbValue.flip(); return true; } } } return false; } void copy(ByteBuffer cb) { if (cb.isDirect()) { int n = Math.min(cb.remaining(), bbValue.remaining()); if (n > 0) { cb.get(bbValue.array(), bbValue.position(), n); bbValue.position(bbValue.position() + n); } } else { IOUtil.copyToHeapBuffer(cb, bbValue); } } public void setResponse(byte[] value) { this.response = ByteBuffer.wrap(value); } public boolean writeTo(ByteBuffer bb) { if (response == null) { response = ByteBuffer.wrap(STORED); } while (bb.hasRemaining() && response.hasRemaining()) { bb.put(response.get()); } return !response.hasRemaining(); } public boolean shouldReply() { return !noreply; } public int getExpiration() { return expiration; } public String getKey() { return key; } public byte[] getValue() { return bbValue.array(); } public int getFlag() { return flag; } @Override public String toString() { return "SetCommand [" + type + "]{" + "key='" + key + '\'' + ", flag=" + flag + ", expiration=" + expiration + ", valueLen=" + valueLen + ", value=" + bbValue + '}' + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_SetCommand.java
36
public class SetCommandParser extends TypeAwareCommandParser { public SetCommandParser(TextCommandConstants.TextCommandType type) { super(type); } public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String key = null; int valueLen = 0; int flag = 0; int expiration = 0; boolean noReply = false; if (st.hasMoreTokens()) { key = st.nextToken(); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { flag = Integer.parseInt(st.nextToken()); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { expiration = Integer.parseInt(st.nextToken()); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { valueLen = Integer.parseInt(st.nextToken()); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { noReply = "noreply".equals(st.nextToken()); } return new SetCommand(type, key, flag, expiration, valueLen, noReply); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_SetCommandParser.java
37
public class SetCommandProcessor extends MemcacheCommandProcessor<SetCommand> { private final ILogger logger; public SetCommandProcessor(TextCommandService textCommandService) { super(textCommandService); logger = textCommandService.getNode().getLogger(this.getClass().getName()); } /** * "set" means "store this data". * <p/> * "add" means "store this data, but only if the server *doesn't* already * hold data for this key". * <p/> * "replace" means "store this data, but only if the server *does* * already hold data for this key". * <p/> * <p/> * After sending the command line and the data block the client awaits * the reply, which may be: * <p/> * - "STORED\r\n", to indicate success. * <p/> * - "NOT_STORED\r\n" to indicate the data was not stored, but not * because of an error. This normally means that either that the * condition for an "add" or a "replace" command wasn't met, or that the * item is in a delete queue (see the "delete" command below). */ public void handle(SetCommand setCommand) { String key = null; try { key = URLDecoder.decode(setCommand.getKey(), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new HazelcastException(e); } String mapName = DEFAULT_MAP_NAME; int index = key.indexOf(':'); if (index != -1) { mapName = MAP_NAME_PRECEDER + key.substring(0, index); key = key.substring(index + 1); } Object value = new MemcacheEntry(setCommand.getKey(), setCommand.getValue(), setCommand.getFlag()); int ttl = textCommandService.getAdjustedTTLSeconds(setCommand.getExpiration()); textCommandService.incrementSetCount(); if (SET == setCommand.getType()) { textCommandService.put(mapName, key, value, ttl); setCommand.setResponse(STORED); } else if (ADD == setCommand.getType()) { boolean added = (textCommandService.putIfAbsent(mapName, key, value, ttl) == null); if (added) { setCommand.setResponse(STORED); } else { setCommand.setResponse(NOT_STORED); } } else if (REPLACE == setCommand.getType()) { boolean replaced = (textCommandService.replace(mapName, key, value) != null); if (replaced) { setCommand.setResponse(STORED); } else { setCommand.setResponse(NOT_STORED); } } else if (APPEND == setCommand.getType()) { try { textCommandService.lock(mapName, key); } catch (Exception e) { setCommand.setResponse(NOT_STORED); if (setCommand.shouldReply()) { textCommandService.sendResponse(setCommand); } return; } Object oldValue = textCommandService.get(mapName, key); MemcacheEntry entry = null; if (oldValue != null) { if (oldValue instanceof MemcacheEntry) { final MemcacheEntry oldEntry = (MemcacheEntry) oldValue; entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(oldEntry.getValue(), setCommand.getValue()), 0); } else if (oldValue instanceof byte[]) { entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(((byte[]) oldValue), setCommand.getValue()), 0); } else if (oldValue instanceof String) { entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(stringToBytes((String) oldValue), setCommand.getValue()), 0); } else { try { entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(textCommandService.toByteArray(oldValue), setCommand.getValue()), 0); } catch (Exception e) { logger.warning(e); } } textCommandService.put(mapName, key, entry, ttl); setCommand.setResponse(STORED); } else { setCommand.setResponse(NOT_STORED); } textCommandService.unlock(mapName, key); } else if (PREPEND == setCommand.getType()) { try { textCommandService.lock(mapName, key); } catch (Exception e) { setCommand.setResponse(NOT_STORED); if (setCommand.shouldReply()) { textCommandService.sendResponse(setCommand); } return; } Object oldValue = textCommandService.get(mapName, key); MemcacheEntry entry = null; if (oldValue != null) { if (oldValue instanceof MemcacheEntry) { final MemcacheEntry oldEntry = (MemcacheEntry) oldValue; entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(setCommand.getValue(), oldEntry.getValue()), oldEntry.getFlag()); } else if (oldValue instanceof byte[]) { entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(setCommand.getValue(), ((byte[]) oldValue)), 0); } else if (oldValue instanceof String) { entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(setCommand.getValue(), stringToBytes((String) oldValue)), 0); } else { try { entry = new MemcacheEntry(setCommand.getKey(), ByteUtil.concatenate(setCommand.getValue(), textCommandService.toByteArray(oldValue)), 0); } catch (Exception e) { logger.warning(e); } } textCommandService.put(mapName, key, entry, ttl); setCommand.setResponse(STORED); } else { setCommand.setResponse(NOT_STORED); } textCommandService.unlock(mapName, key); } if (setCommand.shouldReply()) { textCommandService.sendResponse(setCommand); } } public void handleRejection(SetCommand request) { request.setResponse(NOT_STORED); if (request.shouldReply()) { textCommandService.sendResponse(request); } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_SetCommandProcessor.java
38
public class SimpleCommand extends AbstractTextCommand { ByteBuffer response; public SimpleCommand(TextCommandType type) { super(type); } public boolean readFrom(ByteBuffer cb) { return true; } public void setResponse(byte[] value) { this.response = ByteBuffer.wrap(value); } public boolean writeTo(ByteBuffer bb) { while (bb.hasRemaining() && response.hasRemaining()) { bb.put(response.get()); } return !response.hasRemaining(); } @Override public String toString() { return "SimpleCommand [" + type + "]{" + '}' + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_SimpleCommand.java
39
public class SimpleCommandParser extends TypeAwareCommandParser { public SimpleCommandParser(TextCommandConstants.TextCommandType type) { super(type); } public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { if (type == QUIT) { return new SimpleCommand(type); } else if (type == STATS) { return new StatsCommand(); } else if (type == VERSION) { return new VersionCommand(type); } else { return new ErrorCommand(UNKNOWN); } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_SimpleCommandParser.java
40
public class SimpleCommandProcessor extends MemcacheCommandProcessor<SimpleCommand> { private final ILogger logger; public SimpleCommandProcessor(TextCommandService textCommandService) { super(textCommandService); logger = textCommandService.getNode().getLogger(this.getClass().getName()); } public void handle(SimpleCommand command) { if (command.getType() == QUIT) { try { command.getSocketTextReader().closeConnection(); } catch (Exception e) { logger.warning(e); } } else if (command.getType() == UNKNOWN) { command.setResponse(ERROR); textCommandService.sendResponse(command); } } public void handleRejection(SimpleCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_SimpleCommandProcessor.java
41
public class Stats { public int waiting_requests; public int threads; public int uptime; //seconds public long cmd_get; public long cmd_set; public long cmd_touch; public long get_hits; public long get_misses; public long delete_hits; public long delete_misses; public long incr_hits; public long incr_misses; public long decr_hits; public long decr_misses; public long bytes; public int curr_connections; public int total_connections; // public Stats(int uptime, int threads, long get_misses, long get_hits, long cmd_set, long cmd_get, long bytes) { // this.uptime = uptime; // this.threads = threads; // this.get_misses = get_misses; // this.get_hits = get_hits; // this.cmd_set = cmd_set; // this.cmd_get = cmd_get; // this.bytes = bytes; // } public Stats() { } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_Stats.java
42
public class StatsCommand extends AbstractTextCommand { static final byte[] STAT = stringToBytes("STAT "); static final byte[] UPTIME = stringToBytes("uptime "); static final byte[] BYTES = stringToBytes("bytes "); static final byte[] CMD_SET = stringToBytes("cmd_set "); static final byte[] CMD_GET = stringToBytes("cmd_get "); static final byte[] CMD_TOUCH = stringToBytes("cmd_touch "); static final byte[] THREADS = stringToBytes("threads "); static final byte[] WAITING_REQUESTS = stringToBytes("waiting_requests "); static final byte[] GET_HITS = stringToBytes("get_hits "); static final byte[] GET_MISSES = stringToBytes("get_misses "); static final byte[] DELETE_HITS = stringToBytes("delete_hits "); static final byte[] DELETE_MISSES = stringToBytes("delete_misses "); static final byte[] INCR_HITS = stringToBytes("incr_hits "); static final byte[] INCR_MISSES = stringToBytes("incr_misses "); static final byte[] DECR_HITS = stringToBytes("decr_hits "); static final byte[] DECR_MISSES = stringToBytes("decr_misses "); static final byte[] CURR_CONNECTIONS = stringToBytes("curr_connections "); static final byte[] TOTAL_CONNECTIONS = stringToBytes("total_connections "); ByteBuffer response; public StatsCommand() { super(TextCommandType.STATS); } public boolean readFrom(ByteBuffer cb) { return true; } public void setResponse(Stats stats) { response = ByteBuffer.allocate(1000); putInt(UPTIME, stats.uptime); putInt(THREADS, stats.threads); putInt(WAITING_REQUESTS, stats.waiting_requests); putInt(CURR_CONNECTIONS, stats.curr_connections); putInt(TOTAL_CONNECTIONS, stats.total_connections); putLong(BYTES, stats.bytes); putLong(CMD_GET, stats.cmd_get); putLong(CMD_SET, stats.cmd_set); putLong(CMD_TOUCH, stats.cmd_touch); putLong(GET_HITS, stats.get_hits); putLong(GET_MISSES, stats.get_misses); putLong(DELETE_HITS, stats.delete_hits); putLong(DELETE_MISSES, stats.delete_misses); putLong(INCR_HITS, stats.incr_hits); putLong(INCR_MISSES, stats.incr_misses); putLong(DECR_HITS, stats.decr_hits); putLong(DECR_MISSES, stats.decr_misses); response.put(END); response.flip(); } private void putInt(byte[] name, int value) { response.put(STAT); response.put(name); response.put(stringToBytes(String.valueOf(value))); response.put(RETURN); } private void putLong(byte[] name, long value) { response.put(STAT); response.put(name); response.put(stringToBytes(String.valueOf(value))); response.put(RETURN); } public boolean writeTo(ByteBuffer bb) { if (response == null) { response = ByteBuffer.allocate(0); } IOUtil.copyToHeapBuffer(response, bb); return !response.hasRemaining(); } @Override public String toString() { return "StatsCommand{" + '}' + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_StatsCommand.java
43
public class StatsCommandProcessor extends MemcacheCommandProcessor<StatsCommand> { public StatsCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(StatsCommand command) { Stats stats = textCommandService.getStats(); command.setResponse(stats); textCommandService.sendResponse(command); } public void handleRejection(StatsCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_StatsCommandProcessor.java
44
public class TouchCommand extends AbstractTextCommand { String key; int expiration; boolean noreply; ByteBuffer response; public TouchCommand(TextCommandType type, String key, int expiration, boolean noReply) { super(type); this.key = key; this.expiration = expiration; this.noreply = noReply; } public boolean writeTo(ByteBuffer destination) { if (response == null) { response = ByteBuffer.wrap(STORED); } while (destination.hasRemaining() && response.hasRemaining()) { destination.put(response.get()); } return !response.hasRemaining(); } public boolean readFrom(ByteBuffer source) { return true; } public boolean shouldReply() { return !noreply; } public String getKey() { return key; } public int getExpiration() { return expiration; } public void setResponse(byte[] value) { this.response = ByteBuffer.wrap(value); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_TouchCommand.java
45
public class TouchCommandParser extends TypeAwareCommandParser { public TouchCommandParser(TextCommandType type) { super(type); } public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String key = null; int expiration = 0; boolean noReply = false; if (st.hasMoreTokens()) { key = st.nextToken(); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { expiration = Integer.parseInt(st.nextToken()); } else { return new ErrorCommand(ERROR_CLIENT); } if (st.hasMoreTokens()) { noReply = "noreply".equals(st.nextToken()); } return new TouchCommand(type, key, expiration, noReply); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_TouchCommandParser.java
46
public class TouchCommandProcessor extends MemcacheCommandProcessor<TouchCommand> { private final ILogger logger; public TouchCommandProcessor(TextCommandServiceImpl textCommandService) { super(textCommandService); logger = textCommandService.getNode().getLogger(this.getClass().getName()); } public void handle(TouchCommand touchCommand) { String key = null; try { key = URLDecoder.decode(touchCommand.getKey(), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new HazelcastException(e); } String mapName = DEFAULT_MAP_NAME; int index = key.indexOf(':'); if (index != -1) { mapName = MAP_NAME_PRECEDER + key.substring(0, index); key = key.substring(index + 1); } int ttl = textCommandService.getAdjustedTTLSeconds(touchCommand.getExpiration()); try { textCommandService.lock(mapName, key); } catch (Exception e) { touchCommand.setResponse(NOT_STORED); if (touchCommand.shouldReply()) { textCommandService.sendResponse(touchCommand); } return; } final Object value = textCommandService.get(mapName, key); textCommandService.incrementTouchCount(); if (value != null) { textCommandService.put(mapName, key, value, ttl); touchCommand.setResponse(TOUCHED); } else { touchCommand.setResponse(NOT_STORED); } textCommandService.unlock(mapName, key); if (touchCommand.shouldReply()) { textCommandService.sendResponse(touchCommand); } } public void handleRejection(TouchCommand request) { request.setResponse(NOT_STORED); if (request.shouldReply()) { textCommandService.sendResponse(request); } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_TouchCommandProcessor.java
47
public class VersionCommand extends AbstractTextCommand { private static final byte[] VERSION = stringToBytes("VERSION Hazelcast\r\n"); protected VersionCommand(TextCommandType type) { super(type); } public boolean writeTo(ByteBuffer destination) { destination.put(VERSION); return true; } public boolean readFrom(ByteBuffer source) { return true; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_VersionCommand.java
48
public class VersionCommandProcessor extends MemcacheCommandProcessor<VersionCommand> { public VersionCommandProcessor(TextCommandServiceImpl textCommandService) { super(textCommandService); } public void handle(VersionCommand request) { textCommandService.sendResponse(request); } public void handleRejection(VersionCommand request) { handle(request); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_memcache_VersionCommandProcessor.java
49
@edu.umd.cs.findbugs.annotations.SuppressWarnings({ "EI_EXPOSE_REP", "MS_MUTABLE_ARRAY", "MS_PKGPROTECT" }) public abstract class HttpCommand extends AbstractTextCommand { public static final String HEADER_CONTENT_TYPE = "content-type: "; public static final String HEADER_CONTENT_LENGTH = "content-length: "; public static final String HEADER_CHUNKED = "transfer-encoding: chunked"; public static final String HEADER_EXPECT_100 = "expect: 100"; public static final byte[] RES_200 = stringToBytes("HTTP/1.1 200 OK\r\n"); public static final byte[] RES_400 = stringToBytes("HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n"); public static final byte[] RES_403 = stringToBytes("HTTP/1.1 403 Forbidden\r\n\r\n"); public static final byte[] RES_404 = stringToBytes("HTTP/1.1 404 Not Found\r\n\r\n"); public static final byte[] RES_100 = stringToBytes("HTTP/1.1 100 Continue\r\n\r\n"); public static final byte[] RES_204 = stringToBytes("HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n"); public static final byte[] RES_503 = stringToBytes("HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\n\r\n"); public static final byte[] RES_500 = stringToBytes("HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\n\r\n"); public static final byte[] CONTENT_TYPE = stringToBytes("Content-Type: "); public static final byte[] CONTENT_LENGTH = stringToBytes("Content-Length: "); public static final byte[] CONTENT_TYPE_PLAIN_TEXT = stringToBytes("text/plain"); public static final byte[] CONTENT_TYPE_BINARY = stringToBytes("application/binary"); protected final String uri; protected ByteBuffer response; public HttpCommand(TextCommandType type, String uri) { super(type); this.uri = uri; } public boolean shouldReply() { return true; } public String getURI() { return uri; } public void send204() { this.response = ByteBuffer.wrap(RES_204); } public void send400() { this.response = ByteBuffer.wrap(RES_400); } public void setResponse(byte[] value) { this.response = ByteBuffer.wrap(value); } public void send200() { setResponse(null, null); } /** * HTTP/1.0 200 OK * Date: Fri, 31 Dec 1999 23:59:59 GMT * Content-TextCommandType: text/html * Content-Length: 1354 * * @param contentType * @param value */ public void setResponse(byte[] contentType, byte[] value) { int valueSize = (value == null) ? 0 : value.length; byte[] len = stringToBytes(String.valueOf(valueSize)); int size = RES_200.length; if (contentType != null) { size += CONTENT_TYPE.length; size += contentType.length; size += RETURN.length; } size += CONTENT_LENGTH.length; size += len.length; size += RETURN.length; size += RETURN.length; size += valueSize; size += RETURN.length; this.response = ByteBuffer.allocate(size); response.put(RES_200); if (contentType != null) { response.put(CONTENT_TYPE); response.put(contentType); response.put(RETURN); } response.put(CONTENT_LENGTH); response.put(len); response.put(RETURN); response.put(RETURN); if (value != null) { response.put(value); } response.put(RETURN); response.flip(); } public boolean writeTo(ByteBuffer bb) { IOUtil.copyToHeapBuffer(response, bb); return !response.hasRemaining(); } @Override public String toString() { return "HttpCommand [" + type + "]{" + "uri='" + uri + '\'' + '}' + super.toString(); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpCommand.java
50
public abstract class HttpCommandProcessor<T> extends AbstractTextCommandProcessor<T> { public static final String URI_MAPS = "/hazelcast/rest/maps/"; public static final String URI_QUEUES = "/hazelcast/rest/queues/"; public static final String URI_CLUSTER = "/hazelcast/rest/cluster"; public static final String URI_STATE_DUMP = "/hazelcast/rest/dump"; public static final String URI_MANCENTER_CHANGE_URL = "/hazelcast/rest/mancenter/changeurl"; protected HttpCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpCommandProcessor.java
51
public class HttpDeleteCommand extends HttpCommand { boolean nextLine; public HttpDeleteCommand(String uri) { super(TextCommandType.HTTP_DELETE, uri); } public boolean readFrom(ByteBuffer cb) { while (cb.hasRemaining()) { char c = (char) cb.get(); if (c == '\n') { if (nextLine) { return true; } nextLine = true; } else if (c != '\r') { nextLine = false; } } return false; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpDeleteCommand.java
52
public class HttpDeleteCommandParser implements CommandParser { public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String uri = null; if (st.hasMoreTokens()) { uri = st.nextToken(); } else { return new ErrorCommand(ERROR_CLIENT); } return new HttpDeleteCommand(uri); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpDeleteCommandParser.java
53
public class HttpDeleteCommandProcessor extends HttpCommandProcessor<HttpDeleteCommand> { public HttpDeleteCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(HttpDeleteCommand command) { String uri = command.getURI(); if (uri.startsWith(URI_MAPS)) { int indexEnd = uri.indexOf('/', URI_MAPS.length()); if (indexEnd == -1) { String mapName = uri.substring(URI_MAPS.length(), uri.length()); textCommandService.deleteAll(mapName); command.send200(); } else { String mapName = uri.substring(URI_MAPS.length(), indexEnd); String key = uri.substring(indexEnd + 1); textCommandService.delete(mapName, key); command.send200(); } } else if (uri.startsWith(URI_QUEUES)) { // Poll an item from the default queue in 3 seconds // http://127.0.0.1:5701/hazelcast/rest/queues/default/3 int indexEnd = uri.indexOf('/', URI_QUEUES.length()); String queueName = uri.substring(URI_QUEUES.length(), indexEnd); String secondStr = (uri.length() > (indexEnd + 1)) ? uri.substring(indexEnd + 1) : null; int seconds = (secondStr == null) ? 0 : Integer.parseInt(secondStr); Object value = textCommandService.poll(queueName, seconds); if (value == null) { command.send204(); } else { if (value instanceof byte[]) { command.setResponse(null, (byte[]) value); } else if (value instanceof RestValue) { RestValue restValue = (RestValue) value; command.setResponse(restValue.getContentType(), restValue.getValue()); } else if (value instanceof String) { command.setResponse(HttpCommand.CONTENT_TYPE_PLAIN_TEXT, stringToBytes((String) value)); } else { command.setResponse(null, textCommandService.toByteArray(value)); } } } else { command.send400(); } textCommandService.sendResponse(command); } public void handleRejection(HttpDeleteCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpDeleteCommandProcessor.java
54
public class HttpGetCommand extends HttpCommand { boolean nextLine; public HttpGetCommand(String uri) { super(TextCommandType.HTTP_GET, uri); } public boolean readFrom(ByteBuffer cb) { while (cb.hasRemaining()) { char c = (char) cb.get(); if (c == '\n') { if (nextLine) { return true; } nextLine = true; } else if (c != '\r') { nextLine = false; } } return false; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpGetCommand.java
55
public class HttpGetCommandParser implements CommandParser { public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String uri = null; if (st.hasMoreTokens()) { uri = st.nextToken(); } else { return new ErrorCommand(ERROR_CLIENT); } return new HttpGetCommand(uri); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpGetCommandParser.java
56
public class HttpGetCommandProcessor extends HttpCommandProcessor<HttpGetCommand> { public static final String QUEUE_SIZE_COMMAND = "size"; public HttpGetCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(HttpGetCommand command) { String uri = command.getURI(); if (uri.startsWith(URI_MAPS)) { int indexEnd = uri.indexOf('/', URI_MAPS.length()); String mapName = uri.substring(URI_MAPS.length(), indexEnd); String key = uri.substring(indexEnd + 1); Object value = textCommandService.get(mapName, key); prepareResponse(command, value); } else if (uri.startsWith(URI_QUEUES)) { int indexEnd = uri.indexOf('/', URI_QUEUES.length()); String queueName = uri.substring(URI_QUEUES.length(), indexEnd); String secondStr = (uri.length() > (indexEnd + 1)) ? uri.substring(indexEnd + 1) : null; if (QUEUE_SIZE_COMMAND.equalsIgnoreCase(secondStr)) { int size = textCommandService.size(queueName); prepareResponse(command, Integer.toString(size)); } else { int seconds = (secondStr == null) ? 0 : Integer.parseInt(secondStr); Object value = textCommandService.poll(queueName, seconds); prepareResponse(command, value); } } else if (uri.startsWith(URI_CLUSTER)) { Node node = textCommandService.getNode(); StringBuilder res = new StringBuilder(node.getClusterService().membersString()); res.append("\n"); ConnectionManager connectionManager = node.getConnectionManager(); res.append("ConnectionCount: ").append(connectionManager.getCurrentClientConnections()); res.append("\n"); res.append("AllConnectionCount: ").append(connectionManager.getAllTextConnections()); res.append("\n"); command.setResponse(null, stringToBytes(res.toString())); } else if (uri.startsWith(URI_STATE_DUMP)) { String stateDump = textCommandService.getNode().getSystemLogService().dump(); stateDump += textCommandService.getNode().getPartitionService().toString() + "\n"; command.setResponse(HttpCommand.CONTENT_TYPE_PLAIN_TEXT, stringToBytes(stateDump)); } else { command.send400(); } textCommandService.sendResponse(command); } public void handleRejection(HttpGetCommand command) { handle(command); } private void prepareResponse(HttpGetCommand command, Object value) { if (value == null) { command.send204(); } else { if (value instanceof byte[]) { command.setResponse(HttpCommand.CONTENT_TYPE_BINARY, (byte[]) value); } else if (value instanceof RestValue) { RestValue restValue = (RestValue) value; command.setResponse(restValue.getContentType(), restValue.getValue()); } else if (value instanceof String) { command.setResponse(HttpCommand.CONTENT_TYPE_PLAIN_TEXT, stringToBytes((String) value)); } else { command.setResponse(HttpCommand.CONTENT_TYPE_BINARY, textCommandService.toByteArray(value)); } } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpGetCommandProcessor.java
57
public class HttpPostCommand extends HttpCommand { boolean nextLine; boolean readyToReadData; private ByteBuffer data; private ByteBuffer line = ByteBuffer.allocate(500); private String contentType; private final SocketTextReader socketTextRequestReader; private boolean chunked; public HttpPostCommand(SocketTextReader socketTextRequestReader, String uri) { super(TextCommandType.HTTP_POST, uri); this.socketTextRequestReader = socketTextRequestReader; } /** * POST /path HTTP/1.0 * User-Agent: HTTPTool/1.0 * Content-TextCommandType: application/x-www-form-urlencoded * Content-Length: 45 * <next_line> * <next_line> * byte[45] * <next_line> * * @param cb * @return */ public boolean readFrom(ByteBuffer cb) { boolean complete = doActualRead(cb); while (!complete && readyToReadData && chunked && cb.hasRemaining()) { complete = doActualRead(cb); } if (complete) { if (data != null) { data.flip(); } } return complete; } public byte[] getData() { if (data == null) { return null; } else { return data.array(); } } public byte[] getContentType() { if (contentType == null) { return null; } else { return stringToBytes(contentType); } } public boolean doActualRead(ByteBuffer cb) { if (readyToReadData) { if (chunked && (data == null || !data.hasRemaining())) { boolean hasLine = readLine(cb); String lineStr = null; if (hasLine) { lineStr = toStringAndClear(line).trim(); } if (hasLine) { // hex string int dataSize = lineStr.length() == 0 ? 0 : Integer.parseInt(lineStr, 16); if (dataSize == 0) { return true; } if (data != null) { ByteBuffer newData = ByteBuffer.allocate(data.capacity() + dataSize); newData.put(data.array()); data = newData; } else { data = ByteBuffer.allocate(dataSize); } } } IOUtil.copyToHeapBuffer(cb, data); } while (!readyToReadData && cb.hasRemaining()) { byte b = cb.get(); char c = (char) b; if (c == '\n') { processLine(toStringAndClear(line).toLowerCase()); if (nextLine) { readyToReadData = true; } nextLine = true; } else if (c != '\r') { nextLine = false; line.put(b); } } return !chunked && ((data != null) && !data.hasRemaining()); } String toStringAndClear(ByteBuffer bb) { if (bb == null) { return ""; } String result; if (bb.position() == 0) { result = ""; } else { result = StringUtil.bytesToString(bb.array(), 0, bb.position()); } bb.clear(); return result; } boolean readLine(ByteBuffer cb) { while (cb.hasRemaining()) { byte b = cb.get(); char c = (char) b; if (c == '\n') { return true; } else if (c != '\r') { line.put(b); } } return false; } private void processLine(String currentLine) { if (contentType == null && currentLine.startsWith(HEADER_CONTENT_TYPE)) { contentType = currentLine.substring(currentLine.indexOf(' ') + 1); } else if (data == null && currentLine.startsWith(HEADER_CONTENT_LENGTH)) { data = ByteBuffer.allocate(Integer.parseInt(currentLine.substring(currentLine.indexOf(' ') + 1))); } else if (!chunked && currentLine.startsWith(HEADER_CHUNKED)) { chunked = true; } else if (currentLine.startsWith(HEADER_EXPECT_100)) { socketTextRequestReader.sendResponse(new NoOpCommand(RES_100)); } } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpPostCommand.java
58
public class HttpPostCommandParser implements CommandParser { public TextCommand parser(SocketTextReader socketTextReader, String cmd, int space) { StringTokenizer st = new StringTokenizer(cmd); st.nextToken(); String uri = null; if (st.hasMoreTokens()) { uri = st.nextToken(); } else { return new ErrorCommand(ERROR_CLIENT); } return new HttpPostCommand(socketTextReader, uri); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpPostCommandParser.java
59
public class HttpPostCommandProcessor extends HttpCommandProcessor<HttpPostCommand> { private static final byte[] QUEUE_SIMPLE_VALUE_CONTENT_TYPE = stringToBytes("text/plain"); public HttpPostCommandProcessor(TextCommandService textCommandService) { super(textCommandService); } public void handle(HttpPostCommand command) { try { String uri = command.getURI(); if (uri.startsWith(URI_MAPS)) { handleMap(command, uri); } else if (uri.startsWith(URI_MANCENTER_CHANGE_URL)) { handleManagementCenterUrlChange(command); } else if (uri.startsWith(URI_QUEUES)) { handleQueue(command, uri); } else { command.setResponse(HttpCommand.RES_400); } } catch (Exception e) { command.setResponse(HttpCommand.RES_500); } textCommandService.sendResponse(command); } private void handleQueue(HttpPostCommand command, String uri) { String simpleValue = null; String suffix; if (uri.endsWith("/")) { suffix = uri.substring(URI_QUEUES.length(), uri.length() - 1); } else { suffix = uri.substring(URI_QUEUES.length(), uri.length()); } int indexSlash = suffix.lastIndexOf('/'); String queueName; if (indexSlash == -1) { queueName = suffix; } else { queueName = suffix.substring(0, indexSlash); simpleValue = suffix.substring(indexSlash + 1, suffix.length()); } byte[] data; byte[] contentType; if (simpleValue == null) { data = command.getData(); contentType = command.getContentType(); } else { data = stringToBytes(simpleValue); contentType = QUEUE_SIMPLE_VALUE_CONTENT_TYPE; } boolean offerResult = textCommandService.offer(queueName, new RestValue(data, contentType)); if (offerResult) { command.send200(); } else { command.setResponse(HttpCommand.RES_503); } } private void handleManagementCenterUrlChange(HttpPostCommand command) throws UnsupportedEncodingException { if (textCommandService.getNode().getGroupProperties().MC_URL_CHANGE_ENABLED.getBoolean()) { byte[] res = HttpCommand.RES_204; byte[] data = command.getData(); String[] strList = bytesToString(data).split("&"); String cluster = URLDecoder.decode(strList[0], "UTF-8"); String pass = URLDecoder.decode(strList[1], "UTF-8"); String url = URLDecoder.decode(strList[2], "UTF-8"); ManagementCenterService managementCenterService = textCommandService.getNode().getManagementCenterService(); if (managementCenterService != null) { res = managementCenterService.clusterWideUpdateManagementCenterUrl(cluster, pass, url); } command.setResponse(res); } else { command.setResponse(HttpCommand.RES_503); } } private void handleMap(HttpPostCommand command, String uri) { int indexEnd = uri.indexOf('/', URI_MAPS.length()); String mapName = uri.substring(URI_MAPS.length(), indexEnd); String key = uri.substring(indexEnd + 1); byte[] data = command.getData(); textCommandService.put(mapName, key, new RestValue(data, command.getContentType()), -1); command.send200(); } public void handleRejection(HttpPostCommand command) { handle(command); } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_HttpPostCommandProcessor.java
60
@edu.umd.cs.findbugs.annotations.SuppressWarnings("EI_EXPOSE_REP") public class RestValue implements DataSerializable { private byte[] value; private byte[] contentType; public RestValue() { } public RestValue(byte[] value, byte[] contentType) { this.value = value; this.contentType = contentType; } public void readData(ObjectDataInput in) throws IOException { value = IOUtil.readByteArray(in); contentType = IOUtil.readByteArray(in); } public void writeData(ObjectDataOutput out) throws IOException { IOUtil.writeByteArray(out, value); IOUtil.writeByteArray(out, contentType); } public byte[] getContentType() { return contentType; } public void setContentType(byte[] contentType) { this.contentType = contentType; } public byte[] getValue() { return value; } public void setValue(byte[] value) { this.value = value; } @Override public String toString() { String contentTypeStr; if (contentType == null) { contentTypeStr = "unknown-content-type"; } else { contentTypeStr = bytesToString(contentType); } String valueStr; if (value == null) { valueStr = "value.length=0"; } else if (contentTypeStr.contains("text")) { valueStr = "value=\"" + bytesToString(value) + "\""; } else { valueStr = "value.length=" + value.length; } return "RestValue{" + "contentType='" + contentTypeStr + "', " + valueStr + '}'; } }
false
hazelcast_src_main_java_com_hazelcast_ascii_rest_RestValue.java
61
public class AWSClient { private String endpoint; private final AwsConfig awsConfig; public AWSClient(AwsConfig awsConfig) { if (awsConfig == null) { throw new IllegalArgumentException("AwsConfig is required!"); } if (awsConfig.getAccessKey() == null) { throw new IllegalArgumentException("AWS access key is required!"); } if (awsConfig.getSecretKey() == null) { throw new IllegalArgumentException("AWS secret key is required!"); } this.awsConfig = awsConfig; endpoint = awsConfig.getHostHeader(); } public List<String> getPrivateIpAddresses() throws Exception { return new DescribeInstances(awsConfig).execute(endpoint); } public void setEndpoint(String s) { this.endpoint = s; } }
false
hazelcast-cloud_src_main_java_com_hazelcast_aws_AWSClient.java
62
public interface Constants { String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss'Z'"; String DOC_VERSION = "2011-05-15"; String SIGNATURE_METHOD = "HmacSHA256"; String SIGNATURE_VERSION = "2"; String GET = "GET"; }
false
hazelcast-cloud_src_main_java_com_hazelcast_aws_impl_Constants.java
63
public class DescribeInstances { private final EC2RequestSigner rs; private final AwsConfig awsConfig; public DescribeInstances(AwsConfig awsConfig) { if (awsConfig == null) { throw new IllegalArgumentException("AwsConfig is required!"); } if (awsConfig.getAccessKey() == null) { throw new IllegalArgumentException("AWS access key is required!"); } rs = new EC2RequestSigner(awsConfig.getSecretKey()); attributes.put("Action", this.getClass().getSimpleName()); attributes.put("Version", DOC_VERSION); attributes.put("SignatureVersion", SIGNATURE_VERSION); attributes.put("SignatureMethod", SIGNATURE_METHOD); attributes.put("AWSAccessKeyId", awsConfig.getAccessKey()); attributes.put("Timestamp", getFormattedTimestamp()); this.awsConfig = awsConfig; } /** * Formats date as ISO 8601 timestamp */ private String getFormattedTimestamp() { SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); df.setTimeZone(TimeZone.getTimeZone("UTC")); return df.format(new Date()); } private Map<String, String> attributes = new HashMap<String, String>(); public String getQueryString() { return CloudyUtility.getQueryString(attributes); } public Map<String, String> getAttributes() { return attributes; } public void putSignature(String value) { attributes.put("Signature", value); } public <T> T execute(String endpoint) throws Exception { rs.sign(this, endpoint); Object result = callService(endpoint); return (T) result; } public Object callService(String endpoint) throws Exception { String query = getQueryString(); URL url = new URL("https", endpoint, -1, "/" + query); HttpURLConnection httpConnection = (HttpURLConnection) (url.openConnection()); httpConnection.setRequestMethod(GET); httpConnection.setDoOutput(true); httpConnection.connect(); Object response = unmarshalTheResponse(httpConnection.getInputStream(), awsConfig); return response; } }
false
hazelcast-cloud_src_main_java_com_hazelcast_aws_impl_DescribeInstances.java
64
public class EC2RequestSigner { private static final String HTTP_VERB = "GET\n"; private static final String HTTP_REQUEST_URI = "/\n"; private final String secretKey; public EC2RequestSigner(String secretKey) { if (secretKey == null) { throw new IllegalArgumentException("AWS secret key is required!"); } this.secretKey = secretKey; } public void sign(DescribeInstances request, String endpoint) { String canonicalizedQueryString = getCanonicalizedQueryString(request); String stringToSign = HTTP_VERB + endpoint + "\n" + HTTP_REQUEST_URI + canonicalizedQueryString; String signature = signTheString(stringToSign); request.putSignature(signature); } private String signTheString(String stringToSign) { String signature = null; try { signature = RFC2104HMAC.calculateRFC2104HMAC(stringToSign, secretKey); } catch (SignatureException e) { throw new RuntimeException(e); } return signature; } private String getCanonicalizedQueryString(DescribeInstances request) { List<String> components = getListOfEntries(request.getAttributes()); Collections.sort(components); return getCanonicalizedQueryString(components); } private void addComponents(List<String> components, Map<String, String> attributes, String key) { components.add(AwsURLEncoder.urlEncode(key) + "=" + AwsURLEncoder.urlEncode(attributes.get(key))); } private List<String> getListOfEntries(Map<String, String> entries) { List<String> components = new ArrayList<String>(); for (String key : entries.keySet()) { addComponents(components, entries, key); } return components; } /** * @param list * @return */ private String getCanonicalizedQueryString(List<String> list) { Iterator<String> it = list.iterator(); StringBuilder result = new StringBuilder(it.next()); while (it.hasNext()) { result.append("&").append(it.next()); } return result.toString(); } }
false
hazelcast-cloud_src_main_java_com_hazelcast_aws_security_EC2RequestSigner.java
65
public class RFC2104HMAC { private RFC2104HMAC(){} public static String calculateRFC2104HMAC(String data, String key) throws SignatureException { String result; try { SecretKeySpec signingKey = new SecretKeySpec(stringToBytes(key), SIGNATURE_METHOD); Mac mac = Mac.getInstance(SIGNATURE_METHOD); mac.init(signingKey); byte[] rawSignature = mac.doFinal(stringToBytes(data)); result = bytesToString(encode(rawSignature)); result = result.trim(); } catch (Exception e) { throw new SignatureException("Failed to generate HMAC : " + e.getMessage()); } return result; } }
false
hazelcast-cloud_src_main_java_com_hazelcast_aws_security_RFC2104HMAC.java
66
public class AwsURLEncoder { private AwsURLEncoder() { } public static String urlEncode(String string) { String encoded; try { encoded = URLEncoder.encode(string, "UTF-8").replace("+", "%20"); } catch (UnsupportedEncodingException e) { throw new HazelcastException(e); } return encoded; } }
false
hazelcast-cloud_src_main_java_com_hazelcast_aws_utility_AwsURLEncoder.java
67
public class CloudyUtility { final static ILogger logger = Logger.getLogger(CloudyUtility.class); private CloudyUtility() { } public static String getQueryString(Map<String, String> attributes) { StringBuilder query = new StringBuilder(); for (Iterator<Map.Entry<String,String>> iterator = attributes.entrySet().iterator(); iterator.hasNext(); ) { final Map.Entry<String,String> entry = iterator.next(); final String value = entry.getValue(); query.append(AwsURLEncoder.urlEncode(entry.getKey())).append("=").append(AwsURLEncoder.urlEncode(value)).append("&"); } String result = query.toString(); if (result != null && !result.equals("")) result = "?" + result.substring(0, result.length() - 1); return result; } public static Object unmarshalTheResponse(InputStream stream, AwsConfig awsConfig) throws IOException { Object o = parse(stream, awsConfig); return o; } private static Object parse(InputStream in, AwsConfig awsConfig) { final DocumentBuilder builder; try { builder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); Document doc = builder.parse(in); Element element = doc.getDocumentElement(); NodeHolder elementNodeHolder = new NodeHolder(element); List<String> names = new ArrayList<String>(); List<NodeHolder> reservationset = elementNodeHolder.getSubNodes("reservationset"); for (NodeHolder reservation : reservationset) { List<NodeHolder> items = reservation.getSubNodes("item"); for (NodeHolder item : items) { NodeHolder instancesset = item.getSub("instancesset"); names.addAll(instancesset.getList("privateipaddress", awsConfig)); } } return names; } catch (Exception e) { logger.warning(e); } return new ArrayList<String>(); } static class NodeHolder { Node node; public NodeHolder(Node node) { this.node = node; } public NodeHolder getSub(String name) { if (node != null) { for (org.w3c.dom.Node node : new AbstractXmlConfigHelper.IterableNodeList(this.node.getChildNodes())) { String nodeName = cleanNodeName(node.getNodeName()); if (name.equals(nodeName)) { return new NodeHolder(node); } } } return new NodeHolder(null); } public List<NodeHolder> getSubNodes(String name) { List<NodeHolder> list = new ArrayList<NodeHolder>(); if (node != null) { for (org.w3c.dom.Node node : new AbstractXmlConfigHelper.IterableNodeList(this.node.getChildNodes())) { String nodeName = cleanNodeName(node.getNodeName()); if (name.equals(nodeName)) { list.add(new NodeHolder(node)); } } } return list; } public List<String> getList(String name, AwsConfig awsConfig) { List<String> list = new ArrayList<String>(); if (node == null) return list; for (org.w3c.dom.Node node : new AbstractXmlConfigHelper.IterableNodeList(this.node.getChildNodes())) { String nodeName = cleanNodeName(node.getNodeName()); if (!"item".equals(nodeName)) continue; final NodeHolder nodeHolder = new NodeHolder(node); final String state = getState(nodeHolder); final String ip = getIp(name, nodeHolder); final String instanceName = getInstanceName(nodeHolder); if (ip != null) { if (!acceptState(state)) { logger.finest(format("Ignoring EC2 instance [%s][%s] reason: the instance is not running but %s", instanceName, ip, state)); } else if (!acceptTag(awsConfig, node)) { logger.finest(format("Ignoring EC2 instance [%s][%s] reason: tag-key/tag-value don't match", instanceName, ip)); } else if (!acceptGroupName(awsConfig, node)) { logger.finest(format("Ignoring EC2 instance [%s][%s] reason: security-group-name doesn't match", instanceName, ip)); } else { list.add(ip); logger.finest(format("Accepting EC2 instance [%s][%s]",instanceName, ip)); } } } return list; } private boolean acceptState(String state) { return "running".equals(state); } private static String getState(NodeHolder nodeHolder) { final NodeHolder instancestate = nodeHolder.getSub("instancestate"); return instancestate.getSub("name").getNode().getFirstChild().getNodeValue(); } private static String getInstanceName(NodeHolder nodeHolder) { final NodeHolder tagSetNode = nodeHolder.getSub("tagset"); if (tagSetNode.getNode() == null) { return null; } final NodeList childNodes = tagSetNode.getNode().getChildNodes(); for (int k = 0; k < childNodes.getLength(); k++) { Node item = childNodes.item(k); if (!item.getNodeName().equals("item")) continue; NodeHolder itemHolder = new NodeHolder(item); final Node keyNode = itemHolder.getSub("key").getNode(); if (keyNode == null || keyNode.getFirstChild() == null) continue; final String nodeValue = keyNode.getFirstChild().getNodeValue(); if (!"Name".equals(nodeValue)) continue; final Node valueNode = itemHolder.getSub("value").getNode(); if (valueNode == null || valueNode.getFirstChild() == null) continue; return valueNode.getFirstChild().getNodeValue(); } return null; } private static String getIp(String name, NodeHolder nodeHolder) { final Node node1 = nodeHolder.getSub(name).getNode(); return node1 == null ? null : node1.getFirstChild().getNodeValue(); } private boolean acceptTag(AwsConfig awsConfig, Node node) { return applyTagFilter(node, awsConfig.getTagKey(), awsConfig.getTagValue()); } private boolean acceptGroupName(AwsConfig awsConfig, Node node) { return applyFilter(node, awsConfig.getSecurityGroupName(), "groupset", "groupname"); } private boolean applyFilter(Node node, String filter, String set, String filterField) { if (nullOrEmpty(filter)) { return true; } else { for (NodeHolder group : new NodeHolder(node).getSub(set).getSubNodes("item")) { NodeHolder nh = group.getSub(filterField); if (nh != null && nh.getNode().getFirstChild() != null && filter.equals(nh.getNode().getFirstChild().getNodeValue())) { return true; } } return false; } } private boolean applyTagFilter(Node node, String keyExpected, String valueExpected) { if (nullOrEmpty(keyExpected)) { return true; } else { for (NodeHolder group : new NodeHolder(node).getSub("tagset").getSubNodes("item")) { if (keyEquals(keyExpected, group) && (nullOrEmpty(valueExpected) || valueEquals(valueExpected, group))) { return true; } } return false; } } private boolean valueEquals(String valueExpected, NodeHolder group) { NodeHolder nhValue = group.getSub("value"); return nhValue != null && nhValue.getNode().getFirstChild() != null && valueExpected.equals(nhValue.getNode().getFirstChild().getNodeValue()); } private boolean nullOrEmpty(String keyExpected) { return keyExpected == null || keyExpected.equals(""); } private boolean keyEquals(String keyExpected, NodeHolder group) { NodeHolder nhKey = group.getSub("key"); return nhKey != null && nhKey.getNode().getFirstChild() != null && keyExpected.equals(nhKey.getNode().getFirstChild().getNodeValue()); } public Node getNode() { return node; } } }
true
hazelcast-cloud_src_main_java_com_hazelcast_aws_utility_CloudyUtility.java
68
static class NodeHolder { Node node; public NodeHolder(Node node) { this.node = node; } public NodeHolder getSub(String name) { if (node != null) { for (org.w3c.dom.Node node : new AbstractXmlConfigHelper.IterableNodeList(this.node.getChildNodes())) { String nodeName = cleanNodeName(node.getNodeName()); if (name.equals(nodeName)) { return new NodeHolder(node); } } } return new NodeHolder(null); } public List<NodeHolder> getSubNodes(String name) { List<NodeHolder> list = new ArrayList<NodeHolder>(); if (node != null) { for (org.w3c.dom.Node node : new AbstractXmlConfigHelper.IterableNodeList(this.node.getChildNodes())) { String nodeName = cleanNodeName(node.getNodeName()); if (name.equals(nodeName)) { list.add(new NodeHolder(node)); } } } return list; } public List<String> getList(String name, AwsConfig awsConfig) { List<String> list = new ArrayList<String>(); if (node == null) return list; for (org.w3c.dom.Node node : new AbstractXmlConfigHelper.IterableNodeList(this.node.getChildNodes())) { String nodeName = cleanNodeName(node.getNodeName()); if (!"item".equals(nodeName)) continue; final NodeHolder nodeHolder = new NodeHolder(node); final String state = getState(nodeHolder); final String ip = getIp(name, nodeHolder); final String instanceName = getInstanceName(nodeHolder); if (ip != null) { if (!acceptState(state)) { logger.finest(format("Ignoring EC2 instance [%s][%s] reason: the instance is not running but %s", instanceName, ip, state)); } else if (!acceptTag(awsConfig, node)) { logger.finest(format("Ignoring EC2 instance [%s][%s] reason: tag-key/tag-value don't match", instanceName, ip)); } else if (!acceptGroupName(awsConfig, node)) { logger.finest(format("Ignoring EC2 instance [%s][%s] reason: security-group-name doesn't match", instanceName, ip)); } else { list.add(ip); logger.finest(format("Accepting EC2 instance [%s][%s]",instanceName, ip)); } } } return list; } private boolean acceptState(String state) { return "running".equals(state); } private static String getState(NodeHolder nodeHolder) { final NodeHolder instancestate = nodeHolder.getSub("instancestate"); return instancestate.getSub("name").getNode().getFirstChild().getNodeValue(); } private static String getInstanceName(NodeHolder nodeHolder) { final NodeHolder tagSetNode = nodeHolder.getSub("tagset"); if (tagSetNode.getNode() == null) { return null; } final NodeList childNodes = tagSetNode.getNode().getChildNodes(); for (int k = 0; k < childNodes.getLength(); k++) { Node item = childNodes.item(k); if (!item.getNodeName().equals("item")) continue; NodeHolder itemHolder = new NodeHolder(item); final Node keyNode = itemHolder.getSub("key").getNode(); if (keyNode == null || keyNode.getFirstChild() == null) continue; final String nodeValue = keyNode.getFirstChild().getNodeValue(); if (!"Name".equals(nodeValue)) continue; final Node valueNode = itemHolder.getSub("value").getNode(); if (valueNode == null || valueNode.getFirstChild() == null) continue; return valueNode.getFirstChild().getNodeValue(); } return null; } private static String getIp(String name, NodeHolder nodeHolder) { final Node node1 = nodeHolder.getSub(name).getNode(); return node1 == null ? null : node1.getFirstChild().getNodeValue(); } private boolean acceptTag(AwsConfig awsConfig, Node node) { return applyTagFilter(node, awsConfig.getTagKey(), awsConfig.getTagValue()); } private boolean acceptGroupName(AwsConfig awsConfig, Node node) { return applyFilter(node, awsConfig.getSecurityGroupName(), "groupset", "groupname"); } private boolean applyFilter(Node node, String filter, String set, String filterField) { if (nullOrEmpty(filter)) { return true; } else { for (NodeHolder group : new NodeHolder(node).getSub(set).getSubNodes("item")) { NodeHolder nh = group.getSub(filterField); if (nh != null && nh.getNode().getFirstChild() != null && filter.equals(nh.getNode().getFirstChild().getNodeValue())) { return true; } } return false; } } private boolean applyTagFilter(Node node, String keyExpected, String valueExpected) { if (nullOrEmpty(keyExpected)) { return true; } else { for (NodeHolder group : new NodeHolder(node).getSub("tagset").getSubNodes("item")) { if (keyEquals(keyExpected, group) && (nullOrEmpty(valueExpected) || valueEquals(valueExpected, group))) { return true; } } return false; } } private boolean valueEquals(String valueExpected, NodeHolder group) { NodeHolder nhValue = group.getSub("value"); return nhValue != null && nhValue.getNode().getFirstChild() != null && valueExpected.equals(nhValue.getNode().getFirstChild().getNodeValue()); } private boolean nullOrEmpty(String keyExpected) { return keyExpected == null || keyExpected.equals(""); } private boolean keyEquals(String keyExpected, NodeHolder group) { NodeHolder nhKey = group.getSub("key"); return nhKey != null && nhKey.getNode().getFirstChild() != null && keyExpected.equals(nhKey.getNode().getFirstChild().getNodeValue()); } public Node getNode() { return node; } }
true
hazelcast-cloud_src_main_java_com_hazelcast_aws_utility_CloudyUtility.java
69
@RunWith(HazelcastSerialClassRunner.class) @Category(QuickTest.class) public class CloudyUtilityTest { String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n" + "<DescribeInstancesResponse xmlns=\"http://ec2.amazonaws.com/doc/2011-05-15/\">\n" + " <requestId>c0f82bf8-b7f5-4cf1-bbfa-b95ea4bd38da</requestId>\n" + " <reservationSet>\n" + " <item>\n" + " <reservationId>r-48ff3826</reservationId>\n" + " <ownerId>665466731577</ownerId>\n" + " <groupSet>\n" + " <item>\n" + " <groupId>sg-b67baddf</groupId>\n" + " <groupName>hazelcast</groupName>\n" + " </item>\n" + " </groupSet>\n" + " <instancesSet>\n" + " <item>\n" + " <instanceId>i-0a0c616a</instanceId>\n" + " <imageId>ami-7f418316</imageId>\n" + " <instanceState>\n" + " <code>16</code>\n" + " <name>running</name>\n" + " </instanceState>\n" + " <privateDnsName>domU-12-31-39-07-C5-C4.compute-1.internal</privateDnsName>\n" + " <dnsName>ec2-50-17-19-37.compute-1.amazonaws.com</dnsName>\n" + " <reason/>\n" + " <keyName>hazelcast_key_pair</keyName>\n" + " <amiLaunchIndex>0</amiLaunchIndex>\n" + " <productCodes/>\n" + " <instanceType>t1.micro</instanceType>\n" + " <launchTime>2011-09-27T11:37:35.000Z</launchTime>\n" + " <placement>\n" + " <availabilityZone>us-east-1a</availabilityZone>\n" + " <groupName/>\n" + " <tenancy>default</tenancy>\n" + " </placement>\n" + " <kernelId>aki-805ea7e9</kernelId>\n" + " <monitoring>\n" + " <state>disabled</state>\n" + " </monitoring>\n" + " <privateIpAddress>10.209.198.50</privateIpAddress>\n" + " <ipAddress>50.17.19.37</ipAddress>\n" + " <groupSet>\n" + " <item>\n" + " <groupId>sg-b67baddf</groupId>\n" + " <groupName>hazelcast</groupName>\n" + " </item>\n" + " </groupSet>\n" + " <architecture>i386</architecture>\n" + " <rootDeviceType>ebs</rootDeviceType>\n" + " <rootDeviceName>/dev/sda1</rootDeviceName>\n" + " <blockDeviceMapping>\n" + " <item>\n" + " <deviceName>/dev/sda1</deviceName>\n" + " <ebs>\n" + " <volumeId>vol-d5bdffbf</volumeId>\n" + " <status>attached</status>\n" + " <attachTime>2011-09-27T11:37:56.000Z</attachTime>\n" + " <deleteOnTermination>true</deleteOnTermination>\n" + " </ebs>\n" + " </item>\n" + " </blockDeviceMapping>\n" + " <virtualizationType>paravirtual</virtualizationType>\n" + " <clientToken/>\n" + " <tagSet>\n" + " <item>\n" + " <key>name2</key>\n" + " <value>value2</value>\n" + " </item>\n" + " <item>\n" + " <key>Name1</key>\n" + " <value>value1</value>\n" + " </item>\n" + " <item>\n" + " <key>name</key>\n" + " <value/>\n" + " </item>\n" + " </tagSet>\n" + " <hypervisor>xen</hypervisor>\n" + " </item>\n" + " <item>\n" + " <instanceId>i-0c0c616c</instanceId>\n" + " <imageId>ami-7f418316</imageId>\n" + " <instanceState>\n" + " <code>16</code>\n" + " <name>running</name>\n" + " </instanceState>\n" + " <privateDnsName>domU-12-31-39-07-C2-60.compute-1.internal</privateDnsName>\n" + " <dnsName>ec2-50-16-102-143.compute-1.amazonaws.com</dnsName>\n" + " <reason/>\n" + " <keyName>hazelcast_key_pair</keyName>\n" + " <amiLaunchIndex>1</amiLaunchIndex>\n" + " <productCodes/>\n" + " <instanceType>t1.micro</instanceType>\n" + " <launchTime>2011-09-27T11:37:35.000Z</launchTime>\n" + " <placement>\n" + " <availabilityZone>us-east-1a</availabilityZone>\n" + " <groupName/>\n" + " <tenancy>default</tenancy>\n" + " </placement>\n" + " <kernelId>aki-805ea7e9</kernelId>\n" + " <monitoring>\n" + " <state>disabled</state>\n" + " </monitoring>\n" + " <privateIpAddress>10.209.193.170</privateIpAddress>\n" + " <ipAddress>50.16.102.143</ipAddress>\n" + " <groupSet>\n" + " <item>\n" + " <groupId>sg-b67baddf</groupId>\n" + " <groupName>hazelcast</groupName>\n" + " </item>\n" + " </groupSet>\n" + " <architecture>i386</architecture>\n" + " <rootDeviceType>ebs</rootDeviceType>\n" + " <rootDeviceName>/dev/sda1</rootDeviceName>\n" + " <blockDeviceMapping>\n" + " <item>\n" + " <deviceName>/dev/sda1</deviceName>\n" + " <ebs>\n" + " <volumeId>vol-abbdffc1</volumeId>\n" + " <status>attached</status>\n" + " <attachTime>2011-09-27T11:37:57.000Z</attachTime>\n" + " <deleteOnTermination>true</deleteOnTermination>\n" + " </ebs>\n" + " </item>\n" + " </blockDeviceMapping>\n" + " <virtualizationType>paravirtual</virtualizationType>\n" + " <clientToken/>\n" + " <tagSet>\n" + " <item>\n" + " <key>Name1</key>\n" + " <value>value1</value>\n" + " </item>\n" + " <item>\n" + " <key>name2</key>\n" + " <value>value2</value>\n" + " </item>\n" + " </tagSet>\n" + " <hypervisor>xen</hypervisor>\n" + " </item>\n" + " </instancesSet>\n" + " <requesterId>058890971305</requesterId>\n" + " </item>\n" + " </reservationSet>\n" + "</DescribeInstancesResponse>"; @Test public void testNoTags() throws IOException { InputStream is = new ByteArrayInputStream(xml.getBytes()); AwsConfig awsConfig = new AwsConfig(); awsConfig.setAccessKey("some-access-key"); awsConfig.setSecretKey("some-secret-key"); awsConfig.setSecurityGroupName("hazelcast"); List<String> result = (List<String>) CloudyUtility.unmarshalTheResponse(is, awsConfig); assertEquals(2, result.size()); } @Test public void testTagsBothNodeHave() throws IOException { InputStream is = new ByteArrayInputStream(xml.getBytes()); AwsConfig awsConfig = new AwsConfig(); awsConfig.setAccessKey("some-access-key"); awsConfig.setSecretKey("some-secret-key"); awsConfig.setSecurityGroupName("hazelcast"); awsConfig.setTagKey("Name1"); awsConfig.setTagValue("value1"); List<String> result = (List<String>) CloudyUtility.unmarshalTheResponse(is, awsConfig); assertEquals(2, result.size()); } @Test public void testTagOnlyOneNodeHave() throws IOException { InputStream is = new ByteArrayInputStream(xml.getBytes()); AwsConfig awsConfig = new AwsConfig(); awsConfig.setAccessKey("some-access-key"); awsConfig.setSecretKey("some-secret-key"); awsConfig.setSecurityGroupName("hazelcast"); awsConfig.setTagKey("name"); awsConfig.setTagValue(""); List<String> result = (List<String>) CloudyUtility.unmarshalTheResponse(is, awsConfig); assertEquals(1, result.size()); } }
false
hazelcast-cloud_src_test_java_com_hazelcast_aws_utility_CloudyUtilityTest.java
70
public abstract class AllPartitionsClientRequest extends ClientRequest { @Override final void process() throws Exception { ClientEndpoint endpoint = getEndpoint(); OperationFactory operationFactory = new OperationFactoryWrapper(createOperationFactory(), endpoint.getUuid()); Map<Integer, Object> map = clientEngine.invokeOnAllPartitions(getServiceName(), operationFactory); Object result = reduce(map); endpoint.sendResponse(result, getCallId()); } protected abstract OperationFactory createOperationFactory(); protected abstract Object reduce(Map<Integer, Object> map); }
false
hazelcast_src_main_java_com_hazelcast_client_AllPartitionsClientRequest.java
71
public class AuthenticationException extends HazelcastException { public AuthenticationException() { super("Wrong group name and password."); } public AuthenticationException(String message) { super(message); } }
false
hazelcast_src_main_java_com_hazelcast_client_AuthenticationException.java
72
public final class AuthenticationRequest extends CallableClientRequest { private Credentials credentials; private ClientPrincipal principal; private boolean reAuth; private boolean firstConnection; public AuthenticationRequest() { } public AuthenticationRequest(Credentials credentials) { this.credentials = credentials; } public AuthenticationRequest(Credentials credentials, ClientPrincipal principal) { this.credentials = credentials; this.principal = principal; } public Object call() throws Exception { boolean authenticated = authenticate(); if (authenticated) { return handleAuthenticated(); } else { return handleUnauthenticated(); } } private boolean authenticate() { ClientEngineImpl clientEngine = getService(); Connection connection = endpoint.getConnection(); ILogger logger = clientEngine.getLogger(getClass()); boolean authenticated; if (credentials == null) { authenticated = false; logger.severe("Could not retrieve Credentials object!"); } else if (clientEngine.getSecurityContext() != null) { authenticated = authenticate(clientEngine.getSecurityContext()); } else if (credentials instanceof UsernamePasswordCredentials) { UsernamePasswordCredentials usernamePasswordCredentials = (UsernamePasswordCredentials) credentials; authenticated = authenticate(usernamePasswordCredentials); } else { authenticated = false; logger.severe("Hazelcast security is disabled.\nUsernamePasswordCredentials or cluster " + "group-name and group-password should be used for authentication!\n" + "Current credentials type is: " + credentials.getClass().getName()); } logger.log((authenticated ? Level.INFO : Level.WARNING), "Received auth from " + connection + ", " + (authenticated ? "successfully authenticated" : "authentication failed")); return authenticated; } private boolean authenticate(UsernamePasswordCredentials credentials) { ClientEngineImpl clientEngine = getService(); GroupConfig groupConfig = clientEngine.getConfig().getGroupConfig(); String nodeGroupName = groupConfig.getName(); String nodeGroupPassword = groupConfig.getPassword(); boolean usernameMatch = nodeGroupName.equals(credentials.getUsername()); boolean passwordMatch = nodeGroupPassword.equals(credentials.getPassword()); return usernameMatch && passwordMatch; } private boolean authenticate(SecurityContext securityContext) { Connection connection = endpoint.getConnection(); credentials.setEndpoint(connection.getInetAddress().getHostAddress()); try { LoginContext lc = securityContext.createClientLoginContext(credentials); lc.login(); endpoint.setLoginContext(lc); return true; } catch (LoginException e) { ILogger logger = clientEngine.getLogger(getClass()); logger.warning(e); return false; } } private Object handleUnauthenticated() { ClientEngineImpl clientEngine = getService(); clientEngine.removeEndpoint(endpoint.getConnection()); return new AuthenticationException("Invalid credentials!"); } private Object handleAuthenticated() { ClientEngineImpl clientEngine = getService(); if (principal != null && reAuth) { principal = new ClientPrincipal(principal.getUuid(), clientEngine.getLocalMember().getUuid()); reAuthLocal(); Collection<MemberImpl> members = clientEngine.getClusterService().getMemberList(); for (MemberImpl member : members) { if (!member.localMember()) { ClientReAuthOperation op = new ClientReAuthOperation(principal.getUuid(), firstConnection); clientEngine.sendOperation(op, member.getAddress()); } } } if (principal == null) { principal = new ClientPrincipal(endpoint.getUuid(), clientEngine.getLocalMember().getUuid()); } endpoint.authenticated(principal, firstConnection); clientEngine.bind(endpoint); return new SerializableCollection(clientEngine.toData(clientEngine.getThisAddress()), clientEngine.toData(principal)); } private void reAuthLocal() { final Set<ClientEndpoint> endpoints = clientEngine.getEndpoints(principal.getUuid()); for (ClientEndpoint endpoint : endpoints) { endpoint.authenticated(principal, firstConnection); } } public String getServiceName() { return ClientEngineImpl.SERVICE_NAME; } @Override public int getFactoryId() { return ClientPortableHook.ID; } @Override public int getClassId() { return ClientPortableHook.AUTH; } public void setReAuth(boolean reAuth) { this.reAuth = reAuth; } public boolean isFirstConnection() { return firstConnection; } public void setFirstConnection(boolean firstConnection) { this.firstConnection = firstConnection; } @Override public void write(PortableWriter writer) throws IOException { writer.writePortable("credentials", (Portable) credentials); if (principal != null) { writer.writePortable("principal", principal); } else { writer.writeNullPortable("principal", ClientPortableHook.ID, ClientPortableHook.PRINCIPAL); } writer.writeBoolean("reAuth", reAuth); writer.writeBoolean("firstConnection", firstConnection); } @Override public void read(PortableReader reader) throws IOException { credentials = (Credentials) reader.readPortable("credentials"); principal = reader.readPortable("principal"); reAuth = reader.readBoolean("reAuth"); firstConnection = reader.readBoolean("firstConnection"); } @Override public Permission getRequiredPermission() { return null; } }
true
hazelcast_src_main_java_com_hazelcast_client_AuthenticationRequest.java
73
public abstract class BaseClientRemoveListenerRequest extends CallableClientRequest { protected String name; protected String registrationId; protected BaseClientRemoveListenerRequest() { } protected BaseClientRemoveListenerRequest(String name, String registrationId) { this.name = name; this.registrationId = registrationId; } public String getRegistrationId() { return registrationId; } public void setRegistrationId(String registrationId) { this.registrationId = registrationId; } public String getName() { return name; } public void setName(final String name) { this.name = name; } @Override public void write(PortableWriter writer) throws IOException { writer.writeUTF("n", name); writer.writeUTF("r", registrationId); } @Override public void read(PortableReader reader) throws IOException { name = reader.readUTF("n"); registrationId = reader.readUTF("r"); } }
false
hazelcast_src_main_java_com_hazelcast_client_BaseClientRemoveListenerRequest.java
74
public abstract class CallableClientRequest extends ClientRequest implements Callable { @Override final void process() throws Exception { ClientEndpoint endpoint = getEndpoint(); try { Object result = call(); endpoint.sendResponse(result, getCallId()); } catch (Exception e) { clientEngine.getLogger(getClass()).warning(e); endpoint.sendResponse(e, getCallId()); } } }
false
hazelcast_src_main_java_com_hazelcast_client_CallableClientRequest.java
75
@Ignore//TODO @RunWith(Categories.class) @Categories.IncludeCategory(ClientCompatibleTest.class) @Suite.SuiteClasses({}) public class ClientCompatibleTestsSuit { @BeforeClass public static void setUp() { System.setProperty(TestEnvironment.HAZELCAST_TEST_USE_NETWORK, "true"); System.setProperty(TestEnvironment.HAZELCAST_TEST_USE_CLIENT, "true"); System.setProperty("hazelcast.version.check.enabled", "false"); System.setProperty("hazelcast.mancenter.enabled", "false"); System.setProperty("hazelcast.wait.seconds.before.join", "1"); System.setProperty("hazelcast.local.localAddress", "127.0.0.1"); System.setProperty("java.net.preferIPv4Stack", "true"); } }
false
hazelcast-client_src_test_java_com_hazelcast_client_ClientCompatibleTestsSuit.java
76
public class ClientCreateRequest extends CallableClientRequest implements Portable, RetryableRequest, SecureRequest { private String name; private String serviceName; public ClientCreateRequest() { } public ClientCreateRequest(String name, String serviceName) { this.name = name; this.serviceName = serviceName; } @Override public Object call() throws Exception { ProxyService proxyService = clientEngine.getProxyService(); proxyService.initializeDistributedObject(serviceName, name); return null; } @Override public String getServiceName() { return serviceName; } @Override public int getFactoryId() { return ClientPortableHook.ID; } @Override public int getClassId() { return ClientPortableHook.CREATE_PROXY; } @Override public void write(PortableWriter writer) throws IOException { writer.writeUTF("n", name); writer.writeUTF("s", serviceName); } @Override public void read(PortableReader reader) throws IOException { name = reader.readUTF("n"); serviceName = reader.readUTF("s"); } @Override public Permission getRequiredPermission() { return ActionConstants.getPermission(name, serviceName, ActionConstants.ACTION_CREATE); } }
false
hazelcast_src_main_java_com_hazelcast_client_ClientCreateRequest.java
77
public final class ClientDataSerializerHook implements DataSerializerHook { public static final int ID = FactoryIdHelper.getFactoryId(FactoryIdHelper.CLIENT_DS_FACTORY, -3); public static final int CLIENT_RESPONSE = 1; @Override public int getFactoryId() { return ID; } @Override public DataSerializableFactory createFactory() { return new DataSerializableFactory() { @Override public IdentifiedDataSerializable create(int typeId) { switch (typeId) { case CLIENT_RESPONSE: return new ClientResponse(); default: return null; } } }; } }
false
hazelcast_src_main_java_com_hazelcast_client_ClientDataSerializerHook.java
78
return new DataSerializableFactory() { @Override public IdentifiedDataSerializable create(int typeId) { switch (typeId) { case CLIENT_RESPONSE: return new ClientResponse(); default: return null; } } };
false
hazelcast_src_main_java_com_hazelcast_client_ClientDataSerializerHook.java
79
public class ClientDestroyRequest extends CallableClientRequest implements Portable, RetryableRequest, SecureRequest { private String name; private String serviceName; public ClientDestroyRequest() { } public ClientDestroyRequest(String name, String serviceName) { this.name = name; this.serviceName = serviceName; } @Override public Object call() throws Exception { ProxyService proxyService = getClientEngine().getProxyService(); proxyService.destroyDistributedObject(getServiceName(), name); return null; } @Override public String getServiceName() { return serviceName; } @Override public int getFactoryId() { return ClientPortableHook.ID; } @Override public int getClassId() { return ClientPortableHook.DESTROY_PROXY; } @Override public void write(PortableWriter writer) throws IOException { writer.writeUTF("n", name); writer.writeUTF("s", serviceName); } @Override public void read(PortableReader reader) throws IOException { name = reader.readUTF("n"); serviceName = reader.readUTF("s"); } @Override public Permission getRequiredPermission() { return getPermission(name, serviceName, ActionConstants.ACTION_DESTROY); } }
false
hazelcast_src_main_java_com_hazelcast_client_ClientDestroyRequest.java
80
public class ClientDisconnectionOperation extends AbstractOperation implements UrgentSystemOperation { private String clientUuid; public ClientDisconnectionOperation() { } public ClientDisconnectionOperation(String clientUuid) { this.clientUuid = clientUuid; } @Override public void run() throws Exception { ClientEngineImpl engine = getService(); Set<ClientEndpoint> endpoints = engine.getEndpoints(clientUuid); for (ClientEndpoint endpoint : endpoints) { Connection connection = endpoint.getConnection(); engine.removeEndpoint(connection, true); } NodeEngineImpl nodeEngine = (NodeEngineImpl) getNodeEngine(); nodeEngine.onClientDisconnected(clientUuid); Collection<ClientAwareService> services = nodeEngine.getServices(ClientAwareService.class); for (ClientAwareService service : services) { service.clientDisconnected(clientUuid); } } @Override public boolean returnsResponse() { return false; } @Override protected void writeInternal(ObjectDataOutput out) throws IOException { super.writeInternal(out); out.writeUTF(clientUuid); } @Override protected void readInternal(ObjectDataInput in) throws IOException { super.readInternal(in); clientUuid = in.readUTF(); } }
true
hazelcast_src_main_java_com_hazelcast_client_ClientDisconnectionOperation.java
81
public final class ClientEndpoint implements Client { private final ClientEngineImpl clientEngine; private final Connection conn; private final ConcurrentMap<String, TransactionContext> transactionContextMap = new ConcurrentHashMap<String, TransactionContext>(); private final List<Runnable> removeListenerActions = Collections.synchronizedList(new LinkedList<Runnable>()); private final SocketAddress socketAddress; private String uuid; private LoginContext loginContext; private ClientPrincipal principal; private boolean firstConnection; private volatile boolean authenticated; ClientEndpoint(ClientEngineImpl clientEngine, Connection conn, String uuid) { this.clientEngine = clientEngine; this.conn = conn; if (conn instanceof TcpIpConnection) { TcpIpConnection tcpIpConnection = (TcpIpConnection) conn; socketAddress = tcpIpConnection.getSocketChannelWrapper().socket().getRemoteSocketAddress(); } else { socketAddress = null; } this.uuid = uuid; } Connection getConnection() { return conn; } @Override public String getUuid() { return uuid; } public boolean live() { return conn.live(); } void setLoginContext(LoginContext loginContext) { this.loginContext = loginContext; } public Subject getSubject() { return loginContext != null ? loginContext.getSubject() : null; } public boolean isFirstConnection() { return firstConnection; } void authenticated(ClientPrincipal principal, boolean firstConnection) { this.principal = principal; this.uuid = principal.getUuid(); this.firstConnection = firstConnection; this.authenticated = true; } public boolean isAuthenticated() { return authenticated; } public ClientPrincipal getPrincipal() { return principal; } @Override public InetSocketAddress getSocketAddress() { return (InetSocketAddress) socketAddress; } @Override public ClientType getClientType() { switch (conn.getType()) { case JAVA_CLIENT: return ClientType.JAVA; case CSHARP_CLIENT: return ClientType.CSHARP; case CPP_CLIENT: return ClientType.CPP; case PYTHON_CLIENT: return ClientType.PYTHON; case RUBY_CLIENT: return ClientType.RUBY; case BINARY_CLIENT: return ClientType.OTHER; default: throw new IllegalArgumentException("Invalid connection type: " + conn.getType()); } } public TransactionContext getTransactionContext(String txnId) { final TransactionContext transactionContext = transactionContextMap.get(txnId); if (transactionContext == null) { throw new TransactionException("No transaction context found for txnId:" + txnId); } return transactionContext; } public void setTransactionContext(TransactionContext transactionContext) { transactionContextMap.put(transactionContext.getTxnId(), transactionContext); } public void removeTransactionContext(String txnId) { transactionContextMap.remove(txnId); } public void setListenerRegistration(final String service, final String topic, final String id) { removeListenerActions.add(new Runnable() { @Override public void run() { EventService eventService = clientEngine.getEventService(); eventService.deregisterListener(service, topic, id); } }); } public void setDistributedObjectListener(final String id) { removeListenerActions.add(new Runnable() { @Override public void run() { clientEngine.getProxyService().removeProxyListener(id); } }); } public void clearAllListeners() { for (Runnable removeAction : removeListenerActions) { try { removeAction.run(); } catch (Exception e) { getLogger().warning("Exception during destroy action", e); } } removeListenerActions.clear(); } void destroy() throws LoginException { for (Runnable removeAction : removeListenerActions) { try { removeAction.run(); } catch (Exception e) { getLogger().warning("Exception during destroy action", e); } } LoginContext lc = loginContext; if (lc != null) { lc.logout(); } for (TransactionContext context : transactionContextMap.values()) { Transaction transaction = TransactionAccessor.getTransaction(context); if (context.isXAManaged() && transaction.getState() == PREPARED) { TransactionManagerServiceImpl transactionManager = (TransactionManagerServiceImpl) clientEngine.getTransactionManagerService(); transactionManager.addTxBackupLogForClientRecovery(transaction); } else { try { context.rollbackTransaction(); } catch (HazelcastInstanceNotActiveException e) { getLogger().finest(e); } catch (Exception e) { getLogger().warning(e); } } } authenticated = false; } private ILogger getLogger() { return clientEngine.getLogger(getClass()); } public void sendResponse(Object response, int callId) { boolean isError = false; Object clientResponseObject; if (response == null) { clientResponseObject = ClientEngineImpl.NULL; } else if (response instanceof Throwable) { isError = true; ClientExceptionConverter converter = ClientExceptionConverters.get(getClientType()); clientResponseObject = converter.convert((Throwable) response); } else { clientResponseObject = response; } ClientResponse clientResponse = new ClientResponse(clientEngine.toData(clientResponseObject), isError, callId); clientEngine.sendResponse(this, clientResponse); } public void sendEvent(Object event, int callId) { Data data = clientEngine.toData(event); clientEngine.sendResponse(this, new ClientResponse(data, callId, true)); } @Override public String toString() { StringBuilder sb = new StringBuilder("ClientEndpoint{"); sb.append("conn=").append(conn); sb.append(", uuid='").append(uuid).append('\''); sb.append(", firstConnection=").append(firstConnection); sb.append(", authenticated=").append(authenticated); sb.append('}'); return sb.toString(); } }
true
hazelcast_src_main_java_com_hazelcast_client_ClientEndpoint.java
82
removeListenerActions.add(new Runnable() { @Override public void run() { EventService eventService = clientEngine.getEventService(); eventService.deregisterListener(service, topic, id); } });
false
hazelcast_src_main_java_com_hazelcast_client_ClientEndpoint.java
83
removeListenerActions.add(new Runnable() { @Override public void run() { clientEngine.getProxyService().removeProxyListener(id); } });
false
hazelcast_src_main_java_com_hazelcast_client_ClientEndpoint.java
84
public interface ClientEngine { int getClientEndpointCount(); InternalPartitionService getPartitionService(); ClusterService getClusterService(); SerializationService getSerializationService(); EventService getEventService(); TransactionManagerService getTransactionManagerService(); ProxyService getProxyService(); Config getConfig(); ILogger getLogger(Class clazz); ILogger getLogger(String className); Object toObject(Data data); Data toData(Object obj); Address getMasterAddress(); Address getThisAddress(); MemberImpl getLocalMember(); SecurityContext getSecurityContext(); }
false
hazelcast_src_main_java_com_hazelcast_client_ClientEngine.java

Dataset Card for "hazelcast_3_3_EA"

More Information needed

Downloads last month
4
Edit dataset card