Ejemplo n.º 1
0
 public void testSetLoggingLevelVerbosity() throws Exception {
   if (memcachedClient.getProtocol() == Protocol.Text
       || memcachedClient.getProtocol() == Protocol.Binary) {
     memcachedClient.setLoggingLevelVerbosity(
         AddrUtil.getAddresses(properties.getProperty("test.memcached.servers")).get(0), 2);
     memcachedClient.setLoggingLevelVerbosityWithNoReply(
         AddrUtil.getAddresses(properties.getProperty("test.memcached.servers")).get(0), 3);
     memcachedClient.setLoggingLevelVerbosityWithNoReply(
         AddrUtil.getAddresses(properties.getProperty("test.memcached.servers")).get(0), 0);
   } else {
     // do nothing,binary protocol doesn't have verbosity protocol.
   }
 }
Ejemplo n.º 2
0
  public static void main(String[] args) throws IOException {
    MemcachedClientBuilder builder =
        new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:11211"));
    MemcachedClient memcachedClient = builder.build();
    try {
      memcachedClient.set("hello", 0, "Hello,xmemcached");
      String value = memcachedClient.get("hello");
      System.out.println("hello=" + value);
      memcachedClient.delete("hello");
      value = memcachedClient.get("hello");
      System.out.println("hello=" + value);
    } catch (MemcachedException e) {
      System.err.println("MemcachedClient operation fail");
      e.printStackTrace();
    } catch (TimeoutException e) {
      System.err.println("MemcachedClient operation timeout");
      e.printStackTrace();
    } catch (InterruptedException e) {
      // ignore
    }

    try {
      // close memcached client
      memcachedClient.shutdown();
    } catch (IOException e) {
      System.err.println("Shutdown MemcachedClient fail");
      e.printStackTrace();
    }
  }
Ejemplo n.º 3
0
  public void testWeightedServers() throws Exception {
    // shutdown current client
    memcachedClient.shutdown();

    MemcachedClientBuilder builder = createWeightedBuilder();
    builder.getConfiguration().setStatisticsServer(true);
    memcachedClient = builder.build();
    memcachedClient.flushAll(5000);

    Map<InetSocketAddress, Map<String, String>> oldStats = memcachedClient.getStats();

    for (int i = 0; i < 100; i++) {
      assertTrue(memcachedClient.set(String.valueOf(i), 0, i));
    }
    for (int i = 0; i < 100; i++) {
      assertEquals(i, memcachedClient.get(String.valueOf(i)));
    }

    List<InetSocketAddress> addressList =
        AddrUtil.getAddresses(properties.getProperty("test.memcached.servers"));
    Map<InetSocketAddress, Map<String, String>> newStats = memcachedClient.getStats();
    for (InetSocketAddress address : addressList) {
      int oldSets = Integer.parseInt(oldStats.get(address).get("cmd_set"));
      int newSets = Integer.parseInt(newStats.get(address).get("cmd_set"));
      System.out.println("sets:" + (newSets - oldSets));
      int oldGets = Integer.parseInt(oldStats.get(address).get("cmd_get"));
      int newGets = Integer.parseInt(newStats.get(address).get("cmd_get"));
      System.out.println("gets:" + (newGets - oldGets));
    }
  }
Ejemplo n.º 4
0
  public void testRemoveAndAddServer() throws Exception {
    String servers = properties.getProperty("test.memcached.servers");
    memcachedClient.set("name", 0, "dennis");
    assertEquals("dennis", memcachedClient.get("name"));
    memcachedClient.removeServer(servers);

    synchronized (this) {
      while (memcachedClient.getAvaliableServers().size() > 0) {
        wait(1000);
      }
    }
    assertEquals(0, memcachedClient.getAvaliableServers().size());
    try {
      memcachedClient.get("name");
      fail();
    } catch (MemcachedException e) {
      assertEquals("There is no available connection at this moment", e.getMessage());
    }

    memcachedClient.addServer(properties.getProperty("test.memcached.servers"));
    synchronized (this) {
      while (memcachedClient.getAvaliableServers().size() < AddrUtil.getAddresses(servers).size()) {
        wait(1000);
      }
    }
    Thread.sleep(5000);
    assertEquals("dennis", memcachedClient.get("name"));
  }
 @Override
 public MemcachedClientBuilder createBuilder() throws Exception {
   MemcachedClientBuilder builder =
       new XMemcachedClientBuilder(
           AddrUtil.getAddresses(this.properties.getProperty("test.memcached.servers")));
   // builder.setConnectionPoolSize(Runtime.getRuntime().availableProcessors());
   return builder;
 }
Ejemplo n.º 6
0
  public void testGetAvaliableServers() {
    Collection<InetSocketAddress> servers = memcachedClient.getAvaliableServers();

    List<InetSocketAddress> serverList =
        AddrUtil.getAddresses(properties.getProperty("test.memcached.servers"));
    assertEquals(servers.size(), serverList.size());
    for (InetSocketAddress address : servers) {
      assertTrue(serverList.contains(address));
    }
  }
 public static net.rubyeye.xmemcached.MemcachedClient getXClient() {
   MemcachedClientBuilder builder =
       new XMemcachedClientBuilder(
           net.rubyeye.xmemcached.utils.AddrUtil.getAddresses(MEMCACHED_SERVER_ADDR));
   try {
     return builder.build();
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
 }
Ejemplo n.º 8
0
 /**
  * 获取MemcachedClient
  *
  * @param server 服务器
  * @return MemcachedClient
  */
 public static MemcachedClient getMemcachedClient(Config c) {
   MemcachedClientBuilder bulider =
       new XMemcachedClientBuilder(AddrUtil.getAddresses(c.getMemServer()));
   bulider.setConnectionPoolSize(2);
   try {
     return bulider.build();
   } catch (IOException e) {
     e.printStackTrace();
   }
   return null;
 }
  @Override
  public MemcachedClientBuilder createWeightedBuilder() throws Exception {
    List<InetSocketAddress> addressList =
        AddrUtil.getAddresses(this.properties.getProperty("test.memcached.servers"));
    int[] weights = new int[addressList.size()];
    for (int i = 0; i < weights.length; i++) {
      weights[i] = i + 1;
    }

    MemcachedClientBuilder builder = new XMemcachedClientBuilder(addressList, weights);
    builder.setSessionLocator(new KetamaMemcachedSessionLocator());
    return builder;
  }
Ejemplo n.º 10
0
  /*
   * (non-Javadoc)
   * @see junit.framework.TestCase#setUp()
   */
  protected void setUp() throws Exception {
    Config.setSetting("port", "12001");
    Config.setSetting("path", "dbtest");
    Config.setSetting("logsize", "40");
    Config.setSetting("authorization", "key|abc@@bbs|pass");
    StartNewQueue.newQueueInstance(Integer.parseInt(Config.getSetting("port")));
    log.info("running at port " + Config.getSetting("port"));
    builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("127.0.0.1:12001"));
    builder.setConnectionPoolSize(50); // set connection pool size to five

    try {
      client = builder.build();
      client.setOptimizeGet(false);
      builder.setSocketOption(StandardSocketOption.SO_KEEPALIVE, true);
      builder.setSocketOption(StandardSocketOption.SO_RCVBUF, 64 * 1024);
      builder.setSocketOption(StandardSocketOption.SO_SNDBUF, 64 * 1024);
      builder.setSocketOption(StandardSocketOption.SO_REUSEADDR, true);
      builder.setSocketOption(StandardSocketOption.TCP_NODELAY, false);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    client.get("clear|key|abc");
  }