ambari-logsearch-web/src/app/modules/app-load/services/app-load.service.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 { Injectable } from '@angular/core';
import { Response } from '@angular/http';
import 'rxjs/add/operator/toPromise';
import { TranslateService } from '@ngx-translate/core';

import { AppStateService } from 'app/services/storage/app-state.service';
import { HttpClientService } from 'app/services/http-client.service';
import { ClustersService } from 'app/services/storage/clusters.service';
import { ServiceLogsFieldsService } from 'app/services/storage/service-logs-fields.service';
import { AuditLogsFieldsService } from 'app/services/storage/audit-logs-fields.service';
import { AuditLogsFieldSet, LogField } from 'app/classes/object';
import { Observable } from 'rxjs/Observable';
import { HostsService } from 'app/services/storage/hosts.service';
import { NodeItem } from 'app/classes/models/node-item';
import { ComponentsService } from 'app/services/storage/components.service';
import { DataAvailabilityValues } from 'app/classes/string';
import { DataAvaibilityStatesModel } from '@app/modules/app-load/models/data-availability-state.model';
import { DataAvailabilityStatesStore } from '@app/modules/app-load/stores/data-availability-state.store';

import { Store } from '@ngrx/store';
import { AppStore } from '@app/classes/models/store';
import { isAuthorizedSelector } from '@app/store/selectors/auth.selectors';
import { LoadAuditLogsReposAction } from '@app/store/actions/audit-log-repos.actions';
import { LoadApiFeaturesAction } from '@app/store/actions/api-features.actions';

// @ToDo create a separate data state enrty in the store with keys of the model names
export enum DataStateStoreKeys {
  CLUSTERS_DATA_KEY = 'clustersDataState',
  HOSTS_DATA_KEY = 'hostsDataState',
  COMPONENTS_DATA_KEY = 'componentsDataState',
  LOG_FIELDS_DATA_KEY = 'logFieldsDataState',
  BASE_DATA_SET_KEY = 'baseDataSetState',
};

export const baseDataKeys: DataStateStoreKeys[] = [
  DataStateStoreKeys.CLUSTERS_DATA_KEY,
  DataStateStoreKeys.HOSTS_DATA_KEY,
  DataStateStoreKeys.COMPONENTS_DATA_KEY,
  DataStateStoreKeys.LOG_FIELDS_DATA_KEY
];

@Injectable()
export class AppLoadService {

  baseDataAvailibilityState$: Observable<DataAvailabilityValues>;

  constructor(
    private httpClient: HttpClientService,
    private appStateService: AppStateService,
    private clustersStorage: ClustersService,
    private serviceLogsFieldsService: ServiceLogsFieldsService,
    private auditLogsFieldsService: AuditLogsFieldsService,
    private translationService: TranslateService,
    private hostStoreService: HostsService,
    private componentsStorageService: ComponentsService,
    private dataAvaibilityStateStore: DataAvailabilityStatesStore,
    private store: Store<AppStore>
  ) {
    this.store.select(isAuthorizedSelector).subscribe(this.initOnAuthorization);
    this.appStateService.setParameter('isInitialLoading', true);

    Observable.combineLatest(
      this.appStateService.getParameter(DataStateStoreKeys.CLUSTERS_DATA_KEY),
      this.appStateService.getParameter(DataStateStoreKeys.COMPONENTS_DATA_KEY),
      this.appStateService.getParameter(DataStateStoreKeys.HOSTS_DATA_KEY),
      this.appStateService.getParameter(DataStateStoreKeys.LOG_FIELDS_DATA_KEY)
    ).subscribe(this.onDataAvailibilityChange);

    this.baseDataAvailibilityState$ = this.dataAvaibilityStateStore.getAll()
      .map((dataAvailabilityState: DataAvaibilityStatesModel): DataAvailabilityValues => {

        const values: DataAvailabilityValues[] = Object.keys(dataAvailabilityState)
          .filter((key: DataStateStoreKeys): boolean => baseDataKeys.indexOf(key) > -1)
          .map((key): DataAvailabilityValues => dataAvailabilityState[key]);

        let nextDataState: DataAvailabilityValues = DataAvailabilityValues.NOT_AVAILABLE;

        if (values.indexOf(DataAvailabilityValues.ERROR) > -1) {
          nextDataState = DataAvailabilityValues.ERROR;
        } else if (values.indexOf(DataAvailabilityValues.LOADING) > -1) {
          nextDataState = DataAvailabilityValues.LOADING;
        } else if ( values.filter((value: DataAvailabilityValues) => value !== DataAvailabilityValues.AVAILABLE).length === 0 ) {
          nextDataState = DataAvailabilityValues.AVAILABLE;
        }

        return nextDataState;

      });
      this.baseDataAvailibilityState$.subscribe(this.onBaseDataAvailabilityChange);
      this.loadApiFeaturesInfo();
  }

  onDataAvailibilityChange = (dataAvailabilityStates: DataAvailabilityValues[]): void => {
    const baseDataAvailability: DataAvailabilityValues = dataAvailabilityStates
      .reduce((availabeState, dataState: DataAvailabilityValues): DataAvailabilityValues => {
        if (dataState === DataAvailabilityValues.ERROR || availabeState === DataAvailabilityValues.ERROR) {
          return DataAvailabilityValues.ERROR;
        }
        if (availabeState === DataAvailabilityValues.LOADING || dataState === DataAvailabilityValues.LOADING) {
          return DataAvailabilityValues.LOADING;
        }
        if (availabeState === DataAvailabilityValues.AVAILABLE && dataState === DataAvailabilityValues.AVAILABLE) {
          return DataAvailabilityValues.AVAILABLE;
        }
        return DataAvailabilityValues.NOT_AVAILABLE;
      }, DataAvailabilityValues.AVAILABLE);
  }

  onBaseDataAvailabilityChange = (baseDataAvailibilityState: DataAvailabilityValues): void => {
    this.appStateService.setParameter(DataStateStoreKeys.BASE_DATA_SET_KEY, baseDataAvailibilityState);
  }

  private setDataAvaibility(dataKey: string, availabilityState: DataAvailabilityValues) {
    this.dataAvaibilityStateStore.setParameter(dataKey, availabilityState);
  }

  loadClusters(): Observable<Response> {
    this.clustersStorage.clear();
    this.setDataAvaibility(DataStateStoreKeys.CLUSTERS_DATA_KEY, DataAvailabilityValues.LOADING);
    const response$: Observable<Response> = this.httpClient.get('clusters').filter((response: Response) => response.ok).first();
    response$.subscribe(
      (response: Response) => {
        const clusterNames = response.json();
        if (clusterNames) {
          this.clustersStorage.addInstances(clusterNames);
          this.setDataAvaibility(DataStateStoreKeys.CLUSTERS_DATA_KEY, DataAvailabilityValues.AVAILABLE);
        }
      },
      (errorResponse: Response) => {
        this.clustersStorage.addInstances([]);
        this.setDataAvaibility(DataStateStoreKeys.CLUSTERS_DATA_KEY, DataAvailabilityValues.ERROR);
      }
    );
    return response$;
  }

  clearClusters(): void {
    this.clustersStorage.clear();
  }

  loadHosts(): Observable<Response> {
    this.hostStoreService.clear();
    this.setDataAvaibility(DataStateStoreKeys.HOSTS_DATA_KEY, DataAvailabilityValues.LOADING);
    const response$ = this.httpClient.get('hosts').filter((response: Response) => response.ok);
    response$.subscribe((response: Response): void => {
      const jsonResponse = response.json(),
        hosts = jsonResponse && jsonResponse.vNodeList;
      if (hosts) {
        this.hostStoreService.addInstances(hosts);
        this.setDataAvaibility(DataStateStoreKeys.HOSTS_DATA_KEY, DataAvailabilityValues.AVAILABLE);
      }
    }, () => {
      this.hostStoreService.addInstances([]);
      this.setDataAvaibility(DataStateStoreKeys.HOSTS_DATA_KEY, DataAvailabilityValues.ERROR);
    });
    return response$;
  }

  clearHosts(): void {
    this.hostStoreService.clear();
  }

  loadServiceLogsComponents(): Observable<[{[key: string]: any}, {[key: string]: any}]> {
    this.setDataAvaibility(DataStateStoreKeys.COMPONENTS_DATA_KEY, DataAvailabilityValues.LOADING);
    const responseComponentsData$: Observable<Response> = this.httpClient.get('components').first()
      .filter((response: Response) => response.ok)
      .map((response: Response) => response.json());
    const responseComponentsName$: Observable<Response> = this.httpClient.get('serviceComponentsName').first()
      .filter((response: Response) => response.ok)
      .map((response: Response) => response.json());
    const responses$ = Observable.combineLatest(responseComponentsName$, responseComponentsData$);
    responses$.subscribe(([componentsNames, componentsData]: [{[key: string]: any}, {[key: string]: any}]) => {
      const components = componentsData && componentsData.vNodeList && componentsData.vNodeList.map((item): NodeItem => {
        const component = componentsNames.metadata.find(componentItem => componentItem.name === item.name);
        return Object.assign(item, {
          label: component && (component.label || item.name),
          group: component && component.group && {
            name: component.group,
            label: componentsNames.groups[component.group]
          },
          value: item.logLevelCount.reduce((currentValue: number, currentItem): number => {
            return currentValue + Number(currentItem.value);
          }, 0)
        });
      });
      if (components) {
        this.componentsStorageService.addInstances(components);
        this.setDataAvaibility(DataStateStoreKeys.COMPONENTS_DATA_KEY, DataAvailabilityValues.AVAILABLE);
      }
    });
    return responses$;
  }

  loadAuditLogsComponents() {
    this.store.dispatch(new LoadAuditLogsReposAction());
  }

  clearComponents(): void {
    this.componentsStorageService.clear();
  }

  loadFieldsForLogs(): Observable<[LogField[], AuditLogsFieldSet]> {
    this.setDataAvaibility(DataStateStoreKeys.LOG_FIELDS_DATA_KEY, DataAvailabilityValues.LOADING);
    const serviceLogsFieldsResponse$: Observable<LogField[]> = this.httpClient.get('serviceLogsFields')
      .filter((response: Response) => response.ok)
      .map((response: Response) => {
        return response.json();
      });
    const auditLogsFieldsResponse$: Observable<AuditLogsFieldSet> = this.httpClient.get('auditLogsFields')
      .filter((response: Response) => response.ok)
      .map((response: Response) => {
        return response.json();
      });
    const responses$: Observable<[LogField[], AuditLogsFieldSet]> = Observable.combineLatest(
      serviceLogsFieldsResponse$, auditLogsFieldsResponse$
    );
    responses$.subscribe(([serviceLogsFieldsResponse, auditLogsFieldsResponse]: [LogField[], AuditLogsFieldSet]) => {
      this.serviceLogsFieldsService.addInstances(serviceLogsFieldsResponse);
      this.auditLogsFieldsService.setParameters(auditLogsFieldsResponse);
      this.setDataAvaibility(DataStateStoreKeys.LOG_FIELDS_DATA_KEY, DataAvailabilityValues.AVAILABLE);
    });
    return responses$;
  }

  loadApiFeaturesInfo() {
    this.store.dispatch( new LoadApiFeaturesAction() );
  }

  initOnAuthorization = (isAuthorized): void => {
    if (isAuthorized) {
        this.loadClusters();
        this.loadHosts();
        this.loadServiceLogsComponents();
        this.loadAuditLogsComponents();
        this.loadFieldsForLogs();
    } else {
      this.clearClusters();
      this.clearHosts();
      this.clearComponents();
    }
  }

  syncAuthorizedStateWithBackend(): Promise<any> {
    const setAuthorization = (isAuthorized: boolean) => {
      this.appStateService.setParameters({
        isAuthorized,
        isInitialLoading: false
      });
    };
    return this.httpClient.get('status').toPromise()
      .then(
        (response: Response) => setAuthorization(response.ok),
        (response: Response) => setAuthorization(false)
      );
  }

  setTranslationService() {
    this.translationService.setDefaultLang('en');
    return this.translationService.use('en').toPromise();
  }

}