Example #1
0
 public bool Process(Serializer iprot, Serializer oprot)
 {
     try
     {
         Message msg = iprot.ReadMessageBegin();
         ProcessFunction fn;
         processMap_.TryGetValue(msg.Name, out fn);
         if (fn == null)
         {
             ProtocolUtil.Skip(iprot, TType.Struct);
             iprot.ReadMessageEnd();
             RPCException x = new RPCException(RPCException.ExceptionType.UnknownMethod, "Invalid method name: '" + msg.Name + "'");
             oprot.WriteMessageBegin(new Message(msg.Name, MessageType.Exception, msg.SeqID));
             x.Write(oprot);
             oprot.WriteMessageEnd();
             oprot.Transport.Flush();
             return true;
         }
         fn(msg.SeqID, iprot, oprot);
     }
     catch (IOException)
     {
         return false;
     }
     return true;
 }
Example #2
0
        public static RPCException Read(Serializer iprot)
        {
            Field field;

            string message = null;
            ExceptionType type = ExceptionType.Unknown;

            iprot.ReadStructBegin();
            while (true)
            {
                field = iprot.ReadFieldBegin();
                if (field.Type == TType.Stop)
                {
                    break;
                }

                switch (field.ID)
                {
                    case 1:
                        if (field.Type == TType.String)
                        {
                            message = iprot.ReadString();
                        }
                        else
                        {
                            ProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;
                    case 2:
                        if (field.Type == TType.I32)
                        {
                            type = (ExceptionType)iprot.ReadI32();
                        }
                        else
                        {
                            ProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;
                    default:
                        ProtocolUtil.Skip(iprot, field.Type);
                        break;
                }

                iprot.ReadFieldEnd();
            }

            iprot.ReadStructEnd();

            return new RPCException(type, message);
        }
Example #3
0
        public void Write(Serializer oprot)
        {
            Struct struc = new Struct("TApplicationException");
            Field field = new Field();

            oprot.WriteStructBegin(struc);

            if (!String.IsNullOrEmpty(Message))
            {
                field.Name = "message";
                field.Type = TType.String;
                field.ID = 1;
                oprot.WriteFieldBegin(field);
                oprot.WriteString(Message);
                oprot.WriteFieldEnd();
            }

            field.Name = "type";
            field.Type = TType.I32;
            field.ID = 2;
            oprot.WriteFieldBegin(field);
            oprot.WriteI32((int)type);
            oprot.WriteFieldEnd();
            oprot.WriteFieldStop();
            oprot.WriteStructEnd();
        }
Example #4
0
 public static void Skip(Serializer prot, TType type)
 {
     switch (type)
     {
         case TType.Bool:
             prot.ReadBool();
             break;
         case TType.Byte:
             prot.ReadByte();
             break;
         case TType.I16:
             prot.ReadI16();
             break;
         case TType.I32:
             prot.ReadI32();
             break;
         case TType.I64:
             prot.ReadI64();
             break;
         case TType.Double:
             prot.ReadDouble();
             break;
         case TType.String:
             // Don't try to decode the string, just skip it.
             prot.ReadBinary();
             break;
         case TType.Struct:
             prot.ReadStructBegin();
             while (true)
             {
                 Field field = prot.ReadFieldBegin();
                 if (field.Type == TType.Stop)
                 {
                     break;
                 }
                 Skip(prot, field.Type);
                 prot.ReadFieldEnd();
             }
             prot.ReadStructEnd();
             break;
         case TType.Map:
             Map map = prot.ReadMapBegin();
             for (int i = 0; i < map.Count; i++)
             {
                 Skip(prot, map.KeyType);
                 Skip(prot, map.ValueType);
             }
             prot.ReadMapEnd();
             break;
         case TType.Set:
             TSet set = prot.ReadSetBegin();
             for (int i = 0; i < set.Count; i++)
             {
                 Skip(prot, set.ElementType);
             }
             prot.ReadSetEnd();
             break;
         case TType.List:
             TList list = prot.ReadListBegin();
             for (int i = 0; i < list.Count; i++)
             {
                 Skip(prot, list.ElementType);
             }
             prot.ReadListEnd();
             break;
     }
 }