web-console/src/utils/load-rule.ts

/*
 * 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.
 */

import { deepMove, deepSet } from './object-change';

export type RuleType =
  | 'loadForever'
  | 'loadByInterval'
  | 'loadByPeriod'
  | 'dropForever'
  | 'dropByInterval'
  | 'dropByPeriod'
  | 'dropBeforeByPeriod'
  | 'broadcastForever'
  | 'broadcastByInterval'
  | 'broadcastByPeriod';

export interface Rule {
  type: RuleType;
  interval?: string;
  period?: string;
  includeFuture?: boolean;
  tieredReplicants?: Record<string, number>;
}

export class RuleUtil {
  static TYPES: RuleType[] = [
    'loadForever',
    'loadByInterval',
    'loadByPeriod',
    'dropForever',
    'dropByInterval',
    'dropByPeriod',
    'dropBeforeByPeriod',
    'broadcastForever',
    'broadcastByInterval',
    'broadcastByPeriod',
  ];

  static ruleToString(rule: Rule): string {
    return [
      rule.type,
      rule.period ? `(${rule.period}${rule.includeFuture ? `+future` : ''})` : '',
      rule.interval ? `(${rule.interval})` : '',
    ].join('');
  }

  static changeRuleType(rule: Rule, type: RuleType): Rule {
    const newRule = deepSet(rule, 'type', type);

    if (RuleUtil.hasPeriod(newRule)) {
      if (!newRule.period) newRule.period = 'P1M';
    } else {
      delete newRule.period;
      delete newRule.includeFuture;
    }

    if (RuleUtil.hasInterval(newRule)) {
      if (!newRule.interval) newRule.interval = '2010-01-01/2020-01-01';
    } else {
      delete newRule.interval;
    }

    if (RuleUtil.hasTieredReplicants(newRule)) {
      if (!newRule.tieredReplicants) newRule.tieredReplicants = { _default_tier: 2 };
    } else {
      delete newRule.tieredReplicants;
    }

    return newRule;
  }

  static hasPeriod(rule: Rule): boolean {
    return rule.type.endsWith('ByPeriod');
  }

  static changePeriod(rule: Rule, period: string): Rule {
    return deepSet(rule, 'period', period);
  }

  static hasIncludeFuture(rule: Rule): boolean {
    return RuleUtil.hasPeriod(rule) && rule.type !== 'dropBeforeByPeriod';
  }

  static changeIncludeFuture(rule: Rule, includeFuture: boolean): Rule {
    return deepSet(rule, 'includeFuture', includeFuture);
  }

  static hasInterval(rule: Rule): boolean {
    return rule.type.endsWith('ByInterval');
  }

  static changeInterval(rule: Rule, interval: string): Rule {
    return deepSet(rule, 'interval', interval);
  }

  static hasTieredReplicants(rule: Rule): boolean {
    return rule.type.startsWith('load');
  }

  static renameTieredReplicants(rule: Rule, oldTier: string, newTier: string): Rule {
    return deepMove(rule, `tieredReplicants.${oldTier}`, `tieredReplicants.${newTier}`);
  }

  static addTieredReplicant(rule: Rule, tier: string, replication: number): Rule {
    const newTieredReplicants = deepSet(rule.tieredReplicants || {}, tier, replication);
    return deepSet(rule, 'tieredReplicants', newTieredReplicants);
  }
}