sparkSessionOperations.ts

/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT License.
 *
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is regenerated.
 */

import { createSpan } from "../tracing";
import { SparkSessionOperations } from "../operationsInterfaces";
import * as coreClient from "@azure/core-client";
import * as coreTracing from "@azure/core-tracing";
import * as Mappers from "../models/mappers";
import * as Parameters from "../models/parameters";
import { SparkClientContext } from "../sparkClientContext";
import {
  SparkSessionGetSparkSessionsOptionalParams,
  SparkSessionGetSparkSessionsResponse,
  SparkSessionOptions,
  SparkSessionCreateSparkSessionOptionalParams,
  SparkSessionCreateSparkSessionResponse,
  SparkSessionGetSparkSessionOptionalParams,
  SparkSessionGetSparkSessionResponse,
  SparkSessionCancelSparkSessionOptionalParams,
  SparkSessionResetSparkSessionTimeoutOptionalParams,
  SparkSessionGetSparkStatementsOptionalParams,
  SparkSessionGetSparkStatementsResponse,
  SparkStatementOptions,
  SparkSessionCreateSparkStatementOptionalParams,
  SparkSessionCreateSparkStatementResponse,
  SparkSessionGetSparkStatementOptionalParams,
  SparkSessionGetSparkStatementResponse,
  SparkSessionCancelSparkStatementOptionalParams,
  SparkSessionCancelSparkStatementResponse
} from "../models";

/** Class containing SparkSessionOperations operations. */
export class SparkSessionOperationsImpl implements SparkSessionOperations {
  private readonly client: SparkClientContext;

  /**
   * Initialize a new instance of the class SparkSessionOperations class.
   * @param client Reference to the service client
   */
  constructor(client: SparkClientContext) {
    this.client = client;
  }

  /**
   * List all spark sessions which are running under a particular spark pool.
   * @param options The options parameters.
   */
  async getSparkSessions(
    options?: SparkSessionGetSparkSessionsOptionalParams
  ): Promise<SparkSessionGetSparkSessionsResponse> {
    const { span } = createSpan("SparkClient-getSparkSessions", options || {});
    try {
      const result = await this.client.sendOperationRequest(
        { options },
        getSparkSessionsOperationSpec
      );
      return result as SparkSessionGetSparkSessionsResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Create new spark session.
   * @param sparkSessionOptions Livy compatible batch job request payload.
   * @param options The options parameters.
   */
  async createSparkSession(
    sparkSessionOptions: SparkSessionOptions,
    options?: SparkSessionCreateSparkSessionOptionalParams
  ): Promise<SparkSessionCreateSparkSessionResponse> {
    const { span } = createSpan(
      "SparkClient-createSparkSession",
      options || {}
    );
    try {
      const result = await this.client.sendOperationRequest(
        { sparkSessionOptions, options },
        createSparkSessionOperationSpec
      );
      return result as SparkSessionCreateSparkSessionResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Gets a single spark session.
   * @param sessionId Identifier for the session.
   * @param options The options parameters.
   */
  async getSparkSession(
    sessionId: number,
    options?: SparkSessionGetSparkSessionOptionalParams
  ): Promise<SparkSessionGetSparkSessionResponse> {
    const { span } = createSpan("SparkClient-getSparkSession", options || {});
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, options },
        getSparkSessionOperationSpec
      );
      return result as SparkSessionGetSparkSessionResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Cancels a running spark session.
   * @param sessionId Identifier for the session.
   * @param options The options parameters.
   */
  async cancelSparkSession(
    sessionId: number,
    options?: SparkSessionCancelSparkSessionOptionalParams
  ): Promise<void> {
    const { span } = createSpan(
      "SparkClient-cancelSparkSession",
      options || {}
    );
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, options },
        cancelSparkSessionOperationSpec
      );
      return result as void;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Sends a keep alive call to the current session to reset the session timeout.
   * @param sessionId Identifier for the session.
   * @param options The options parameters.
   */
  async resetSparkSessionTimeout(
    sessionId: number,
    options?: SparkSessionResetSparkSessionTimeoutOptionalParams
  ): Promise<void> {
    const { span } = createSpan(
      "SparkClient-resetSparkSessionTimeout",
      options || {}
    );
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, options },
        resetSparkSessionTimeoutOperationSpec
      );
      return result as void;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Gets a list of statements within a spark session.
   * @param sessionId Identifier for the session.
   * @param options The options parameters.
   */
  async getSparkStatements(
    sessionId: number,
    options?: SparkSessionGetSparkStatementsOptionalParams
  ): Promise<SparkSessionGetSparkStatementsResponse> {
    const { span } = createSpan(
      "SparkClient-getSparkStatements",
      options || {}
    );
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, options },
        getSparkStatementsOperationSpec
      );
      return result as SparkSessionGetSparkStatementsResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Create statement within a spark session.
   * @param sessionId Identifier for the session.
   * @param sparkStatementOptions Livy compatible batch job request payload.
   * @param options The options parameters.
   */
  async createSparkStatement(
    sessionId: number,
    sparkStatementOptions: SparkStatementOptions,
    options?: SparkSessionCreateSparkStatementOptionalParams
  ): Promise<SparkSessionCreateSparkStatementResponse> {
    const { span } = createSpan(
      "SparkClient-createSparkStatement",
      options || {}
    );
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, sparkStatementOptions, options },
        createSparkStatementOperationSpec
      );
      return result as SparkSessionCreateSparkStatementResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Gets a single statement within a spark session.
   * @param sessionId Identifier for the session.
   * @param statementId Identifier for the statement.
   * @param options The options parameters.
   */
  async getSparkStatement(
    sessionId: number,
    statementId: number,
    options?: SparkSessionGetSparkStatementOptionalParams
  ): Promise<SparkSessionGetSparkStatementResponse> {
    const { span } = createSpan("SparkClient-getSparkStatement", options || {});
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, statementId, options },
        getSparkStatementOperationSpec
      );
      return result as SparkSessionGetSparkStatementResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }

  /**
   * Kill a statement within a session.
   * @param sessionId Identifier for the session.
   * @param statementId Identifier for the statement.
   * @param options The options parameters.
   */
  async cancelSparkStatement(
    sessionId: number,
    statementId: number,
    options?: SparkSessionCancelSparkStatementOptionalParams
  ): Promise<SparkSessionCancelSparkStatementResponse> {
    const { span } = createSpan(
      "SparkClient-cancelSparkStatement",
      options || {}
    );
    try {
      const result = await this.client.sendOperationRequest(
        { sessionId, statementId, options },
        cancelSparkStatementOperationSpec
      );
      return result as SparkSessionCancelSparkStatementResponse;
    } catch (error) {
      span.setStatus({
        code: coreTracing.SpanStatusCode.UNSET,
        message: error.message
      });
      throw error;
    } finally {
      span.end();
    }
  }
}
// Operation Specifications
const serializer = coreClient.createSerializer(Mappers, /* isXml */ false);

const getSparkSessionsOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.SparkSessionCollection
    }
  },
  queryParameters: [Parameters.fromParam, Parameters.size, Parameters.detailed],
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName
  ],
  headerParameters: [Parameters.accept],
  serializer
};
const createSparkSessionOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions",
  httpMethod: "POST",
  responses: {
    200: {
      bodyMapper: Mappers.SparkSession
    }
  },
  requestBody: Parameters.sparkSessionOptions,
  queryParameters: [Parameters.detailed],
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName
  ],
  headerParameters: [Parameters.accept, Parameters.contentType],
  mediaType: "json",
  serializer
};
const getSparkSessionOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.SparkSession
    }
  },
  queryParameters: [Parameters.detailed],
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId
  ],
  headerParameters: [Parameters.accept],
  serializer
};
const cancelSparkSessionOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}",
  httpMethod: "DELETE",
  responses: { 200: {} },
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId
  ],
  serializer
};
const resetSparkSessionTimeoutOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}/reset-timeout",
  httpMethod: "PUT",
  responses: { 200: {} },
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId
  ],
  serializer
};
const getSparkStatementsOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}/statements",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.SparkStatementCollection
    }
  },
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId
  ],
  headerParameters: [Parameters.accept],
  serializer
};
const createSparkStatementOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}/statements",
  httpMethod: "POST",
  responses: {
    200: {
      bodyMapper: Mappers.SparkStatement
    }
  },
  requestBody: Parameters.sparkStatementOptions,
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId
  ],
  headerParameters: [Parameters.accept, Parameters.contentType],
  mediaType: "json",
  serializer
};
const getSparkStatementOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}/statements/{statementId}",
  httpMethod: "GET",
  responses: {
    200: {
      bodyMapper: Mappers.SparkStatement
    }
  },
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId,
    Parameters.statementId
  ],
  headerParameters: [Parameters.accept],
  serializer
};
const cancelSparkStatementOperationSpec: coreClient.OperationSpec = {
  path:
    "/livyApi/versions/{livyApiVersion}/sparkPools/{sparkPoolName}/sessions/{sessionId}/statements/{statementId}/cancel",
  httpMethod: "POST",
  responses: {
    200: {
      bodyMapper: Mappers.SparkStatementCancellationResult
    }
  },
  urlParameters: [
    Parameters.endpoint,
    Parameters.livyApiVersion,
    Parameters.sparkPoolName,
    Parameters.sessionId,
    Parameters.statementId
  ],
  headerParameters: [Parameters.accept],
  serializer
};