@Override public boolean process(TProtocol in, TProtocol out) throws TException { TMessage msg = in.readMessageBegin(); Controller<?, ?> fn = (Controller<?, ?>) this.beanFactory .getBean(msg.name); if (fn == null) { if (LOGGER.isWarnEnabled()) { LOGGER.warn("Invalid request: failed to find interface=" + msg.name + ", from: " + getInetAddress(in)); } TProtocolUtil.skip(in, TType.STRUCT); in.readMessageEnd(); TApplicationException x = new TApplicationException( TApplicationException.UNKNOWN_METHOD, "Invalid method name: '" + msg.name + "'"); out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(out); out.writeMessageEnd(); out.getTransport().flush(); return true; } process(msg.seqid, msg.name, in, out, fn); return true; }
protected void encodeRequest(Channel channel, ChannelBuffer buffer, Request request) throws IOException { Invocation invocation = (Invocation) request.getData(); TProtocol protocol = newProtocol(channel.getUrl(), buffer); try { protocol.writeMessageBegin(new TMessage( invocation.getMethodName(), TMessageType.CALL, thriftSeq.getAndIncrement())); protocol.writeStructBegin(new TStruct(invocation.getMethodName() + "_args")); for(int i = 0; i < invocation.getParameterTypes().length; i++) { Class<?> type = invocation.getParameterTypes()[i]; } } catch (TException e) { throw new IOException(e.getMessage(), e); } }
@SuppressWarnings("rawtypes") private void writeResult(final TProtocol out, final TMessage msg, final WriterHandler onComplete, TBase args, final TBase result) { try { onComplete.beforeWrite(msg, args, result); // if (!isOneway()) { out.writeMessageBegin(new TMessage(msg.name, TMessageType.REPLY, msg.seqid)); if (result != null) { result.write(out); } else { out.writeStructBegin(null); out.writeFieldStop(); out.writeStructEnd(); } out.writeMessageEnd(); out.getTransport().flush(); // } onComplete.afterWrite(msg, null, TMessageType.REPLY, args, result); } catch (Throwable e) { onComplete.afterWrite(msg, e, TMessageType.EXCEPTION, args, result); } }
@Override public final boolean process(final TProtocol in, final TProtocol out) throws TException { final TMessage msg = in.readMessageBegin(); final ProcessFunction<LocatorServiceImpl, ?> fn = this.fnMap .get(msg.name); if (fn != null) { fn.process(msg.seqid, in, out, this.inst); // terminate connection on receiving closeConnection // direct class comparison should be the fastest way return fn.getClass() != LocatorService.Processor.closeConnection.class; } else { TProtocolUtil.skip(in, TType.STRUCT); in.readMessageEnd(); TApplicationException x = new TApplicationException( TApplicationException.UNKNOWN_METHOD, "Invalid method name: '" + msg.name + "'"); out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(out); out.writeMessageEnd(); out.getTransport().flush(); return true; } }
@Override public boolean process(TProtocol in, TProtocol out) throws TException { TMessage msg = in.readMessageBegin(); ProcessFunction fn = processMap.get(msg.name); if (fn == null) { TProtocolUtil.skip(in, TType.STRUCT); in.readMessageEnd(); TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'"); out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(out); out.writeMessageEnd(); out.getTransport().flush(); return true; } fn.process(msg.seqid, in, out, iface); return true; }
private byte[] getMessageTypeAndSeq(JSONObject request, JSONObject methodInfo) throws TProtocolException { if (request.has(ARGUMENTS_KEY)) { if (methodInfo != null && methodInfo.has((ONEWAY_KEY))) { return new byte[] { TMessageType.ONEWAY, 0 }; } else { return new byte[] { TMessageType.CALL, 0 }; } } else if (request.has(RESULT_KEY)) { return new byte[] { TMessageType.REPLY, 1 }; } else if (request.has(EXCEPTION_KEY)) { return new byte[] { TMessageType.EXCEPTION, 1 }; } else { throw new TProtocolException(TProtocolException.INVALID_DATA, new Exception("Unable to parse message type")); } }
@Override public void writeMessageBegin(TMessage tMessage) throws TException { oprot.writeStructBegin(null); oprot.writeString(METHOD_KEY); oprot.writeString(tMessage.name); switch (tMessage.type) { case TMessageType.CALL: oprot.writeString(ARGUMENTS_KEY); break; case TMessageType.REPLY: oprot.writeString(RESULT_KEY); break; case TMessageType.EXCEPTION: oprot.writeString(EXCEPTION_KEY); break; } }
private static TApplicationException readApplicationException(int seqId, ThriftFunction func, TProtocol inputProtocol, TMessage msg) throws TException { if (msg.seqid != seqId) { throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID); } if (!func.name().equals(msg.name)) { return new TApplicationException(TApplicationException.WRONG_METHOD_NAME, msg.name); } if (msg.type == TMessageType.EXCEPTION) { final TApplicationException appEx = TApplicationExceptions.read(inputProtocol); inputProtocol.readMessageEnd(); return appEx; } return null; }
@Override void writeValue(JsonGenerator jw, Byte val) throws IOException { String serialized; switch (val.byteValue()) { case TMessageType.CALL: serialized = "CALL"; break; case TMessageType.REPLY: serialized = "REPLY"; break; case TMessageType.EXCEPTION: serialized = "EXCEPTION"; break; case TMessageType.ONEWAY: serialized = "ONEWAY"; break; default: throw new IllegalArgumentException("Unsupported message type: " + val); } jw.writeString(serialized); }
@Test(timeout = 10000) public void testStructuredLogging() throws Exception { HelloService.Iface client = newClient(); client.hello("kawamuray"); ThriftStructuredLog log = writtenLogs.take(); //assertThat(writtenLogs.size()).isEqualTo(1); assertThat(log.timestampMillis()).isGreaterThan(0); assertThat(log.responseTimeNanos()).isGreaterThanOrEqualTo(0); assertThat(log.thriftServiceName()).isEqualTo(HelloService.class.getCanonicalName()); assertThat(log.thriftMethodName()).isEqualTo("hello"); ThriftCall call = log.thriftCall(); assertThat(call.header().name).isEqualTo("hello"); assertThat(call.header().type).isEqualTo(TMessageType.CALL); assertThat(call.args()).isEqualTo(new hello_args().setName("kawamuray")); ThriftReply reply = log.thriftReply(); assertThat(reply.header().name).isEqualTo("hello"); assertThat(reply.header().type).isEqualTo(TMessageType.REPLY); assertThat(reply.header().seqid).isEqualTo(call.header().seqid); assertThat(reply.result()).isEqualTo(new hello_result().setSuccess("Hello kawamuray")); }
protected void encodeRequest(Channel channel, ChannelBuffer buffer, Request request) throws IOException { Invocation invocation = (Invocation) request.getData(); TProtocol protocol = newProtocol(channel.getUrl(), buffer); try { protocol.writeMessageBegin(new TMessage( invocation.getMethodName(), TMessageType.CALL, thriftSeq.getAndIncrement())); protocol.writeStructBegin(new TStruct(invocation.getMethodName() + "_args")); for (int i = 0; i < invocation.getParameterTypes().length; i++) { Class<?> type = invocation.getParameterTypes()[i]; } } catch (TException e) { throw new IOException(e.getMessage(), e); } }
public final void process(int seqid, TProtocol iprot, TProtocol oprot, I iface) throws TException { T args = getEmptyArgsInstance(); try { args.read(iprot); } catch (TProtocolException e) { iprot.readMessageEnd(); TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); oprot.writeMessageBegin(new TMessage(getMethodName(), TMessageType.EXCEPTION, seqid)); x.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); return; } iprot.readMessageEnd(); TBase result = getResult(iface, args); oprot.writeMessageBegin(new TMessage(getMethodName(), TMessageType.REPLY, seqid)); result.write(oprot); oprot.writeMessageEnd(); oprot.getTransport().flush(); }
public boolean process(TProtocol in, TProtocol out) throws TException { TMessage msg = in.readMessageBegin(); ProcessFunction fn = processMap.get(msg.name); if (fn == null) { TProtocolUtil.skip(in, TType.STRUCT); in.readMessageEnd(); TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'"); out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(out); out.writeMessageEnd(); out.getTransport().flush(); return true; } fn.process(msg.seqid, in, out, iface); return true; }
@SuppressWarnings({ "rawtypes" }) private void writeException(final TProtocol out, final TMessage msg, final WriterHandler onComplete, final TApplicationException x, TBase args) { Throwable cause = null; try { onComplete.beforeWrite(msg, args, null); out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(out); out.writeMessageEnd(); out.getTransport().flush(); } catch (Throwable e) { cause = e; } onComplete.afterWrite(msg, cause, TMessageType.EXCEPTION, args, null); }
@Override public final boolean process(final TProtocol in, final TProtocol out) throws TException { final TMessage msg = in.readMessageBegin(); final ProcessFunction<GFXDServiceImpl, ?> fn = this.fnMap.get(msg.name); if (fn != null) { fn.process(msg.seqid, in, out, this.inst); // terminate connection on receiving closeConnection // direct class comparison should be the fastest way // TODO: SW: also need to clean up connection artifacts in the case of // client connection failure (ConnectionListener does get a notification // but how to tie the socket/connectionNumber to the connectionID?) return fn.getClass() != GFXDService.Processor.closeConnection.class; } else { TProtocolUtil.skip(in, TType.STRUCT); in.readMessageEnd(); TApplicationException x = new TApplicationException( TApplicationException.UNKNOWN_METHOD, "Invalid method name: '" + msg.name + "'"); out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); x.write(out); out.writeMessageEnd(); out.getTransport().flush(); return true; } }
public void write_args(TProtocol prot) throws TException { prot.writeMessageBegin(new TMessage(Processor.FUNCTION_NAME, TMessageType.CALL, 0)); ArgsThriftBase args = new ArgsThriftBase(); args.setFieldValue(AbstractThriftBase.FieldsEnum.VALUE, arg); args.write(prot); prot.writeMessageEnd(); }
protected void receiveBase(TBase result, String methodName) throws TException { TMessage msg = iprot_.readMessageBegin(); if (msg.type == TMessageType.EXCEPTION) { TApplicationException x = TApplicationException.read(iprot_); iprot_.readMessageEnd(); throw x; } if (msg.seqid != seqid_) { throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, methodName + " failed: out of sequence response"); } result.read(iprot_); iprot_.readMessageEnd(); }
private static String typeString(byte typeValue) { switch (typeValue) { case TMessageType.CALL: return "CALL"; case TMessageType.REPLY: return "REPLY"; case TMessageType.EXCEPTION: return "EXCEPTION"; case TMessageType.ONEWAY: return "ONEWAY"; default: return "UNKNOWN(" + (typeValue & 0xFF) + ')'; } }
private static HttpData encodeSuccess(ServiceRequestContext ctx, RpcResponse reply, SerializationFormat serializationFormat, String methodName, int seqId, TBase<?, ?> result) { final ByteBuf buf = ctx.alloc().buffer(128); boolean success = false; try { final TTransport transport = new TByteBufTransport(buf); final TProtocol outProto = ThriftProtocolFactories.get(serializationFormat).getProtocol(transport); final TMessage header = new TMessage(methodName, TMessageType.REPLY, seqId); outProto.writeMessageBegin(header); result.write(outProto); outProto.writeMessageEnd(); ctx.logBuilder().responseContent(reply, new ThriftReply(header, result)); final HttpData encoded = new ByteBufHttpData(buf, false); success = true; return encoded; } catch (TException e) { throw new Error(e); // Should never reach here. } finally { if (!success) { buf.release(); } } }
/** * Creates a new instance that contains a Thrift {@link TMessageType#CALL} or {@link TMessageType#ONEWAY} * message. */ public ThriftCall(TMessage header, TBase<?, ?> args) { super(header); if (header.type != TMessageType.CALL && header.type != TMessageType.ONEWAY) { throw new IllegalArgumentException( "header.type: " + typeStr(header.type) + " (expected: CALL or ONEWAY)"); } this.args = requireNonNull(args, "args"); }
static String typeStr(byte type) { switch (type) { case TMessageType.CALL: return "CALL"; case TMessageType.ONEWAY: return "ONEWAY"; case TMessageType.REPLY: return "REPLY"; case TMessageType.EXCEPTION: return "EXCEPTION"; default: return "UNKNOWN(" + (type & 0xFF) + ')'; } }