vdb.service.ts

/**
 * @license
 * Copyright 2017 JBoss Inc
 *
 * 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 { Injectable } from "@angular/core";
import { Http } from "@angular/http";
import { Connection } from "@connections/shared/connection.model";
import { ApiService } from "@core/api.service";
import { AppSettingsService } from "@core/app-settings.service";
import { LoggerService } from "@core/logger.service";
import { NameValue } from "@dataservices/shared/name-value.model";
import { NotifierService } from "@dataservices/shared/notifier.service";
import { Table } from "@dataservices/shared/table.model";
import { VdbModelSource } from "@dataservices/shared/vdb-model-source.model";
import { VdbModel } from "@dataservices/shared/vdb-model.model";
import { VdbStatus } from "@dataservices/shared/vdb-status.model";
import { Vdb } from "@dataservices/shared/vdb.model";
import { VdbsConstants } from "@dataservices/shared/vdbs-constants";
import { environment } from "@environments/environment";
import { Observable } from "rxjs/Rx";
import { Subscription } from "rxjs/Subscription";

@Injectable()
/**
 * VdbService
 */
export class VdbService extends ApiService {

  private http: Http;
  private deploymentSubscription: Subscription;
  private notifierService: NotifierService;

  constructor(http: Http, appSettings: AppSettingsService,
              notifierService: NotifierService, logger: LoggerService ) {
    super( appSettings, logger  );
    this.http = http;
    this.notifierService = notifierService;
  }

  /**
   * Get the vdbs from the komodo rest interface
   * @returns {Observable<Vdb[]>}
   */
  public getVdbs(): Observable<Vdb[]> {
    return this.http
      .get(environment.komodoWorkspaceUrl + VdbsConstants.vdbsRootPath, this.getAuthRequestOptions())
      .map((response) => {
        const vdbs = response.json();
        return vdbs.map((vdb) => Vdb.create( vdb ));
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Determine if the workspace has a vdb with the supplied name
   * @param {string} vdbName the name of the VDB
   * @returns {Observable<Vdb[]>}
   */
  public hasWorkspaceVdb(vdbName: string): Observable<boolean> {
    return this.http
      .get(environment.komodoWorkspaceUrl + VdbsConstants.vdbsRootPath, this.getAuthRequestOptions())
      .map((response) => {
        const vdbs = response.json();
        // Determine if the vdbName exists in the list
        let vdbFound = false;
        for (const vdb of vdbs) {
          const name = vdb.keng__id;
          if (name === vdbName) {
            vdbFound = true;
            break;
          }
        }
        if (vdbFound) {
          return response.ok;
        }
        return !response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Get the vdbs from the komodo rest interface
   * @returns {Observable<Vdb[]>}
   */
  public getTeiidVdbStatuses(): Observable<VdbStatus[]> {
    return this.http
      .get(environment.komodoTeiidUrl + VdbsConstants.statusPath + VdbsConstants.vdbsRootPath, this.getAuthRequestOptions())
      .map((response) => {
        const vdbStatuses = response.json();
        return vdbStatuses.vdbs.map((vdbStatus) => VdbStatus.create( vdbStatus ));
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Create a vdb via the komodo rest interface
   * @param {Vdb} vdb
   * @returns {Observable<boolean>}
   */
  public createVdb(vdb: Vdb): Observable<boolean> {
    return this.http
      .post(environment.komodoWorkspaceUrl + VdbsConstants.vdbsRootPath + "/" + vdb.getId(),
        vdb, this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Create a vdb via the komodo rest interface
   * @param {string} vdbName
   * @param {VdbModel} vdbModel
   * @returns {Observable<boolean>}
   */
  public createVdbModel(vdbName: string, vdbModel: VdbModel): Observable<boolean> {
    const str = JSON.stringify(vdbModel);
    return this.http
      .post(environment.komodoWorkspaceUrl + VdbsConstants.vdbsRootPath + "/" + vdbName
                                               + VdbsConstants.vdbModelsRootPath + "/" + vdbModel.getId(),
        str, this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Create a vdbModelSource via the komodo rest interface
   * @param {string} vdbName the vdb name
   * @param {string} modelName the model name
   * @param {VdbModelSource} vdbModelSource the modelsource name
   * @returns {Observable<boolean>}
   */
  public createVdbModelSource(vdbName: string, modelName: string, vdbModelSource: VdbModelSource): Observable<boolean> {
    return this.http
      .post(environment.komodoWorkspaceUrl + VdbsConstants.vdbsRootPath + "/" + vdbName
                                               + VdbsConstants.vdbModelsRootPath + "/" + modelName
                                               + VdbsConstants.vdbModelSourcesRootPath + "/" + vdbModelSource.getId(),
        vdbModelSource, this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Delete a vdb via the komodo rest interface
   * @param {string} vdbId
   * @returns {Observable<boolean>}
   */
  public deleteVdb(vdbId: string): Observable<boolean> {
    return this.http
      .delete(environment.komodoWorkspaceUrl + VdbsConstants.vdbsRootPath + "/" + vdbId,
               this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Deploys the workspace VDB with the provided name
   * @param {string} vdbName
   * @returns {Observable<boolean>}
   */
  public deployVdb(vdbName: string): Observable<boolean> {
    const vdbPath = this.getKomodoUserWorkspacePath() + "/" + vdbName;
    return this.http
      .post(environment.komodoTeiidUrl + VdbsConstants.vdbRootPath,
        { path: vdbPath}, this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Undeploy a vdb from the teiid server
   * @param {string} vdbId
   * @returns {Observable<boolean>}
   */
  public undeployVdb(vdbId: string): Observable<boolean> {
    return this.http
      .delete(environment.komodoTeiidUrl + VdbsConstants.vdbsRootPath + "/" + vdbId,
        this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Update the specified repo VDB Model using the DDL from the specified Teiid VDB
   * @param {string} vdbName the VDB in the repo to update
   * @param {string} modelName the Model withing the specified repo VDB
   * @param {string} teiidVdbName the deployed teiid VDB name
   * @param {string} teiidModelName the teiid VDB Model name
   * @returns {Observable<boolean>}
   */
  public updateVdbModelFromTeiid(vdbName: string, modelName: string,
                                 teiidVdbName: string, teiidModelName: string): Observable<boolean> {
    return this.http
      .post(environment.komodoTeiidUrl + VdbsConstants.vdbsRootPath + "/ModelFromTeiidDdl",
        { vdbName, modelName, teiidVdbName, teiidModelName }, this.getAuthRequestOptions())
      .map((response) => {
        return response.ok;
      })
      .catch( ( error ) => this.handleError( error ) );
  }

  /**
   * Polls the server for the specified VDB.  Polling will terminate if
   * (1) The VDB is active
   * (2) The VDB is in a failed state
   * (3) The polling duration has lapsed
   * @param {string} vdbName the name of the VDB
   * @param {number} pollDurationSec the duration (sec) to poll the server
   * @param {number} pollIntervalSec the interval (sec) between polling attempts
   */
  public pollForActiveVdb(vdbName: string, pollDurationSec: number, pollIntervalSec: number): void {
    const pollIntervalMillis = pollIntervalSec * 1000;
    const pollIterations = pollDurationSec / pollIntervalSec;

    let pollCount = 0;
    const self = this;
    // start a timer after one second
    const timer = Observable.timer(1000, pollIntervalMillis);
    this.deploymentSubscription = timer.subscribe((t: any) => {
      this.getTeiidVdbStatuses()
        .subscribe(
          (resp) => {
            for ( const vdbStatus of resp ) {
              if ( vdbStatus.getName() !== vdbName ) {
                continue;
              }
              if ( vdbStatus.isActive() ) {
                this.notifierService.sendVdbDeploymentStatus(vdbStatus);
                self.deploymentSubscription.unsubscribe();
              } else if ( vdbStatus.isFailed() ) {
                this.notifierService.sendVdbDeploymentStatus(vdbStatus);
                self.deploymentSubscription.unsubscribe();
              }
            }
            pollCount++;
            if (pollCount > pollIterations) {
              // Timed out status
              const status: VdbStatus = new VdbStatus();
              status.setName(vdbName);
              status.setActive(false);
              status.setLoading(false);
              status.setFailed(true);
              const errors: string[] = [];
              errors.push("Deployment polling timed out");
              status.setErrors(errors);
              // broadcast the status
              this.notifierService.sendVdbDeploymentStatus(status);
              self.deploymentSubscription.unsubscribe();
            }
          },
          (error) => {
            // Error status
            const status: VdbStatus = new VdbStatus();
            status.setName(vdbName);
            status.setActive(false);
            status.setLoading(false);
            status.setFailed(true);
            const errors: string[] = [];
            errors.push("Deployment failed");
            status.setErrors(errors);
            // Broadcast the status
            this.notifierService.sendVdbDeploymentStatus(status);
            self.deploymentSubscription.unsubscribe();
          }
        );
    });
  }

  /**
   * Create and deploy a VDB for the provided table
   * @param {Table} table
   * @returns {Observable<boolean>}
   */
  public deployVdbForTable(table: Table): Observable<boolean> {
    const connection: Connection = table.getConnection();

    // VDB to create
    const vdb = new Vdb();
    const vdbName = connection.getId() + VdbsConstants.SOURCE_VDB_SUFFIX;
    const connName = connection.getId();
    vdb.setName(vdbName);
    vdb.setId(vdbName);
    const vdbPath = this.getKomodoUserWorkspacePath() + "/" + vdbName;
    vdb.setDataPath(vdbPath);
    vdb.setOriginalFile(vdbPath);
    vdb.setDescription(vdbName + " description");

    // VDB Model to create
    const vdbModel = new VdbModel();
    vdbModel.setId(connName);
    vdbModel.setDataPath(vdbPath + "/" + connName);
    vdbModel.setModelType("PHYSICAL");
    // Filter values for the model
    let catName = table.getCatalogName();
    let schemaName = table.getSchemaName();
    let tableName = table.getName();
    catName = (!catName || catName.length < 1) ? "%" : catName;
    schemaName = (!schemaName || schemaName.length < 1) ? "%" : schemaName;
    tableName = (!tableName || tableName.length < 1) ? "%" : tableName;
    // Set the importer properties for the physical model
    const props: NameValue[] = [];
    props.push(new NameValue("importer.TableTypes", "TABLE"));
    props.push(new NameValue("importer.UseFullSchemaName", "false"));
    props.push(new NameValue("importer.UseQualifiedName", "false"));
    props.push(new NameValue("importer.UseCatalogName", "false"));
    props.push(new NameValue("importer.catalog", catName));
    props.push(new NameValue("importer.schemaPattern", schemaName));
    props.push(new NameValue("importer.tableNamePattern", tableName));
    vdbModel.setProperties(props);

    // VdbModelSource to create
    const vdbModelSource = new VdbModelSource();
    vdbModelSource.setId(connName);
    vdbModelSource.setDataPath(vdbPath + "/" + connName + "/vdb:sources/" + connName);
    vdbModelSource.setJndiName(connection.getJndiName());
    vdbModelSource.setTranslatorName(connection.getDriverName());

    // Chain the individual calls together in series to build the Vdb and deploy it
    return this.deleteVdbIfFound(vdb.getId())
      .flatMap((res) => this.createVdb(vdb))
      .flatMap((res) => this.createVdbModel(vdb.getId(), vdbModel))
      .flatMap((res) => this.createVdbModelSource(vdb.getId(), vdbModel.getId(), vdbModelSource))
      .flatMap((res) => this.deployVdb(vdb.getId()));
  }

  /**
   * Deletes the workspace VDB if found.  Checks the workspace first, before attempting the delete.
   * If the VDB is not found the delete attempt is skipped.
   * @param {string} vdbName the name of the vdb
   * @returns {Observable<boolean>}
   */
  public deleteVdbIfFound(vdbName: string): Observable<boolean> {
    return this.hasWorkspaceVdb(vdbName)
      .switchMap( (resp) => {
        if (resp === true) {
          return this.deleteVdb(vdbName);
        } else {
          return Observable.of(true);
        }
      });
  }

}