org.apache.avro.ipc.RPCContext Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of avro-ipc Show documentation
Avro inter-process communication components
The newest version!
/*
 * 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
 *
 *     https://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.
 */
package org.apache.avro.ipc;

import java.nio.ByteBuffer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.avro.Protocol.Message;

/**
 * This class represents the context of an RPC call or RPC handshake. Designed
 * to provide information to RPC plugin writers, this class encapsulates
 * information about the rpc exchange, including handshake and call metadata.
 * Note: this data includes full copies of the RPC payload, so plugins which
 * store RPCContexts beyond the life of each call should be conscious of memory
 * use.
 *
 */
public class RPCContext {

  private HandshakeRequest handshakeRequest;
  private HandshakeResponse handshakeResponse;

  protected Map requestCallMeta, responseCallMeta;

  protected Object response;
  protected Exception error;
  private Message message;
  List requestPayload;
  List responsePayload;

  /** Set the handshake request of this RPC. */
  public void setHandshakeRequest(HandshakeRequest handshakeRequest) {
    this.handshakeRequest = handshakeRequest;
  }

  /** Get the handshake request of this RPC. */
  public HandshakeRequest getHandshakeRequest() {
    return this.handshakeRequest;
  }

  /** Set the handshake response of this RPC. */
  public void setHandshakeResponse(HandshakeResponse handshakeResponse) {
    this.handshakeResponse = handshakeResponse;
  }

  /** Get the handshake response of this RPC. */
  public HandshakeResponse getHandshakeResponse() {
    return this.handshakeResponse;
  }

  /**
   * This is an access method for the handshake state provided by the client to
   * the server.
   * 
   * @return a map representing handshake state from the client to the server
   */
  public Map requestHandshakeMeta() {
    if (handshakeRequest.getMeta() == null)
      handshakeRequest.setMeta(new HashMap<>());
    return handshakeRequest.getMeta();
  }

  void setRequestHandshakeMeta(Map newmeta) {
    handshakeRequest.setMeta(newmeta);
  }

  /**
   * This is an access method for the handshake state provided by the server back
   * to the client
   * 
   * @return a map representing handshake state from the server to the client
   */
  public Map responseHandshakeMeta() {
    if (handshakeResponse.getMeta() == null)
      handshakeResponse.setMeta(new HashMap<>());
    return handshakeResponse.getMeta();
  }

  void setResponseHandshakeMeta(Map newmeta) {
    handshakeResponse.setMeta(newmeta);
  }

  /**
   * This is an access method for the per-call state provided by the client to the
   * server.
   * 
   * @return a map representing per-call state from the client to the server
   */
  public Map requestCallMeta() {
    if (requestCallMeta == null) {
      requestCallMeta = new HashMap<>();
    }
    return requestCallMeta;
  }

  void setRequestCallMeta(Map newmeta) {
    requestCallMeta = newmeta;
  }

  /**
   * This is an access method for the per-call state provided by the server back
   * to the client.
   * 
   * @return a map representing per-call state from the server to the client
   */
  public Map responseCallMeta() {
    if (responseCallMeta == null) {
      responseCallMeta = new HashMap<>();
    }
    return responseCallMeta;
  }

  void setResponseCallMeta(Map newmeta) {
    responseCallMeta = newmeta;
  }

  void setResponse(Object response) {
    this.response = response;
    this.error = null;
  }

  /**
   * The response object generated at the server, if it exists. If an exception
   * was generated, this will be null.
   * 
   * @return the response created by this RPC, no null if an exception was
   *         generated
   */
  public Object response() {
    return response;
  }

  void setError(Exception error) {
    this.response = null;
    this.error = error;
  }

  /**
   * The exception generated at the server, or null if no such exception has
   * occurred
   * 
   * @return the exception generated at the server, or null if no such exception
   */
  public Exception error() {
    return error;
  }

  /**
   * Indicates whether an exception was generated at the server
   * 
   * @return true is an exception was generated at the server, or false if not
   */
  public boolean isError() {
    return error != null;
  }

  /** Sets the {@link Message} corresponding to this RPC */
  public void setMessage(Message message) {
    this.message = message;
  }

  /**
   * Returns the {@link Message} corresponding to this RPC
   * 
   * @return this RPC's {@link Message}
   */
  public Message getMessage() {
    return message;
  }

  /**
   * Sets the serialized payload of the request in this RPC. Will not include
   * handshake or meta-data.
   */
  public void setRequestPayload(List payload) {
    this.requestPayload = payload;
  }

  /**
   * Returns the serialized payload of the request in this RPC. Will only be
   * generated from a Requestor and will not include handshake or meta-data. If
   * the request payload has not been set yet, returns null.
   *
   * @return this RPC's request payload.
   */
  public List getRequestPayload() {
    return this.requestPayload;
  }

  /**
   * Returns the serialized payload of the response in this RPC. Will only be
   * generated from a Responder and will not include handshake or meta-data. If
   * the response payload has not been set yet, returns null.
   *
   * @return this RPC's response payload.
   */
  public List getResponsePayload() {
    return this.responsePayload;
  }

  /**
   * Sets the serialized payload of the response in this RPC. Will not include
   * handshake or meta-data.
   */
  public void setResponsePayload(List payload) {
    this.responsePayload = payload;
  }
}