Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.helix.controller.rebalancer.context;
  
  
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

Configuration for a resource rebalancer. This contains a RebalancerContext, which contains information specific to each rebalancer.
 
 public final class RebalancerConfig {
   private enum Fields {
     SERIALIZER_CLASS,
     REBALANCER_CONTEXT,
     REBALANCER_CONTEXT_CLASS
   }
 
   private static final Logger LOG = Logger.getLogger(RebalancerConfig.class);
   private final RebalancerContext _context;
   private final NamespacedConfig _config;

  
Instantiate a RebalancerConfig

Parameters:
context rebalancer context
rebalancerRef reference to the rebalancer class that will be used
 
   public RebalancerConfig(RebalancerContext context) {
      =
         new NamespacedConfig(Scope.resource(context.getResourceId()),
             RebalancerConfig.class.getSimpleName());
         .getName());
     
      = context;
     try {
        = context.getSerializerClass().newInstance();
     } catch (InstantiationException e) {
       .error("Error initializing the configuration"e);
     } catch (IllegalAccessException e) {
       .error("Error initializing the configuration"e);
     }
   }

  
Instantiate from a physical ResourceConfiguration

Parameters:
resourceConfiguration populated ResourceConfiguration
 
   public RebalancerConfig(ResourceConfiguration resourceConfiguration) {
      = new NamespacedConfig(resourceConfigurationRebalancerConfig.class.getSimpleName());
      = getSerializer();
      = getContext();
   }

  
Get the class that can serialize and deserialize the rebalancer context

Returns:
ContextSerializer
 
   private ContextSerializer getSerializer() {
     String serializerClassName = .getSimpleField(..toString());
     if (serializerClassName != null) {
       try {
         return (ContextSerializer) HelixUtil.loadClass(getClass(), serializerClassName)
             .newInstance();
       } catch (InstantiationException e) {
         .error("Error getting the serializer"e);
       } catch (IllegalAccessException e) {
         .error("Error getting the serializer"e);
       } catch (ClassNotFoundException e) {
         .error("Error getting the serializer"e);
       }
     }
     return null;
   }
  private RebalancerContext getContext() {
    if (className != null) {
      try {
        Class<? extends RebalancerContextcontextClass =
            HelixUtil.loadClass(getClass(), className).asSubclass(RebalancerContext.class);
        return .deserialize(contextClassserialized);
      } catch (ClassNotFoundException e) {
        .error(className + " is not a valid class");
      } catch (ClassCastException e) {
        .error(className + " does not implement RebalancerContext");
      }
    }
    return null;
  }

  
Get a rebalancer class instance

Returns:
Rebalancer
    // cache the rebalancer to avoid loading and instantiating it excessively
    if ( == null) {
      if ( == null || .getRebalancerRef() == null) {
        return null;
      }
    }
    return ;
  }

  
Get the instantiated RebalancerContext

Parameters:
contextClass specific class of the RebalancerContext
Returns:
RebalancerContext subclass instance, or null if conversion is not possible
  public <T extends RebalancerContext> T getRebalancerContext(Class<T> contextClass) {
    if ( != null) {
      try {
        return contextClass.cast();
      } catch (ClassCastException e) {
        .warn(contextClass + " is incompatible with context class: " + .getClass());
      }
    }
    return null;
  }

  
Get the rebalancer context serialized as a string

Returns:
string representing the context
  }

  
Convert this to a namespaced config

Returns:
NamespacedConfig
    return ;
  }

  
Get a RebalancerConfig from a physical resource config

Parameters:
resourceConfiguration physical resource config
Returns:
RebalancerConfig
  public static RebalancerConfig from(ResourceConfiguration resourceConfiguration) {
    return new RebalancerConfig(resourceConfiguration);
  }

  
Get a RebalancerConfig from a RebalancerContext

Parameters:
context instantiated RebalancerContext
Returns:
RebalancerConfig
  public static RebalancerConfig from(RebalancerContext context) {
    return new RebalancerConfig(context);
  }
New to GrepCode? Check out our FAQ X