Examples of com.linkedin.d2.balancer.KeyMapper$TargetHostHints

com.linkedin.d2.balancer.properties.ServiceProperties
KeyMapper is used with D2's consistent hashing mechanism to maintain key to host affinity across a set of functionally similar hosts. A typical use case for this affinity is to allow the service provider to maintain cache affinity, for better resource utilization. Note that there are no strict partitioning guarantees, since failure or overload conditions can cause the same key to be mapped to another host on subsequent requests. Similarly, different clients may have temporally inconsistent views of the key mappings. KeyMapper allows clients to determine which host would be chosen to serve a request for a specific key without requiring a request for the key to be fully constructed. This allows clients to map a set of keys across the hosts in the D2 cluster. The client can use this information to construct a single batch request to each host, containing the group of keys which map to the respective host. Clients should not depend on a KeyMapper if strict partitioning is required. @author Josh Walker @version $Revision: $


  @Override
  public void setMarkUp(String clusterName, String uri, double weight) throws PropertyStoreException
  {
    Map<Integer, PartitionData> partitionDataMap = new HashMap<Integer, PartitionData>(1);
    partitionDataMap.put(DefaultPartitionAccessor.DEFAULT_PARTITION_ID, new PartitionData(weight));
    setMarkup(clusterName, uri, partitionDataMap, Collections.<String, Object>emptyMap());
  }

View Full Code Here

      for (Map.Entry<String, Object> entry : sourceMap.entrySet())
      {
        @SuppressWarnings("unchecked")
        Map<String, Object> partitionDataMap = (Map<String, Object>) entry.getValue();
        String weightStr = PropertyUtil.checkAndGetValue(partitionDataMap, "weight", String.class, "URI weight");
        PartitionData data = new PartitionData(PropertyUtil.parseDouble("weight", weightStr));
        map.put(PropertyUtil.parseInt("partitionId", entry.getKey()), data);
      }
    }
    return map;
  }

View Full Code Here

  }


  @Override
  public LoadBalancerStateItem<ServiceProperties> getServiceProperties(String serviceName)
  {
    ServiceProperties serviceProperties = new ServiceProperties(_service, _cluster, _path, _strategyName);
    return new LoadBalancerStateItem<ServiceProperties>(serviceProperties, 1, 1);
  }

View Full Code Here

    List<String> prioritizedSchemes = new ArrayList<String>();


    prioritizedSchemes.add("http");


    return (getServiceProperties)
        ? new LoadBalancerStateItem<ServiceProperties>(new ServiceProperties("service-1",
                                                                             "cluster-1",
                                                                             "/foo",
                                                                             "rr",
                                                                             Collections.<String>emptyList(),
                                                                             Collections.<String, Object>emptyMap(),

View Full Code Here


    assertTrue(_state.isListeningToService("service-1"));
    assertNotNull(_state.getServiceProperties("service-1"));
    assertNull(_state.getServiceProperties("service-1").getProperty());


    ServiceProperties property =
        new ServiceProperties("service-1", "cluster-1", "/test", "random");


    _serviceRegistry.put("service-1", property);


    assertTrue(_state.isListeningToService("service-1"));
    assertNotNull(_state.getServiceProperties("service-1"));

View Full Code Here


    _state.listenToService("service-1", new NullStateListenerCallback());


    assertNull(_state.getClient("service-1", uri));


    _serviceRegistry.put("service-1", new ServiceProperties("service-1", "cluster-1",
                                                            "/test", "random", null,
                                                            Collections.<String, Object>emptyMap(),
                                                             null, null, schemes, null));


    assertNull(_state.getClient("service-1", uri));

View Full Code Here

    // set up state
    _state.listenToService("service-1", new NullStateListenerCallback());


    assertNull(_state.getStrategy("service-1", "http"));


    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                            "cluster-1",
                                                            "/test",
                                                            "random",
                                                            Collections.<String>emptyList(),
                                                            Collections.<String, Object>emptyMap(),

View Full Code Here

    _state.listenToService("service-1", new NullStateListenerCallback());
    _state.listenToCluster("cluster-1", new NullStateListenerCallback());


    assertNull(_state.getStrategy("service-1", "http"));


    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                            "cluster-1",
                                                            "/test",
                                                            "random",
                                                            Collections.<String>emptyList(),
                                                            Collections.<String,Object>emptyMap(),
                                                            null,
                                                            null,
                                                            schemes,
                                                            null));


    assertNotNull(_state.getStrategy("service-1", "http"));


    LoadBalancerStrategy strategy = _state.getStrategy("service-1", "http");


    assertNotNull(strategy);
    assertTrue(strategy instanceof RandomLoadBalancerStrategy);


    // check that we're getting the exact same strategy (by pointer) every time
    assertTrue(strategy == _state.getStrategy("service-1", "http"));
    assertTrue(strategy == _state.getStrategy("service-1", "http"));


    // now make sure adding a cluster property won't change the strategy
    _clusterRegistry.put("cluster-1", new ClusterProperties("cluster-1"));


    // we should still have the same strategy now
    LoadBalancerStrategy newStrategy = _state.getStrategy("service-1", "http");
    assertNotNull(newStrategy);
    assertTrue(strategy == newStrategy);
    assertTrue(newStrategy instanceof RandomLoadBalancerStrategy);


    strategy = newStrategy;


    // refresh by adding service
    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                                "cluster-1",
                                                                "/test",
                                                                "random",
                                                                Collections.<String>emptyList(),
                                                                Collections.<String,Object>emptyMap(),

View Full Code Here

    assertNull(_state.getStrategy("service-1", "http"));


    // Put degrader into the strategyList, it it not one of the supported strategies in
    // this strategyFactory, so we should not get a strategy back for http.
    strategyList.add("degrader");
    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                            "cluster-1",
                                                            "/test",
                                                            "unusedInThisConstructor",
                                                            strategyList,
                                                            Collections.<String, Object>emptyMap(),
                                                            null,
                                                            null,
                                                            schemes,
                                                            null));
    _clusterRegistry.put("cluster-1", new ClusterProperties("cluster-1"));
    assertNull(_state.getStrategy("service-1", "http"));


    // put the random strategy into the Strategy list, it is one of the supported strategies in the
    // strategyFactory for this unit test
    strategyList.clear();
    strategyList.add("random");
    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                            "cluster-1",
                                                            "/test",
                                                            "unusedInThisConstructor",
                                                            strategyList,
                                                            Collections.<String, Object>emptyMap(),
                                                            null,
                                                            null,
                                                            schemes,
                                                            null));


    _clusterRegistry.put("cluster-1", new ClusterProperties("cluster-1"));


    LoadBalancerStrategy strategy = _state.getStrategy("service-1", "http");


    assertNotNull(strategy);
    assertTrue(strategy instanceof RandomLoadBalancerStrategy);


    // now add the degraderV3 strategy into the Strategy list
    strategyList.addFirst("degraderV3");
    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                            "cluster-1",
                                                            "/test",
                                                            "unusedInThisConstructor",
                                                            strategyList,
                                                            Collections.<String, Object>emptyMap(),

View Full Code Here

    assertNull(_state.getStrategy("service-1", "http"));


    // Use the _clusterRegistry.put to populate the _state.clusterProperties, used by
    // _state.refreshServiceStrategies
    _clusterRegistry.put("cluster-1", new ClusterProperties("cluster-1"));
    _serviceRegistry.put("service-1", new ServiceProperties("service-1",
                                                              "cluster-1",
                                                              "/test",
                                                              "unusedInThisConstructor",
                                                              strategyList,
                                                              Collections.<String, Object>emptyMap(),
                                                              Collections.<String, Object>emptyMap(),
                                                              Collections.<String, String>emptyMap(),
                                                              schemes,
                                                              Collections.<URI>emptySet()));


    LoadBalancerStrategy strategy = _state.getStrategy("service-1", "http");
    assertNotNull(strategy, "got null strategy in setup");


    // test serial to make sure things are working before concurrent test
    TransportClient resultTC = _state.getClient("service-1", "http");
    assertNotNull(resultTC, "got null tracker client in non-concurrent env");


    ExecutorService myExecutor = Executors.newCachedThreadPool();
    ArrayList<TcCallable> cArray = new ArrayList<TcCallable>();


    List<TrackerClient> clients = new ArrayList<TrackerClient>();
    Map<Integer, PartitionData> partitionDataMap = new HashMap<Integer, PartitionData>(2);
    partitionDataMap.put(DefaultPartitionAccessor.DEFAULT_PARTITION_ID, new PartitionData(1d));
    clients.add(new TrackerClient(uri, partitionDataMap, new DegraderLoadBalancerTest.TestLoadBalancerClient(uri),
                                  SystemClock.instance(), null));


    for (int i = 0; i < 20; i++)
    {
      cArray.add(i, new TcCallable(clients, _state));
    }


    Runnable refreshTask = new Runnable()
    {
      @Override
      public void run()
      {
        while(true)
        {
          List<String> myStrategyList = new LinkedList<String>();
          myStrategyList.add("degraderV3");
          _state.refreshServiceStrategies(new ServiceProperties("service-1",
                                                                "cluster-1",
                                                                "/test",
                                                                "unusedInThisConstructor",
                                                                myStrategyList,
                                                                Collections.<String, Object>emptyMap(),

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.linkedin.d2.balancer.KeyMapper$TargetHostHints

com.example.d2.client.BigDataClientExample

com.example.d2.client.CacheClientExample

com.example.d2.client.EmailClientExample

com.example.d2.client.ExampleD2Client

com.example.d2.client.ProfileClientExample

com.example.d2.server.ExampleD2Server

com.linkedin.d2.balancer.clients.DynamicClient

com.linkedin.d2.balancer.clients.DynamicClientTest

com.linkedin.d2.balancer.clients.DynamicClientTest$TestLoadBalancer

com.linkedin.d2.balancer.clients.RewriteClientTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.