@Test
  public void testConfigLifecycleListener() throws InterruptedException {
    ClientConfig config = new ClientConfig();
    final BlockingQueue<LifecycleEvent> q = new LinkedBlockingQueue<LifecycleEvent>();
    config.addListener(
        new LifecycleListener() {
          public void stateChanged(final LifecycleEvent event) {
            q.offer(event);
            System.out.println(event);
          }
        });
    Hazelcast.getDefaultInstance();
    HazelcastClient client = HazelcastClient.newHazelcastClient(config);

    Assert.assertEquals(new LifecycleEvent(LifecycleState.STARTING), q.poll(3, TimeUnit.SECONDS));
    Assert.assertEquals(
        new LifecycleEvent(LifecycleState.CLIENT_CONNECTION_OPENING), q.poll(3, TimeUnit.SECONDS));
    Assert.assertEquals(
        new LifecycleEvent(LifecycleState.CLIENT_CONNECTION_OPENED), q.poll(3, TimeUnit.SECONDS));
    Assert.assertEquals(new LifecycleEvent(LifecycleState.STARTED), q.poll(3, TimeUnit.SECONDS));
    client.shutdown();
    //        Assert.assertEquals(new LifecycleEvent(LifecycleState.CLIENT_CONNECTION_LOST),
    // q.poll(3, TimeUnit.SECONDS));
    Assert.assertEquals(
        new LifecycleEvent(LifecycleState.SHUTTING_DOWN), q.poll(3, TimeUnit.SECONDS));
    Assert.assertEquals(new LifecycleEvent(LifecycleState.SHUTDOWN), q.poll(3, TimeUnit.SECONDS));
  }
  public static List<PatientSearchResult> getDynamicSearch(
      List<DynamicSearchCriteria> criteria, String stateRelation, String userToken) {
    // Use a form because there are an unknown number of values
    MultivaluedMap form = new MultivaluedMapImpl();
    // stateRelation is how the criteria are logically related "AND", "OR"
    form.add("stateRelation", stateRelation);
    int i = 0;
    // Step through all criteria given, the form fields are appended with an integer
    // to maintain grouping in REST call (dataGroup0, dataGroup1...)
    for (DynamicSearchCriteria dcriteria : criteria) {
      form.add("sourceName" + i, dcriteria.getDataGroup());
      form.add("itemName" + i, dcriteria.getField());
      form.add("operator" + i, dcriteria.getOperator().getValue());
      form.add("value" + i, dcriteria.getValue());
      i++;
    }

    ClientConfig cc = new DefaultClientConfig();
    cc.getClasses().add(JacksonJsonProvider.class);
    Client client = Client.create();
    WebResource resource =
        client.resource(APIURLHolder.getUrl() + "/nbia-api/services/getDynamicSearch");
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .type(MediaType.APPLICATION_FORM_URLENCODED)
            .header("Authorization", "Bearer " + userToken)
            .post(ClientResponse.class, form);
    // check response status code
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    // display response
    String output = response.getEntity(String.class);
    List<PatientSearchResultImpl> myObjects;
    try {
      //	Object json = mapper.readValue(output, Object.class);
      //   String indented = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(json);
      //   logger.info("Returned JSON\n"+indented);
      myObjects = mapper.readValue(output, new TypeReference<List<PatientSearchResultImpl>>() {});
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
    List<PatientSearchResult> returnValue = new ArrayList<PatientSearchResult>();
    for (PatientSearchResultImpl result : myObjects) {
      returnValue.add(result);
    }
    return returnValue;
  }
  @Test
  public void testNearCacheConfigs() {
    assertEquals(1, clientConfig.getNearCacheConfigMap().size());
    final NearCacheConfig nearCacheConfig = clientConfig.getNearCacheConfig("asd");

    assertEquals(2000, nearCacheConfig.getMaxSize());
    assertEquals(2000, nearCacheConfig.getEvictionConfig().getSize());
    assertEquals(90, nearCacheConfig.getTimeToLiveSeconds());
    assertEquals(100, nearCacheConfig.getMaxIdleSeconds());
    assertEquals("LFU", nearCacheConfig.getEvictionPolicy());
    assertEquals(EvictionPolicy.LFU, nearCacheConfig.getEvictionConfig().getEvictionPolicy());
    assertTrue(nearCacheConfig.isInvalidateOnChange());
    assertEquals(InMemoryFormat.OBJECT, nearCacheConfig.getInMemoryFormat());
  }
Пример #4
0
  private void start() {
    // 1. instance
    reactorManager = CommonUtils.newInstance(clientConfig.getReactorManagerClassName());
    ioWorker = CommonUtils.newInstance(clientConfig.getIoWorkerClassName());
    eventWorker = CommonUtils.newInstance(clientConfig.getEventWorkerClassName());
    protocolFactory = CommonUtils.newInstance(clientConfig.getProtocolFactoryClassName());
    messageHandler = CommonUtils.newInstance(clientConfig.getMessageHandlerClassName());

    ioWorker.setReactorManager(reactorManager);

    eventWorker.setProtocolFactory(protocolFactory).setMessageHandler(messageHandler);

    reactorManager.setNIOConfig(clientConfig).setIoWorker(ioWorker).setEventWorker(eventWorker);

    reactorManager.start();
  }
  @Test
  public void testQueryCacheFullConfig() throws Exception {
    QueryCacheConfig queryCacheConfig =
        clientConfig.getQueryCacheConfigs().get("map-name").get("query-cache-name");
    EntryListenerConfig entryListenerConfig = queryCacheConfig.getEntryListenerConfigs().get(0);

    assertEquals("query-cache-name", queryCacheConfig.getName());
    assertTrue(entryListenerConfig.isIncludeValue());
    assertFalse(entryListenerConfig.isLocal());
    assertEquals("com.hazelcast.examples.EntryListener", entryListenerConfig.getClassName());
    assertTrue(queryCacheConfig.isIncludeValue());
    assertEquals(1, queryCacheConfig.getBatchSize());
    assertEquals(16, queryCacheConfig.getBufferSize());
    assertEquals(0, queryCacheConfig.getDelaySeconds());
    assertEquals(EvictionPolicy.LRU, queryCacheConfig.getEvictionConfig().getEvictionPolicy());
    assertEquals(
        EvictionConfig.MaxSizePolicy.ENTRY_COUNT,
        queryCacheConfig.getEvictionConfig().getMaximumSizePolicy());
    assertEquals(10000, queryCacheConfig.getEvictionConfig().getSize());
    assertEquals(InMemoryFormat.BINARY, queryCacheConfig.getInMemoryFormat());
    assertFalse(queryCacheConfig.isCoalesce());
    assertTrue(queryCacheConfig.isPopulate());
    Iterator<MapIndexConfig> iterator = queryCacheConfig.getIndexConfigs().iterator();
    while (iterator.hasNext()) {
      MapIndexConfig mapIndexConfig = iterator.next();
      assertEquals("name", mapIndexConfig.getAttribute());
      assertFalse(mapIndexConfig.isOrdered());
    }

    assertEquals(
        "com.hazelcast.examples.ExamplePredicate",
        queryCacheConfig.getPredicateConfig().getClassName());
  }
  @Test
  public void testSerializationConfig() {
    final SerializationConfig serializationConfig = clientConfig.getSerializationConfig();
    assertEquals(3, serializationConfig.getPortableVersion());

    final Map<Integer, String> dsClasses = serializationConfig.getDataSerializableFactoryClasses();
    assertEquals(1, dsClasses.size());
    assertEquals("com.hazelcast.examples.DataSerializableFactory", dsClasses.get(1));

    final Map<Integer, String> pfClasses = serializationConfig.getPortableFactoryClasses();
    assertEquals(1, pfClasses.size());
    assertEquals("com.hazelcast.examples.PortableFactory", pfClasses.get(2));

    final Collection<SerializerConfig> serializerConfigs =
        serializationConfig.getSerializerConfigs();
    assertEquals(1, serializerConfigs.size());
    final SerializerConfig serializerConfig = serializerConfigs.iterator().next();

    assertEquals("com.hazelcast.examples.DummyType", serializerConfig.getTypeClassName());
    assertEquals("com.hazelcast.examples.SerializerFactory", serializerConfig.getClassName());

    final GlobalSerializerConfig globalSerializerConfig =
        serializationConfig.getGlobalSerializerConfig();
    assertEquals(
        "com.hazelcast.examples.GlobalSerializerFactory", globalSerializerConfig.getClassName());

    assertEquals(ByteOrder.BIG_ENDIAN, serializationConfig.getByteOrder());
    assertEquals(true, serializationConfig.isCheckClassDefErrors());
    assertEquals(false, serializationConfig.isAllowUnsafe());
    assertEquals(false, serializationConfig.isEnableCompression());
    assertEquals(true, serializationConfig.isEnableSharedObject());
    assertEquals(true, serializationConfig.isUseNativeByteOrder());
  }
  @Test
  public void testNetworkConfig() {
    final ClientNetworkConfig networkConfig = clientConfig.getNetworkConfig();
    assertEquals(2, networkConfig.getConnectionAttemptLimit());
    assertEquals(2, networkConfig.getAddresses().size());
    assertTrue(networkConfig.getAddresses().contains("127.0.0.1"));
    assertTrue(networkConfig.getAddresses().contains("127.0.0.2"));

    assertTrue(networkConfig.isSmartRouting());
    assertTrue(networkConfig.isRedoOperation());

    final SocketInterceptorConfig socketInterceptorConfig =
        networkConfig.getSocketInterceptorConfig();
    assertTrue(socketInterceptorConfig.isEnabled());
    assertEquals(
        "com.hazelcast.examples.MySocketInterceptor", socketInterceptorConfig.getClassName());
    assertEquals("bar", socketInterceptorConfig.getProperty("foo"));

    final ClientAwsConfig awsConfig = networkConfig.getAwsConfig();
    assertTrue(awsConfig.isEnabled());
    assertTrue(awsConfig.isInsideAws());
    assertEquals("TEST_ACCESS_KEY", awsConfig.getAccessKey());
    assertEquals("TEST_ACCESS_KEY", awsConfig.getAccessKey());
    assertEquals("TEST_SECRET_KEY", awsConfig.getSecretKey());
    assertEquals("us-east-1", awsConfig.getRegion());
    assertEquals("ec2.amazonaws.com", awsConfig.getHostHeader());
    assertEquals("type", awsConfig.getTagKey());
    assertEquals("hz-nodes", awsConfig.getTagValue());
    assertEquals(11, awsConfig.getConnectionTimeoutSeconds());
  }
Пример #8
0
  @Activate
  public void activate(ClientConfig config) {
    handleIllegalConfiguration(validateClientId(config.clientId()));

    databaseName = config.databaseName();

    // The uriProperty is a single string containing one or more server URIs.
    // When more than one URI is specified, it denotes a replica set and the
    // URIs must be separated by a comma (CSV).

    uris = new ArrayList<String>();
    handleIllegalConfiguration(validateURI(config.uri(), uris));

    MongoClientOptions options = createMongoClientOptions(config);
    mongoClient = createMongoClient(uris, options);
  }
 @Test
 public void testProxyFactories() {
   final List<ProxyFactoryConfig> pfc = clientConfig.getProxyFactoryConfigs();
   assertEquals(3, pfc.size());
   assertTrue(
       pfc.contains(new ProxyFactoryConfig("com.hazelcast.examples.ProxyXYZ1", "sampleService1")));
   assertTrue(
       pfc.contains(new ProxyFactoryConfig("com.hazelcast.examples.ProxyXYZ2", "sampleService1")));
   assertTrue(
       pfc.contains(new ProxyFactoryConfig("com.hazelcast.examples.ProxyXYZ3", "sampleService3")));
 }
 @Test(timeout = 120000)
 public void testSuccessfulSocketInterceptor() {
   Config config = new Config();
   SocketInterceptorConfig sic = new SocketInterceptorConfig();
   MySocketInterceptor mySocketInterceptor = new MySocketInterceptor(true);
   sic.setImplementation(mySocketInterceptor);
   config.getNetworkConfig().setSocketInterceptorConfig(sic);
   HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config);
   HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config);
   HazelcastInstance h3 = Hazelcast.newHazelcastInstance(config);
   HazelcastInstance h4 = Hazelcast.newHazelcastInstance(config);
   int count = 1000;
   for (int i = 0; i < count; i++) {
     h1.getMap("default").put(i, "value" + i);
     h2.getMap("default").put(i, "value" + i);
     h3.getMap("default").put(i, "value" + i);
     h4.getMap("default").put(i, "value" + i);
   }
   assertEquals(4, h4.getCluster().getMembers().size());
   assertTrue(mySocketInterceptor.getAcceptCallCount() >= 6);
   assertTrue(mySocketInterceptor.getConnectCallCount() >= 6);
   assertEquals(4, mySocketInterceptor.getInitCallCount());
   assertEquals(0, mySocketInterceptor.getAcceptFailureCount());
   assertEquals(0, mySocketInterceptor.getConnectFailureCount());
   ClientConfig clientConfig = new ClientConfig();
   clientConfig.setGroupConfig(new GroupConfig("dev", "dev-pass")).addAddress("localhost");
   MySocketInterceptor myClientSocketInterceptor = new MySocketInterceptor(true);
   clientConfig.setSocketInterceptor(myClientSocketInterceptor);
   HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig);
   for (int i = 0; i < count; i++) {
     client.getMap("default").put(i, "value" + i);
   }
   assertTrue(mySocketInterceptor.getAcceptCallCount() >= 7);
   assertTrue(mySocketInterceptor.getConnectCallCount() >= 6);
   assertEquals(1, myClientSocketInterceptor.getConnectCallCount());
   assertEquals(0, myClientSocketInterceptor.getAcceptCallCount());
   assertEquals(0, mySocketInterceptor.getAcceptFailureCount());
   assertEquals(0, mySocketInterceptor.getConnectFailureCount());
   assertEquals(0, myClientSocketInterceptor.getAcceptFailureCount());
   assertEquals(0, myClientSocketInterceptor.getConnectFailureCount());
 }
  @Test
  public void testLeftovers() {
    assertEquals(40, clientConfig.getExecutorPoolSize());

    assertEquals(
        "com.hazelcast.security.UsernamePasswordCredentials",
        clientConfig.getSecurityConfig().getCredentialsClassname());
    assertEquals(40, clientConfig.getExecutorPoolSize());

    assertEquals(
        "com.hazelcast.client.util.RandomLB", clientConfig.getLoadBalancer().getClass().getName());

    final List<ListenerConfig> listenerConfigs = clientConfig.getListenerConfigs();
    assertEquals(3, listenerConfigs.size());
    assertTrue(
        listenerConfigs.contains(new ListenerConfig("com.hazelcast.examples.MembershipListener")));
    assertTrue(
        listenerConfigs.contains(new ListenerConfig("com.hazelcast.examples.InstanceListener")));
    assertTrue(
        listenerConfigs.contains(new ListenerConfig("com.hazelcast.examples.MigrationListener")));
  }
  public static List<ImageDTO> getImageDrillDown(List<Integer> criteria, String userToken) {

    Form form = new Form();
    int i = 0;
    // List of selected series
    for (Integer dcriteria : criteria) {
      form.add("list", dcriteria.toString());
    }

    ClientConfig cc = new DefaultClientConfig();
    cc.getClasses().add(JacksonJsonProvider.class);
    Client client = Client.create();
    WebResource resource =
        client.resource(APIURLHolder.getUrl() + "/nbia-api/services/getImageDrillDown");
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .header("Authorization", "Bearer " + userToken)
            .type(MediaType.APPLICATION_FORM_URLENCODED)
            .post(ClientResponse.class, form);
    // check response status code
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    // display response
    String output = response.getEntity(String.class);
    List<ImageDTO> myObjects;
    try {
      //	Object json = mapper.readValue(output, Object.class);
      //    String indented = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(json);
      //    logger.info("Returned JSON\n"+indented);
      myObjects = mapper.readValue(output, new TypeReference<List<ImageDTO>>() {});
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }

    return myObjects;
  }
  public static String getJNLP(
      List<BasketSeriesItemBean> seriesItems,
      String password,
      boolean annotation,
      String userToken) {
    // Use a form because there are an unknown number of values
    MultivaluedMap form = new MultivaluedMapImpl();
    if ((seriesItems == null) || (seriesItems.size() == 0)) {
      return "";
    }
    // Step through all data in series items for display in download manager
    for (BasketSeriesItemBean item : seriesItems) {
      form.add("list", item.getSeriesId());
    }
    form.add("password", password);
    String annotationString = "false";
    if (annotation) {
      annotationString = "true";
    }
    form.add("includeAnnotation", annotationString);
    ClientConfig cc = new DefaultClientConfig();
    cc.getClasses().add(JacksonJsonProvider.class);
    Client client = Client.create();
    WebResource resource =
        client.resource(APIURLHolder.getUrl() + "/nbia-api/services/getJNLPText");
    ClientResponse response =
        resource
            .accept(MediaType.TEXT_PLAIN)
            .type(MediaType.APPLICATION_FORM_URLENCODED)
            .header("Authorization", "Bearer " + userToken)
            .post(ClientResponse.class, form);
    // check response status code
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    // display response
    String output = response.getEntity(String.class);
    return output;
  }
  public static List<PatientSearchResult> getTextSearch(String textValue, String userToken) {

    Form form = new Form();
    form.add("textValue", textValue);

    ClientConfig cc = new DefaultClientConfig();
    cc.getClasses().add(JacksonJsonProvider.class);
    Client client = Client.create();
    WebResource resource =
        client.resource(APIURLHolder.getUrl() + "/nbia-api/services/getTextSearch");
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .type(MediaType.APPLICATION_FORM_URLENCODED)
            .header("Authorization", "Bearer " + userToken)
            .post(ClientResponse.class, form);
    // check response status code
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    // display response
    String output = response.getEntity(String.class);
    List<PatientTextSearchResult> myObjects;
    try {
      // Object json = mapper.readValue(output, Object.class);
      //  String indented = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(json);
      // logger.info("Returned JSON\n"+indented);
      myObjects =
          mapper.readValue(output, new TypeReference<List<PatientTextSearchResultImpl>>() {});
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
    List<PatientSearchResult> returnValue = new ArrayList<PatientSearchResult>();
    for (PatientTextSearchResult result : myObjects) {
      returnValue.add(result);
    }
    return returnValue;
  }
  @Test
  public void loadingThroughSystemProperty_existingFile() throws IOException {
    String xml =
        HAZELCAST_CLIENT_START_TAG
            + "    <group>\n"
            + "        <name>foobar</name>\n"
            + "        <password>dev-pass</password>\n"
            + "    </group>"
            + "</hazelcast-client>";

    File file = File.createTempFile("foo", "bar");
    file.deleteOnExit();
    PrintWriter writer = new PrintWriter(file, "UTF-8");
    writer.println(xml);
    writer.close();

    System.setProperty("hazelcast.client.config", file.getAbsolutePath());

    XmlClientConfigBuilder configBuilder = new XmlClientConfigBuilder();
    ClientConfig config = configBuilder.build();
    assertEquals("foobar", config.getGroupConfig().getName());
  }
  @Test
  public void testNearCacheConfigWithEvictionConfig() throws IOException {
    URL schemaResource =
        XMLConfigBuilderTest.class.getClassLoader().getResource("hazelcast-client-test.xml");
    ClientConfig clientConfig = new XmlClientConfigBuilder(schemaResource).build();

    assertEquals("MyName", clientConfig.getInstanceName());

    NearCacheConfig nearCacheConfig = clientConfig.getNearCacheConfig("nearCacheWithEviction");

    assertEquals(10000, nearCacheConfig.getTimeToLiveSeconds());
    assertEquals(5000, nearCacheConfig.getMaxIdleSeconds());
    assertFalse(nearCacheConfig.isInvalidateOnChange());
    assertEquals(InMemoryFormat.OBJECT, nearCacheConfig.getInMemoryFormat());
    assertTrue(nearCacheConfig.isCacheLocalEntries());

    assertNotNull(nearCacheConfig.getEvictionConfig());
    assertEquals(100, nearCacheConfig.getEvictionConfig().getSize());
    assertEquals(
        EvictionConfig.MaxSizePolicy.ENTRY_COUNT,
        nearCacheConfig.getEvictionConfig().getMaximumSizePolicy());
    assertEquals(EvictionPolicy.LFU, nearCacheConfig.getEvictionConfig().getEvictionPolicy());
  }
  public static DefaultOAuth2AccessToken getToken(String userName, String password) {

    Form form = new Form();
    form.add("username", userName);
    form.add("password", password);
    form.add("client_id", "nbiaRestAPIClient");
    form.add("client_secret", "ItsBetweenUAndMe");
    form.add("grant_type", "password");

    ClientConfig cc = new DefaultClientConfig();
    cc.getClasses().add(JacksonJsonProvider.class);
    Client client = Client.create();
    WebResource resource = client.resource(APIURLHolder.getUrl() + "/nbia-api/oauth/token");
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .type(MediaType.APPLICATION_FORM_URLENCODED)
            .post(ClientResponse.class, form);
    // check response status code
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    // display response
    String output = response.getEntity(String.class);
    output = "[" + output + "]";
    List<DefaultOAuth2AccessToken> myObjects;
    try {
      myObjects = mapper.readValue(output, new TypeReference<List<DefaultOAuth2AccessToken>>() {});
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }

    return myObjects.get(0);
  }
  @Test
  public void testNearCacheConfigWildcardMatchingPointStartsWith() {
    NearCacheConfig nearCacheConfig1 = new NearCacheConfig().setName("hazelcast.*");
    NearCacheConfig nearCacheConfig2 = new NearCacheConfig().setName("hazelcast.test.*");
    NearCacheConfig nearCacheConfig3 = new NearCacheConfig().setName("hazelcast.test.sub.*");

    ClientConfig config = new ClientConfig();
    config.setConfigPatternMatcher(new LegacyMatchingPointConfigPatternMatcher());
    config.addNearCacheConfig(nearCacheConfig1);
    config.addNearCacheConfig(nearCacheConfig2);
    config.addNearCacheConfig(nearCacheConfig3);

    // we should match this (contains)
    assertEquals(nearCacheConfig1, config.getNearCacheConfig("com.hazelcast.myNearCache"));
    assertEquals(nearCacheConfig2, config.getNearCacheConfig("com.hazelcast.test.myNearCache"));
    assertEquals(nearCacheConfig3, config.getNearCacheConfig("com.hazelcast.test.sub.myNearCache"));
  }
Пример #19
0
  @SuppressWarnings("unchecked")
  public static <T> T createClient(final Class<T> clazz, ClientConfig config) {

    // create the server URI
    URI uri = null;
    try {
      uri = new URI(config.getServer());
    } catch (Exception ex) {
      throw new RuntimeException(
          "Error creating the URI form the server string: " + config.getServer(), ex);
    }

    T service = null;
    if (clientCache.containsKey(clazz)) {
      service = (T) clientCache.get(clazz);
    } else {

      // create the rest-easy provider factory
      ClientBuilder builder = ClientBuilder.newBuilder();
      if (config.isAllowAllHttps()) {
        builder.hostnameVerifier(new AllowAllHostnameVerifier());
      }

      // add the default interceptors.
      if (config.isDefaultLogInterceptor()) {
        builder.register(ClientServiceLogFilter.class);
      }

      // add the advanced interceptors
      List<Class> cpc = config.getComponentClasses();
      if (cpc != null) {
        for (Class filter : cpc) {
          builder.register(filter);
        }
      }
      List<Object> filters = config.getComponents();
      if (filters != null) {
        for (Object filter : filters) {
          builder.register(filter);
        }
      }

      Client client = builder.build();
      WebTarget target = client.target(uri);
      service = ClientServiceProxyFactory.newResource(clazz, target);
      clientCache.put(clazz, service);
    }
    return service;
  }
  @Test
  public void loadingThroughSystemProperty_existingClasspathResource() throws IOException {
    System.setProperty("hazelcast.client.config", "classpath:test-hazelcast-client.xml");

    XmlClientConfigBuilder configBuilder = new XmlClientConfigBuilder();
    ClientConfig config = configBuilder.build();
    assertEquals("foobar", config.getGroupConfig().getName());
    assertEquals(
        "com.hazelcast.nio.ssl.BasicSSLContextFactory",
        config.getNetworkConfig().getSSLConfig().getFactoryClassName());
    assertEquals(32, config.getNetworkConfig().getSocketOptions().getBufferSize());
    assertFalse(config.getNetworkConfig().getSocketOptions().isKeepAlive());
    assertFalse(config.getNetworkConfig().getSocketOptions().isTcpNoDelay());
    assertEquals(3, config.getNetworkConfig().getSocketOptions().getLingerSeconds());
  }
Пример #21
0
  protected void setupHttpClient() {

    LOG.info("setting up http client");

    BasicHttpParams httpParams = new BasicHttpParams();
    HttpConnectionParams.setSoTimeout(httpParams, 70 * 1000);
    HttpConnectionParams.setConnectionTimeout(httpParams, 10 * 1000);
    ConnManagerParams.setMaxTotalConnections(httpParams, 200);
    ConnPerRoute connPerRoute = new ConnPerRouteBean(400);
    ConnManagerParams.setMaxConnectionsPerRoute(httpParams, connPerRoute);
    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
    ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
    // ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams,
    // HttpClientWithKeystore.getSchemeRegistry());
    HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
    HttpProtocolParams.setContentCharset(httpParams, "utf-8");
    mHttpClient = new HttpClientWithKeystore(cm, httpParams);
    mHttpClient.getParams().setParameter("http.useragent", mConfig.getApplicationName());
    mHttpClient.getParams().setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
    mHttpClient.setReuseStrategy(new NoConnectionReuseStrategy());
  }
 @Test
 public void testProperties() {
   assertEquals(6, clientConfig.getProperties().size());
   assertEquals("60000", clientConfig.getProperty("hazelcast.client.heartbeat.timeout"));
 }
Пример #23
0
  private MongoClientOptions createMongoClientOptions(ClientConfig config) {
    MongoClientOptions.Builder optionsBuilder = new MongoClientOptions.Builder();

    optionsBuilder.alwaysUseMBeans(config.alwaysUseMBeans());
    optionsBuilder.connectionsPerHost(config.connectionsPerHost());
    optionsBuilder.connectTimeout(config.connectTimeout());
    optionsBuilder.cursorFinalizerEnabled(config.cursorFinalizerEnabled());
    optionsBuilder.description(config.description());
    optionsBuilder.heartbeatConnectTimeout(config.heartbeatConnectTimeout());
    optionsBuilder.heartbeatFrequency(config.heartbeatFrequency());
    optionsBuilder.heartbeatSocketTimeout(config.heartbeatSocketTimeout());
    optionsBuilder.localThreshold(config.localThreshold());
    optionsBuilder.maxConnectionIdleTime(config.maxConnectionIdleTime());
    optionsBuilder.maxConnectionLifeTime(config.maxConnectionLifeTime());
    optionsBuilder.maxWaitTime(config.maxWaitTime());
    optionsBuilder.minConnectionsPerHost(config.minConnectionsPerHost());
    optionsBuilder.minHeartbeatFrequency(config.minHeartbeatFrequency());
    optionsBuilder.serverSelectionTimeout(config.serverSelectionTimeout());
    optionsBuilder.socketKeepAlive(config.socketKeepAlive());
    optionsBuilder.socketTimeout(config.socketTimeout());
    optionsBuilder.sslEnabled(config.sslEnabled());
    optionsBuilder.sslInvalidHostNameAllowed(config.sslInvalidHostNameAllowed());
    optionsBuilder.threadsAllowedToBlockForConnectionMultiplier(
        config.threadsAllowedToBlockForConnectionMultiplier());
    WriteConcern writeConcern =
        new WriteConcern(
            config.writeConcernW(),
            config.writeConcernWtimeout(),
            config.writeConcernFsync(),
            config.writeConcernJ());
    optionsBuilder.writeConcern(writeConcern);

    if (!config.requiredReplicaSetName().isEmpty())
      optionsBuilder.requiredReplicaSetName(config.requiredReplicaSetName());

    List<Tag> tags = new ArrayList<>();

    if (config.readPreferenceTags() != null) {
      for (String tag : config.readPreferenceTags()) {
        String[] elements = tag.split("=");
        tags.add(new Tag(elements[0], elements[1]));
      }
    }

    TagSet tagSet = new TagSet(tags);

    switch (config.readPreferenceType()) {
      case 1:
        optionsBuilder.readPreference(ReadPreference.nearest(tagSet));
        break;
      case 2:
        optionsBuilder.readPreference(ReadPreference.primary());
        break;
      case 3:
        optionsBuilder.readPreference(ReadPreference.primaryPreferred(tagSet));
        break;
      case 4:
        optionsBuilder.readPreference(ReadPreference.secondary(tagSet));
        break;
      case 5:
        optionsBuilder.readPreference(ReadPreference.secondaryPreferred(tagSet));
        break;
    }

    return optionsBuilder.build();
  }
Пример #24
0
 protected String sign(String url) {
   return ApiSigningTools.sign(url, mConfig.getApiKey(), mConfig.getSharedSecret());
 }
 @Test
 public void testGroupConfig() {
   final GroupConfig groupConfig = clientConfig.getGroupConfig();
   assertEquals("dev", groupConfig.getName());
   assertEquals("dev-pass", groupConfig.getPassword());
 }
Пример #26
0
 @Override
 public void runValidation() {
   ioHelper.validatePath(clientConfig.getBrokerDir(), "broker must be configured");
 }
  public static void getSimpleSearch(List<Criteria> criteria, String userToken) {
    // Use a form because there are an unknown number of values
    MultivaluedMap form = new MultivaluedMapImpl();

    int i = 0;
    // Step through all criteria given, the form fields are appended with an integer
    // to maintain grouping in REST call (dataGroup0, dataGroup1...)
    for (Criteria scriteria : criteria) {
      if (scriteria instanceof CollectionCriteria) {
        CollectionCriteria cri = (CollectionCriteria) scriteria;
        for (String collection : ((CollectionCriteria) scriteria).getCollectionObjects()) {
          form.add("criteriaType" + i, "CollectionCriteria");
          form.add("value" + i, collection);
        }
      }
      if (scriteria instanceof ImageModalityCriteria) {
        ImageModalityCriteria cri = (ImageModalityCriteria) scriteria;
        for (String value : ((ImageModalityCriteria) scriteria).getImageModalityObjects()) {
          form.add("criteriaType" + i, "ImageModalityCriteria");
          form.add("value" + i, value);
        }
      }
      if (scriteria instanceof AnatomicalSiteCriteria) {
        AnatomicalSiteCriteria cri = (AnatomicalSiteCriteria) scriteria;
        for (String value : ((AnatomicalSiteCriteria) scriteria).getAnatomicalSiteValueObjects()) {
          form.add("criteriaType" + i, "AnatomicalSiteCriteria");
          form.add("value" + i, value);
        }
      }
      if (scriteria instanceof ManufacturerCriteria) {
        ManufacturerCriteria cri = (ManufacturerCriteria) scriteria;
        for (String value : ((ManufacturerCriteria) scriteria).getManufacturerObjects()) {
          form.add("criteriaType" + i, "ManufacturerCriteria");
          form.add("value" + i, value);
        }
      }
      if (scriteria instanceof DateRangeCriteria) {
        DateRangeCriteria cri = (DateRangeCriteria) scriteria;
        form.add("criteriaType" + i, "DateRangeCriteria");
        SimpleDateFormat formatter = new SimpleDateFormat("dd/mm/yyyy");
        form.add("fromDate" + i, formatter.format(cri.getFromDate()));
        form.add("toDate" + i, formatter.format(cri.getToDate()));
      }
      if (scriteria instanceof PatientCriteria) {
        PatientCriteria cri = (PatientCriteria) scriteria;
        for (String value : ((PatientCriteria) scriteria).getPatientIdObjects()) {
          form.add("criteriaType" + i, "PatientCriteria");
          form.add("value" + i, value);
        }
      }
      if (scriteria instanceof MinNumberOfStudiesCriteria) {
        MinNumberOfStudiesCriteria cri = (MinNumberOfStudiesCriteria) scriteria;
        form.add("criteriaType" + i, "MinNumberOfStudiesCriteria");
        form.add("value" + i, cri.getMinNumberOfStudiesValue().toString());
      }
      i++;
    }

    ClientConfig cc = new DefaultClientConfig();
    cc.getClasses().add(JacksonJsonProvider.class);
    Client client = Client.create();
    WebResource resource =
        client.resource(APIURLHolder.getUrl() + "/nbia-api/services/getSimpleSearch");
    ClientResponse response =
        resource
            .accept(MediaType.APPLICATION_JSON)
            .type(MediaType.APPLICATION_FORM_URLENCODED)
            .header("Authorization", "Bearer " + userToken)
            .post(ClientResponse.class, form);
    // check response status code
    if (response.getStatus() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + response.getStatus());
    }

    // display response
    String output = response.getEntity(String.class);
    List<PatientSearchResultImpl> myObjects;
    try {
      //    Object json = mapper.readValue(output, Object.class);
      //   String indented = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(json);
      //   logger.info("Returned JSON\n"+indented);
      myObjects = mapper.readValue(output, new TypeReference<List<PatientSearchResultImpl>>() {});
    } catch (Exception e) {
      e.printStackTrace();
      return;
    }
    List<PatientSearchResult> returnValue = new ArrayList<PatientSearchResult>();
    for (PatientSearchResultImpl result : myObjects) {
      returnValue.add(result);
    }
    return;
  }