Package org.apache.helix.controller.rebalancer.context

Examples of org.apache.helix.controller.rebalancer.context.RebalancerConfig


   */
  private boolean setConfiguration(ResourceId resourceId, ResourceConfiguration configuration) {
    boolean status =
        _accessor.setProperty(_keyBuilder.resourceConfig(resourceId.stringify()), configuration);
    // also set an ideal state if the resource supports it
    RebalancerConfig rebalancerConfig = new RebalancerConfig(configuration);
    IdealState idealState =
        rebalancerConfigToIdealState(rebalancerConfig, configuration.getBucketSize(),
            configuration.getBatchMessageMode());
    if (idealState != null) {
      _accessor.setProperty(_keyBuilder.idealStates(resourceId.stringify()), idealState);
View Full Code Here


   * @param resourceId the resource to update
   * @param context the new rebalancer context
   * @return true if the context was set, false otherwise
   */
  public boolean setRebalancerContext(ResourceId resourceId, RebalancerContext context) {
    RebalancerConfig config = new RebalancerConfig(context);
    ResourceConfiguration resourceConfig = new ResourceConfiguration(resourceId);
    resourceConfig.addNamespacedConfig(config.toNamespacedConfig());

    // update the ideal state if applicable
    IdealState oldIdealState =
        _accessor.getProperty(_keyBuilder.idealStates(resourceId.stringify()));
    if (oldIdealState != null) {
View Full Code Here

   * @return true if assignment successful, false otherwise
   */
  public boolean generateDefaultAssignment(ResourceId resourceId, int replicaCount,
      String participantGroupTag) {
    Resource resource = readResource(resourceId);
    RebalancerConfig config = resource.getRebalancerConfig();
    PartitionedRebalancerContext context =
        config.getRebalancerContext(PartitionedRebalancerContext.class);
    if (context == null) {
      LOG.error("Only partitioned resource types are supported");
      return false;
    }
    if (replicaCount != -1) {
View Full Code Here

      batchMessageMode = idealState.getBatchMessageMode();
      idealState.updateUserConfig(userConfig);
    } else if (resourceConfiguration != null) {
      bucketSize = resourceConfiguration.getBucketSize();
      batchMessageMode = resourceConfiguration.getBatchMessageMode();
      RebalancerConfig rebalancerConfig = new RebalancerConfig(resourceConfiguration);
      rebalancerContext = rebalancerConfig.getRebalancerContext(RebalancerContext.class);
    }
    if (rebalancerContext == null) {
      rebalancerContext = new PartitionedRebalancerContext();
    }
    return new Resource(resourceId, type, idealState, resourceAssignment, externalView,
View Full Code Here

  /**
   * Get a RebalancerContext if available
   * @return RebalancerContext, or null
   */
  public RebalancerContext getRebalancerContext(Class<? extends RebalancerContext> clazz) {
    RebalancerConfig config = new RebalancerConfig(this);
    return config.getRebalancerContext(clazz);
  }
View Full Code Here

  public Resource(ResourceId id, ResourceType type, IdealState idealState,
      ResourceAssignment resourceAssignment, ExternalView externalView,
      RebalancerContext rebalancerContext, UserConfig userConfig, int bucketSize,
      boolean batchMessageMode) {
    SchedulerTaskConfig schedulerTaskConfig = schedulerTaskConfig(idealState);
    RebalancerConfig rebalancerConfig = new RebalancerConfig(rebalancerContext);

    _config =
        new ResourceConfig(id, type, schedulerTaskConfig, rebalancerConfig, userConfig, bucketSize,
            batchMessageMode);
    _externalView = externalView;
View Full Code Here

     * Set the rebalancer configuration
     * @param rebalancerContext properties of interest for rebalancing
     * @return Builder
     */
    public Builder rebalancerContext(RebalancerContext rebalancerContext) {
      _rebalancerConfig = new RebalancerConfig(rebalancerContext);
      return this;
    }
View Full Code Here

      configuration.setBatchMessageMode(resource.getBatchMessageMode());
      _accessor.setProperty(_keyBuilder.resourceConfig(resourceId.stringify()), configuration);
    }

    // Create an IdealState from a RebalancerConfig (if the resource is partitioned)
    RebalancerConfig rebalancerConfig = resource.getRebalancerConfig();
    IdealState idealState =
        ResourceAccessor.rebalancerConfigToIdealState(rebalancerConfig, resource.getBucketSize(),
            resource.getBatchMessageMode());
    if (idealState != null) {
      _accessor.setProperty(_keyBuilder.idealStates(resourceId.stringify()), idealState);
View Full Code Here

      ExternalView view = new ExternalView(resourceId.stringify());
      // view.setBucketSize(currentStateOutput.getBucketSize(resourceName));
      // if resource ideal state has bucket size, set it
      // otherwise resource has been dropped, use bucket size from current state instead
      ResourceConfig resource = resourceMap.get(resourceId);
      RebalancerConfig rebalancerConfig = resource.getRebalancerConfig();
      SchedulerTaskConfig schedulerTaskConfig = resource.getSchedulerTaskConfig();

      if (resource.getBucketSize() > 0) {
        view.setBucketSize(resource.getBucketSize());
      } else {
        view.setBucketSize(currentStateOutput.getBucketSize(resourceId));
      }
      for (PartitionId partitionId : resource.getSubUnitMap().keySet()) {
        Map<ParticipantId, State> currentStateMap =
            currentStateOutput.getCurrentStateMap(resourceId, partitionId);
        if (currentStateMap != null && currentStateMap.size() > 0) {
          // Set<String> disabledInstances
          // = cache.getDisabledInstancesForResource(resource.toString());
          for (ParticipantId participantId : currentStateMap.keySet()) {
            // if (!disabledInstances.contains(instance))
            // {
            view.setState(partitionId.stringify(), participantId.stringify(),
                currentStateMap.get(participantId).toString());
            // }
          }
        }
      }

      // TODO fix this
      // Update cluster status monitor mbean
      // ClusterStatusMonitor clusterStatusMonitor =
      // (ClusterStatusMonitor) event.getAttribute("clusterStatusMonitor");
      // IdealState idealState = cache._idealStateMap.get(view.getResourceName());
      // if (idealState != null) {
      // if (clusterStatusMonitor != null
      // && !idealState.getStateModelDefRef().equalsIgnoreCase(
      // DefaultSchedulerMessageHandlerFactory.SCHEDULER_TASK_QUEUE)) {
      // clusterStatusMonitor.onExternalViewChange(view,
      // cache._idealStateMap.get(view.getResourceName()));
      // }
      // }

      // compare the new external view with current one, set only on different
      ExternalView curExtView = curExtViews.get(resourceId.stringify());
      if (curExtView == null || !curExtView.getRecord().equals(view.getRecord())) {
        keys.add(keyBuilder.externalView(resourceId.stringify()));
        newExtViews.add(view);

        // For SCHEDULER_TASK_RESOURCE resource group (helix task queue), we need to find out which
        // task
        // partitions are finished (COMPLETED or ERROR), update the status update of the original
        // scheduler
        // message, and then remove the partitions from the ideal state
        RebalancerContext rebalancerContext =
            (rebalancerConfig != null) ? rebalancerConfig
                .getRebalancerContext(RebalancerContext.class) : null;
        if (rebalancerContext != null
            && rebalancerContext.getStateModelDefId().equalsIgnoreCase(
                StateModelDefId.SchedulerTaskQueue)) {
          updateScheduledTaskStatus(resourceId, view, manager, schedulerTaskConfig);
View Full Code Here

    for (ResourceId resourceId : resourceMap.keySet()) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Processing resource:" + resourceId);
      }
      ResourceConfig resourceConfig = resourceMap.get(resourceId);
      RebalancerConfig rebalancerConfig = resourceConfig.getRebalancerConfig();
      RebalancerContext context = rebalancerConfig.getRebalancerContext(RebalancerContext.class);
      StateModelDefinition stateModelDef = stateModelDefs.get(context.getStateModelDefId());
      ResourceAssignment resourceAssignment = null;
      if (rebalancerConfig != null) {
        HelixRebalancer rebalancer = rebalancerConfig.getRebalancer();
        HelixManager manager = event.getAttribute("helixmanager");
        if (rebalancer == null) {
          rebalancer = new FallbackRebalancer();
        }
        rebalancer.init(manager);
View Full Code Here

TOP

Related Classes of org.apache.helix.controller.rebalancer.context.RebalancerConfig

Copyright © 2018 www.massapicom. All rights reserved.
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.