package com.linkedin.databus.bootstrap.common;
/*
*
* Copyright 2013 LinkedIn Corp. All rights reserved
*
* Licensed 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.
*
*/
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import com.linkedin.databus.bootstrap.common.BootstrapCleanerStaticConfig.BootstrapDBType;
import com.linkedin.databus.bootstrap.common.BootstrapCleanerStaticConfig.DiskSpaceTriggerConfig;
import com.linkedin.databus.bootstrap.common.BootstrapCleanerStaticConfig.PeriodicTriggerConfig;
import com.linkedin.databus.bootstrap.common.BootstrapCleanerStaticConfig.RetentionStaticConfig;
import com.linkedin.databus.bootstrap.common.BootstrapCleanerStaticConfig.RetentionType;
import com.linkedin.databus.core.util.ConfigBuilder;
import com.linkedin.databus.core.util.InvalidConfigException;
public class BootstrapCleanerConfig
implements ConfigBuilder<BootstrapCleanerStaticConfig>
{
private boolean enable;
private Map<String,RetentionConfig> retentionOverride;
private RetentionConfig retentionDefault;
private Map<String,String> bootstrapTypeOverride;
private String bootstrapTypeDefault;
private Map<String, Boolean> enableOptimizeTable;
private Boolean enableOptimizeTableDefault;
private Map<String, Boolean> enableForceTabTableCleanup;
private Boolean enableForceTabTableCleanupDefault;
private DiskSpaceTriggerConfigBuilder diskSpaceTrigger;
private PeriodicTriggerConfigBuilder periodicTrigger;
public BootstrapCleanerConfig()
{
retentionOverride = new HashMap<String, RetentionConfig>();
retentionDefault = new RetentionConfig();
bootstrapTypeOverride = new HashMap<String, String>();
bootstrapTypeDefault = BootstrapDBType.BOOTSTRAP_FULL.toString();
enable = true;
enableOptimizeTable = new HashMap<String, Boolean>();
enableOptimizeTableDefault = Boolean.FALSE;
enableForceTabTableCleanup = new HashMap<String, Boolean>();
enableForceTabTableCleanupDefault = Boolean.FALSE;
diskSpaceTrigger = new DiskSpaceTriggerConfigBuilder();
periodicTrigger = new PeriodicTriggerConfigBuilder();
}
@Override
public BootstrapCleanerStaticConfig build() throws InvalidConfigException
{
Map<String, RetentionStaticConfig> retOverrides = new HashMap<String, RetentionStaticConfig>();
for (Entry<String, RetentionConfig> e : retentionOverride.entrySet())
{
retOverrides.put(e.getKey(), e.getValue().build());
}
Map<String, BootstrapDBType> bsTypeOverrides = new HashMap<String, BootstrapDBType>();
for (Entry<String, String> e : bootstrapTypeOverride.entrySet())
{
bsTypeOverrides.put(e.getKey(), BootstrapDBType.valueOf(e.getValue()));
}
return new BootstrapCleanerStaticConfig(retOverrides,
retentionDefault.build(),
bsTypeOverrides,
BootstrapDBType.valueOf(bootstrapTypeDefault),
enableOptimizeTable,
enableOptimizeTableDefault,
enableForceTabTableCleanup,
enableForceTabTableCleanupDefault,
enable,
diskSpaceTrigger.build(),
periodicTrigger.build());
}
public RetentionConfig getRetentionOverride(String source)
{
RetentionConfig r = retentionOverride.get(source);
if (null == r)
{
r = new RetentionConfig();
retentionOverride.put(source, r);
}
return r;
}
public Boolean getEnableOptimizeTable(String source)
{
return enableOptimizeTable.get(source);
}
public void setEnableOptimizeTable(String source, Boolean enable)
{
this.enableOptimizeTable.put(source, enable);
}
public Boolean getEnableOptimizeTableDefault()
{
return enableOptimizeTableDefault;
}
public void setEnableOptimizeTableDefault(Boolean enable)
{
this.enableOptimizeTableDefault = enable;
}
public Boolean getEnableForceTabTableCleanup(String source)
{
return enableForceTabTableCleanup.get(source);
}
public void setEnableForceTabTableCleanup(String source, Boolean enable)
{
this.enableForceTabTableCleanup.put(source, enable);
}
public Boolean getEnableForceTabTableCleanupDefault()
{
return enableForceTabTableCleanupDefault;
}
public void setEnableForceTabTableCleanupDefault(Boolean enable)
{
this.enableForceTabTableCleanupDefault = enable;
}
public String getBootstrapTypeOverride(String source)
{
return bootstrapTypeOverride.get(source);
}
public void setBootstrapTypeOverride(String source, String bootstrapTypeOverride)
{
this.bootstrapTypeOverride.put(source, bootstrapTypeOverride);
}
public void setRetentionOverride(String source, RetentionConfig retentionOverride)
{
this.retentionOverride.put(source, retentionOverride);
}
public RetentionConfig getRetentionDefault()
{
return retentionDefault;
}
public void setRetentionDefault(RetentionConfig retentionDefault)
{
this.retentionDefault = retentionDefault;
}
public String getBootstrapTypeDefault()
{
return bootstrapTypeDefault;
}
public void setBootstrapTypeDefault(String bootstrapTypeDefault)
{
this.bootstrapTypeDefault = bootstrapTypeDefault;
}
public boolean getEnable()
{
return enable;
}
public void setEnable(boolean e)
{
enable = e;
}
public PeriodicTriggerConfigBuilder getPeriodicTrigger() {
return periodicTrigger;
}
public void setPeriodicTrigger(PeriodicTriggerConfigBuilder periodicTrigger) {
this.periodicTrigger = periodicTrigger;
}
public DiskSpaceTriggerConfigBuilder getDiskSpaceTrigger() {
return diskSpaceTrigger;
}
public void setDiskSpaceTrigger(DiskSpaceTriggerConfigBuilder diskSpaceTrigger) {
this.diskSpaceTrigger = diskSpaceTrigger;
}
public static class RetentionConfig implements ConfigBuilder<RetentionStaticConfig>
{
private static final String DEFAULT_RETENTION_TYPE = RetentionType.RETENTION_SECONDS.toString();
private static final long DEFAULT_RETENTION_QTY = 14 * 24 * 60 * 60; // 2 weeks
private String retentionType;
private long retentionQuantity;
public RetentionConfig()
{
retentionType = DEFAULT_RETENTION_TYPE;
retentionQuantity = DEFAULT_RETENTION_QTY;
}
public String getRetentionType() {
return retentionType;
}
public void setRetentionType(String retentionType) {
this.retentionType = retentionType;
}
public long getRetentionQuantity() {
return retentionQuantity;
}
public void setRetentionQuantity(long retentionQuantity) {
this.retentionQuantity = retentionQuantity;
}
@Override
public RetentionStaticConfig build() throws InvalidConfigException
{
try
{
RetentionType type = RetentionType.valueOf(retentionType);
return new RetentionStaticConfig(type, retentionQuantity);
} catch (Exception ex) {
throw new InvalidConfigException(ex);
}
}
}
public static class DiskSpaceTriggerConfigBuilder
implements ConfigBuilder<DiskSpaceTriggerConfig>
{
public static final double DEFAULT_AVAILABLE_THRESHOLD_PERCENT = 25.0;
public static final boolean DEFAULT_ENABLE = true;
public static final long DEFAULT_RUN_INTERVAL_SECONDS = 3600; //every hour
public static final String DEFAULT_BOOTSTRAP_DB_DRIVE = "/mnt/u001";
private boolean enable;
private long runIntervalSeconds;
private double availableThresholdPercent;
private String bootstrapDBDrive;
public DiskSpaceTriggerConfigBuilder()
{
enable = DEFAULT_ENABLE;
runIntervalSeconds = DEFAULT_RUN_INTERVAL_SECONDS;
availableThresholdPercent = DEFAULT_AVAILABLE_THRESHOLD_PERCENT;
bootstrapDBDrive = DEFAULT_BOOTSTRAP_DB_DRIVE;
}
public boolean getEnable() {
return enable;
}
public void setEnable(boolean enable) {
this.enable = enable;
}
public long getRunIntervalSeconds() {
return runIntervalSeconds;
}
public void setRunIntervalSeconds(long runIntervalSeconds) {
this.runIntervalSeconds = runIntervalSeconds;
}
public double getAvailableThresholdPercent() {
return availableThresholdPercent;
}
public void setAvailableThresholdPercent(double availableThresholdPercent) {
this.availableThresholdPercent = availableThresholdPercent;
}
@Override
public DiskSpaceTriggerConfig build()
throws InvalidConfigException
{
if (availableThresholdPercent > 100 ||
availableThresholdPercent < 0)
throw new InvalidConfigException("availableThresholdPercent must be between 0-100");
return new DiskSpaceTriggerConfig(enable, runIntervalSeconds, availableThresholdPercent, bootstrapDBDrive);
}
public String getBootstrapDBDrive() {
return bootstrapDBDrive;
}
public void setBootstrapDBDrive(String bootstrapDBDrive) {
this.bootstrapDBDrive = bootstrapDBDrive;
}
}
public static class PeriodicTriggerConfigBuilder
implements ConfigBuilder<PeriodicTriggerConfig>
{
public static final long DEFAULT_RUN_INTERVAL_SECONDS = 6 * 60 * 60; //4x per day
private long runIntervalSeconds;
private boolean enable;
private boolean runOnStart;
public PeriodicTriggerConfigBuilder()
{
runIntervalSeconds = DEFAULT_RUN_INTERVAL_SECONDS;
enable = true;
runOnStart = false;
}
public long getRunIntervalSeconds() {
return runIntervalSeconds;
}
public void setRunIntervalSeconds(long runIntervalSeconds) {
this.runIntervalSeconds = runIntervalSeconds;
}
public boolean getEnable() {
return enable;
}
public void setEnable(boolean enable) {
this.enable = enable;
}
public boolean isRunOnStart() {
return runOnStart;
}
public void setRunOnStart(boolean runOnStart) {
this.runOnStart = runOnStart;
}
@Override
public PeriodicTriggerConfig build()
throws InvalidConfigException
{
return new PeriodicTriggerConfig(runIntervalSeconds, enable, runOnStart);
}
}
}