| /** |
| * 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. |
| */ |
| 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<String,ByteBuffer> requestCallMeta, responseCallMeta; |
| |
| protected Object response; |
| protected Exception error; |
| private Message message; |
| List<ByteBuffer> requestPayload; |
| List<ByteBuffer> 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<String,ByteBuffer> requestHandshakeMeta() { |
| if (handshakeRequest.meta == null) |
| handshakeRequest.meta = new HashMap<String,ByteBuffer>(); |
| return handshakeRequest.meta; |
| } |
| |
| void setRequestHandshakeMeta(Map<String,ByteBuffer> newmeta) { |
| handshakeRequest.meta = 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<String,ByteBuffer> responseHandshakeMeta() { |
| if (handshakeResponse.meta == null) |
| handshakeResponse.meta = new HashMap<String,ByteBuffer>(); |
| return handshakeResponse.meta; |
| } |
| |
| void setResponseHandshakeMeta(Map<String,ByteBuffer> newmeta) { |
| handshakeResponse.meta = 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<String,ByteBuffer> requestCallMeta() { |
| if (requestCallMeta == null) { |
| requestCallMeta = new HashMap<String,ByteBuffer>(); |
| } |
| return requestCallMeta; |
| } |
| |
| void setRequestCallMeta(Map<String,ByteBuffer> 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<String,ByteBuffer> responseCallMeta() { |
| if (responseCallMeta == null) { |
| responseCallMeta = new HashMap<String,ByteBuffer>(); |
| } |
| return responseCallMeta; |
| } |
| |
| void setResponseCallMeta(Map<String,ByteBuffer> 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 occured |
| * @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<ByteBuffer> 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<ByteBuffer> 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<ByteBuffer> 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<ByteBuffer> payload) { |
| this.responsePayload = payload; |
| } |
| } |