* Copyright © 2014 Cask Data, 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.

*/

*  HttpHandler class for app-fabric requests.

*/

  private static final Logger LOG = LoggerFactory.getLogger(AppFabricHttpHandler.class);

  private static final java.lang.reflect.Type MAP_STRING_STRING_TYPE

    = new TypeToken<Map<String, String>>() { }.getType();

  /**

   * Json serializer.

   */

  private static final Gson GSON = new Gson();

  /**

   * Timeout to get response from metrics system.

   */

  private static final long METRICS_SERVER_RESPONSE_TIMEOUT = TimeUnit.MILLISECONDS.convert(5, TimeUnit.MINUTES);

  private static final String ARCHIVE_NAME_HEADER = "X-Archive-Name";

  /**

   * Timeout to upload to remote app fabric.

   */

  private static final long UPLOAD_TIMEOUT = TimeUnit.MILLISECONDS.convert(10, TimeUnit.MINUTES);

  private static final Map<String, ProgramType> RUNNABLE_TYPE_MAP = new ImmutableMap.Builder<String, ProgramType>()

    .put("mapreduce", ProgramType.MAPREDUCE)

    .put("spark", ProgramType.SPARK)

    .put("flows", ProgramType.FLOW)

    .put("procedures", ProgramType.PROCEDURE)

    .put("workflows", ProgramType.WORKFLOW)

    .put("webapp", ProgramType.WEBAPP)

    .put("services", ProgramType.SERVICE)

    .build();

  /**

   * Configuration object passed from higher up.

   */

  private final CConfiguration configuration;

  /**

   * Factory for handling the location - can do both in either Distributed or Local mode.

   */

  private final LocationFactory locationFactory;

  /**

   * Runtime program service for running and managing programs.

   */

  private final ProgramRuntimeService runtimeService;

  /**

   * Client talking to transaction system.

   */

  private TransactionSystemClient txClient;

  /**

   * Access Dataset Service

   */

  private final DatasetFramework dsFramework;

  /**

   * App fabric output directory.

   */

  private final String appFabricDir;

  /**

   * Maintains a mapping of transient session state. The state is stored in memory,

   * in case of failure, all the current running sessions will be terminated. As

   * per the current implementation only connection per account is allowed to upload.

   */

  private final Map<String, SessionInfo> sessions = Maps.newConcurrentMap();

  /**

   * Store manages non-runtime lifecycle.

   */

  private final Store store;

  private final WorkflowClient workflowClient;

  private final DiscoveryServiceClient discoveryServiceClient;

  private final QueueAdmin queueAdmin;

  private final StreamAdmin streamAdmin;

  private final StreamConsumerFactory streamConsumerFactory;

  /**

   * Number of seconds for timing out a service endpoint discovery.

   */

  private static final long DISCOVERY_TIMEOUT_SECONDS = 3;

  /**

   * The directory where the uploaded files would be placed.

   */

  private final String archiveDir;

  private final ManagerFactory<Location, ApplicationWithPrograms> managerFactory;

  private final Scheduler scheduler;

  private static final class AppFabricServiceStatus {

    private static final AppFabricServiceStatus OK = new AppFabricServiceStatus(HttpResponseStatus.OK, "");

    private static final AppFabricServiceStatus PROGRAM_STILL_RUNNING =

      new AppFabricServiceStatus(HttpResponseStatus.FORBIDDEN, "Program is still running");

    private static final AppFabricServiceStatus PROGRAM_ALREADY_RUNNING =

      new AppFabricServiceStatus(HttpResponseStatus.CONFLICT, "Program is already running");

    private static final AppFabricServiceStatus PROGRAM_ALREADY_STOPPED =

      new AppFabricServiceStatus(HttpResponseStatus.CONFLICT, "Program already stopped");

    private static final AppFabricServiceStatus RUNTIME_INFO_NOT_FOUND =

      new AppFabricServiceStatus(HttpResponseStatus.CONFLICT,

                                 UserMessages.getMessage(UserErrors.RUNTIME_INFO_NOT_FOUND));

    private static final AppFabricServiceStatus PROGRAM_NOT_FOUND =

      new AppFabricServiceStatus(HttpResponseStatus.NOT_FOUND, "Program not found");

    private static final AppFabricServiceStatus INTERNAL_ERROR =

      new AppFabricServiceStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR, "Internal server error");

    private final HttpResponseStatus code;

    private final String message;

    /**

     * Describes the output status of app fabric operations.

     */

    private AppFabricServiceStatus(HttpResponseStatus code, String message) {

      this.code = code;

      this.message = message;

    }

    public HttpResponseStatus getCode() {

      return code;

    }

    public String getMessage() {

      return message;

    }

  }

  /**

   * Constructs an new instance. Parameters are binded by Guice.

   */

  @Inject

  public AppFabricHttpHandler(Authenticator authenticator, CConfiguration configuration,

                              LocationFactory locationFactory,

                              ManagerFactory<Location, ApplicationWithPrograms> managerFactory,

                              StoreFactory storeFactory,

                              ProgramRuntimeService runtimeService, StreamAdmin streamAdmin,

                              StreamConsumerFactory streamConsumerFactory,

                              WorkflowClient workflowClient, Scheduler service, QueueAdmin queueAdmin,

                              DiscoveryServiceClient discoveryServiceClient, TransactionSystemClient txClient,

                              DatasetFramework dsFramework) {

    super(authenticator);

    this.locationFactory = locationFactory;

    this.managerFactory = managerFactory;

    this.streamAdmin = streamAdmin;

    this.streamConsumerFactory = streamConsumerFactory;

    this.configuration = configuration;

    this.runtimeService = runtimeService;

    this.appFabricDir = configuration.get(Constants.AppFabric.OUTPUT_DIR,

                                          System.getProperty("java.io.tmpdir"));

    this.archiveDir = this.appFabricDir + "/archive";

    this.store = storeFactory.create();

    this.workflowClient = workflowClient;

    this.scheduler = service;

    this.discoveryServiceClient = discoveryServiceClient;

    this.queueAdmin = queueAdmin;

    this.txClient = txClient;

    this.dsFramework =

      new NamespacedDatasetFramework(dsFramework,

                                     new DefaultDatasetNamespace(configuration, Namespace.USER));

  }

  /**

   * Ping to check handler status.

   */

  @Path("/ping")

  @GET

  public void ping(HttpRequest request, HttpResponder responder) {

      responder.sendStatus(HttpResponseStatus.OK);

  }

  /**

   * Retrieve the state of the transaction manager.

   */

  @Path("/transactions/state")

  @GET

  public void getTxManagerSnapshot(HttpRequest request, HttpResponder responder) {

    try {

      LOG.trace("Taking transaction manager snapshot at time {}", System.currentTimeMillis());

      InputStream in = txClient.getSnapshotInputStream();

      LOG.trace("Took and retrieved transaction manager snapshot successfully.");

      try {

        responder.sendChunkStart(HttpResponseStatus.OK, ImmutableMultimap.<String, String>of());

        while (true) {

          // netty doesn't copy the readBytes buffer, so we have to reallocate a new buffer

          byte[] readBytes = new byte[4096];

          int res = in.read(readBytes, 0, 4096);

          if (res == -1) {

            break;

          }

          responder.sendChunk(ChannelBuffers.wrappedBuffer(readBytes, 0, res));

        }

        responder.sendChunkEnd();

      } finally {

        in.close();

      }

    } catch (Exception e) {

      LOG.error("Could not take transaction manager snapshot", e);

      responder.sendStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR);

    }

  }

  /**

   * Invalidate a transaction.

   * @param txId transaction ID.

   */

  @Path("/transactions/{tx-id}/invalidate")

  @POST

  public void invalidateTx(HttpRequest request, HttpResponder responder,

                           @PathParam("tx-id") final String txId) {

    try {

      long txIdLong = Long.parseLong(txId);

      boolean success = txClient.invalidate(txIdLong);

      if (success) {

        LOG.info("Transaction {} successfully invalidated", txId);

        responder.sendStatus(HttpResponseStatus.OK);

      } else {

        LOG.info("Transaction {} could not be invalidated: not in progress.", txId);

        responder.sendStatus(HttpResponseStatus.CONFLICT);