Experimental Thrift support

No thread safety
no connection pooling for thrift
very limited error handling

elasticsearch/connection.py

@@ -42,6 +42,7 @@ class Connection(object):
 
     def log_request_success(self, method, full_url, path, body, status_code, response, duration):
         """ Log a successful API call.  """
+        #  TODO: optionally pass in params instead of full_url and do urlencode only when needed
         def _pretty_json(data):
             # pretty JSON in tracer curl logs
             try:
@@ -210,3 +211,51 @@ class MemcachedConnection(Connection):
             response, duration)
 
         return status, response
+
+from .esthrift.ttypes import Method, RestRequest
+from .esthrift import Rest
+from thrift.Thrift import TException
+from thrift.transport import TTransport, TSocket
+from thrift.protocol import TBinaryProtocol
+
+
+class ThriftConnection(Connection):
+    transport_schema = 'thrift'
+
+    def __init__(self, host='localhost', port=9500, framed_transport=False, **kwargs):
+        super(ThriftConnection, self).__init__(host=host, port=port, **kwargs)
+        socket = TSocket.TSocket(host, port)
+        socket.setTimeout(self.timeout * 1000.0)
+        if framed_transport:
+            transport = TTransport.TFramedTransport(socket)
+        else:
+            transport = TTransport.TBufferedTransport(socket)
+
+        protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport)
+        client = Rest.Client(protocol)
+        transport.open()
+        self.tclient = client
+        self.ttransport = transport
+
+    def perform_request(self, method, url, params=None, body=None, timeout=None):
+        request = RestRequest(method=Method._NAMES_TO_VALUES[method.upper()], uri=url,
+                    parameters=params, body=body)
+
+        start = time.time()
+        try:
+            response = self.tclient.execute(request)
+            duration = time.time() - start
+        except TException as e:
+            self.log_request_fail(method, url, time.time() - start, exception=e)
+            raise ConnectionError('N/A', str(e), e)
+
+        if not (200 <= response.status < 300):
+            self.log_request_fail(method, url, duration, response.status)
+            self._raise_error(response.status, response.body)
+
+        self.log_request_success(method, url, url, body, response.status,
+            response.body, duration)
+
+        return response.status, response.body
+
+

elasticsearch/esthrift/Rest-remote

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py:new_style=true,utf8strings=true
+#
+
+import sys
+import pprint
+from urlparse import urlparse
+from thrift.transport import TTransport
+from thrift.transport import TSocket
+from thrift.transport import THttpClient
+from thrift.protocol import TBinaryProtocol
+
+import Rest
+from ttypes import *
+
+if len(sys.argv) <= 1 or sys.argv[1] == '--help':
+  print ''
+  print 'Usage: ' + sys.argv[0] + ' [-h host[:port]] [-u url] [-f[ramed]] function [arg1 [arg2...]]'
+  print ''
+  print 'Functions:'
+  print '  RestResponse execute(RestRequest request)'
+  print ''
+  sys.exit(0)
+
+pp = pprint.PrettyPrinter(indent = 2)
+host = 'localhost'
+port = 9090
+uri = ''
+framed = False
+http = False
+argi = 1
+
+if sys.argv[argi] == '-h':
+  parts = sys.argv[argi+1].split(':')
+  host = parts[0]
+  if len(parts) > 1:
+    port = int(parts[1])
+  argi += 2
+
+if sys.argv[argi] == '-u':
+  url = urlparse(sys.argv[argi+1])
+  parts = url[1].split(':')
+  host = parts[0]
+  if len(parts) > 1:
+    port = int(parts[1])
+  else:
+    port = 80
+  uri = url[2]
+  if url[4]:
+    uri += '?%s' % url[4]
+  http = True
+  argi += 2
+
+if sys.argv[argi] == '-f' or sys.argv[argi] == '-framed':
+  framed = True
+  argi += 1
+
+cmd = sys.argv[argi]
+args = sys.argv[argi+1:]
+
+if http:
+  transport = THttpClient.THttpClient(host, port, uri)
+else:
+  socket = TSocket.TSocket(host, port)
+  if framed:
+    transport = TTransport.TFramedTransport(socket)
+  else:
+    transport = TTransport.TBufferedTransport(socket)
+protocol = TBinaryProtocol.TBinaryProtocol(transport)
+client = Rest.Client(protocol)
+transport.open()
+
+if cmd == 'execute':
+  if len(args) != 1:
+    print 'execute requires 1 args'
+    sys.exit(1)
+  pp.pprint(client.execute(eval(args[0]),))
+
+else:
+  print 'Unrecognized method %s' % cmd
+  sys.exit(1)
+
+transport.close()

elasticsearch/esthrift/Rest.py

@@ -0,0 +1,223 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py:new_style=true,utf8strings=true
+#
+
+from thrift.Thrift import TType, TMessageType, TException, TApplicationException
+from ttypes import *
+from thrift.Thrift import TProcessor
+from thrift.transport import TTransport
+from thrift.protocol import TBinaryProtocol, TProtocol
+try:
+  from thrift.protocol import fastbinary
+except:
+  fastbinary = None
+
+
+class Iface(object):
+  def execute(self, request):
+    """
+    Parameters:
+     - request
+    """
+    pass
+
+
+class Client(Iface):
+  def __init__(self, iprot, oprot=None):
+    self._iprot = self._oprot = iprot
+    if oprot is not None:
+      self._oprot = oprot
+    self._seqid = 0
+
+  def execute(self, request):
+    """
+    Parameters:
+     - request
+    """
+    self.send_execute(request)
+    return self.recv_execute()
+
+  def send_execute(self, request):
+    self._oprot.writeMessageBegin('execute', TMessageType.CALL, self._seqid)
+    args = execute_args()
+    args.request = request
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_execute(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = execute_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "execute failed: unknown result");
+
+
+class Processor(Iface, TProcessor):
+  def __init__(self, handler):
+    self._handler = handler
+    self._processMap = {}
+    self._processMap["execute"] = Processor.process_execute
+
+  def process(self, iprot, oprot):
+    (name, type, seqid) = iprot.readMessageBegin()
+    if name not in self._processMap:
+      iprot.skip(TType.STRUCT)
+      iprot.readMessageEnd()
+      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
+      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
+      x.write(oprot)
+      oprot.writeMessageEnd()
+      oprot.trans.flush()
+      return
+    else:
+      self._processMap[name](self, seqid, iprot, oprot)
+    return True
+
+  def process_execute(self, seqid, iprot, oprot):
+    args = execute_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = execute_result()
+    result.success = self._handler.execute(args.request)
+    oprot.writeMessageBegin("execute", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+
+# HELPER FUNCTIONS AND STRUCTURES
+
+class execute_args(object):
+  """
+  Attributes:
+   - request
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'request', (RestRequest, RestRequest.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, request=None,):
+    self.request = request
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.request = RestRequest()
+          self.request.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('execute_args')
+    if self.request is not None:
+      oprot.writeFieldBegin('request', TType.STRUCT, 1)
+      self.request.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.request is None:
+      raise TProtocol.TProtocolException(message='Required field request is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class execute_result(object):
+  """
+  Attributes:
+   - success
+  """
+
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (RestResponse, RestResponse.thrift_spec), None, ), # 0
+  )
+
+  def __init__(self, success=None,):
+    self.success = success
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = RestResponse()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('execute_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)

elasticsearch/esthrift/__init__.py

@@ -0,0 +1 @@
+__all__ = ['ttypes', 'constants', 'Rest']

elasticsearch/esthrift/constants.py

@@ -0,0 +1,11 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py:new_style=true,utf8strings=true
+#
+
+from thrift.Thrift import TType, TMessageType, TException, TApplicationException
+from ttypes import *
+

elasticsearch/esthrift/ttypes.py

@@ -0,0 +1,412 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py:new_style=true,utf8strings=true
+#
+
+from thrift.Thrift import TType, TMessageType, TException, TApplicationException
+
+from thrift.transport import TTransport
+from thrift.protocol import TBinaryProtocol, TProtocol
+try:
+  from thrift.protocol import fastbinary
+except:
+  fastbinary = None
+
+
+class Method(object):
+  GET = 0
+  PUT = 1
+  POST = 2
+  DELETE = 3
+  HEAD = 4
+  OPTIONS = 5
+
+  _VALUES_TO_NAMES = {
+    0: "GET",
+    1: "PUT",
+    2: "POST",
+    3: "DELETE",
+    4: "HEAD",
+    5: "OPTIONS",
+  }
+
+  _NAMES_TO_VALUES = {
+    "GET": 0,
+    "PUT": 1,
+    "POST": 2,
+    "DELETE": 3,
+    "HEAD": 4,
+    "OPTIONS": 5,
+  }
+
+class Status(object):
+  CONT = 100
+  SWITCHING_PROTOCOLS = 101
+  OK = 200
+  CREATED = 201
+  ACCEPTED = 202
+  NON_AUTHORITATIVE_INFORMATION = 203
+  NO_CONTENT = 204
+  RESET_CONTENT = 205
+  PARTIAL_CONTENT = 206
+  MULTI_STATUS = 207
+  MULTIPLE_CHOICES = 300
+  MOVED_PERMANENTLY = 301
+  FOUND = 302
+  SEE_OTHER = 303
+  NOT_MODIFIED = 304
+  USE_PROXY = 305
+  TEMPORARY_REDIRECT = 307
+  BAD_REQUEST = 400
+  UNAUTHORIZED = 401
+  PAYMENT_REQUIRED = 402
+  FORBIDDEN = 403
+  NOT_FOUND = 404
+  METHOD_NOT_ALLOWED = 405
+  NOT_ACCEPTABLE = 406
+  PROXY_AUTHENTICATION = 407
+  REQUEST_TIMEOUT = 408
+  CONFLICT = 409
+  GONE = 410
+  LENGTH_REQUIRED = 411
+  PRECONDITION_FAILED = 412
+  REQUEST_ENTITY_TOO_LARGE = 413
+  REQUEST_URI_TOO_LONG = 414
+  UNSUPPORTED_MEDIA_TYPE = 415
+  REQUESTED_RANGE_NOT_SATISFIED = 416
+  EXPECTATION_FAILED = 417
+  UNPROCESSABLE_ENTITY = 422
+  LOCKED = 423
+  FAILED_DEPENDENCY = 424
+  INTERNAL_SERVER_ERROR = 500
+  NOT_IMPLEMENTED = 501
+  BAD_GATEWAY = 502
+  SERVICE_UNAVAILABLE = 503
+  GATEWAY_TIMEOUT = 504
+  INSUFFICIENT_STORAGE = 506
+
+  _VALUES_TO_NAMES = {
+    100: "CONT",
+    101: "SWITCHING_PROTOCOLS",
+    200: "OK",
+    201: "CREATED",
+    202: "ACCEPTED",
+    203: "NON_AUTHORITATIVE_INFORMATION",
+    204: "NO_CONTENT",
+    205: "RESET_CONTENT",
+    206: "PARTIAL_CONTENT",
+    207: "MULTI_STATUS",
+    300: "MULTIPLE_CHOICES",
+    301: "MOVED_PERMANENTLY",
+    302: "FOUND",
+    303: "SEE_OTHER",
+    304: "NOT_MODIFIED",
+    305: "USE_PROXY",
+    307: "TEMPORARY_REDIRECT",
+    400: "BAD_REQUEST",
+    401: "UNAUTHORIZED",
+    402: "PAYMENT_REQUIRED",
+    403: "FORBIDDEN",
+    404: "NOT_FOUND",
+    405: "METHOD_NOT_ALLOWED",
+    406: "NOT_ACCEPTABLE",
+    407: "PROXY_AUTHENTICATION",
+    408: "REQUEST_TIMEOUT",
+    409: "CONFLICT",
+    410: "GONE",
+    411: "LENGTH_REQUIRED",
+    412: "PRECONDITION_FAILED",
+    413: "REQUEST_ENTITY_TOO_LARGE",
+    414: "REQUEST_URI_TOO_LONG",
+    415: "UNSUPPORTED_MEDIA_TYPE",
+    416: "REQUESTED_RANGE_NOT_SATISFIED",
+    417: "EXPECTATION_FAILED",
+    422: "UNPROCESSABLE_ENTITY",
+    423: "LOCKED",
+    424: "FAILED_DEPENDENCY",
+    500: "INTERNAL_SERVER_ERROR",
+    501: "NOT_IMPLEMENTED",
+    502: "BAD_GATEWAY",
+    503: "SERVICE_UNAVAILABLE",
+    504: "GATEWAY_TIMEOUT",
+    506: "INSUFFICIENT_STORAGE",
+  }
+
+  _NAMES_TO_VALUES = {
+    "CONT": 100,
+    "SWITCHING_PROTOCOLS": 101,
+    "OK": 200,
+    "CREATED": 201,
+    "ACCEPTED": 202,
+    "NON_AUTHORITATIVE_INFORMATION": 203,
+    "NO_CONTENT": 204,
+    "RESET_CONTENT": 205,
+    "PARTIAL_CONTENT": 206,
+    "MULTI_STATUS": 207,
+    "MULTIPLE_CHOICES": 300,
+    "MOVED_PERMANENTLY": 301,
+    "FOUND": 302,
+    "SEE_OTHER": 303,
+    "NOT_MODIFIED": 304,
+    "USE_PROXY": 305,
+    "TEMPORARY_REDIRECT": 307,
+    "BAD_REQUEST": 400,
+    "UNAUTHORIZED": 401,
+    "PAYMENT_REQUIRED": 402,
+    "FORBIDDEN": 403,
+    "NOT_FOUND": 404,
+    "METHOD_NOT_ALLOWED": 405,
+    "NOT_ACCEPTABLE": 406,
+    "PROXY_AUTHENTICATION": 407,
+    "REQUEST_TIMEOUT": 408,
+    "CONFLICT": 409,
+    "GONE": 410,
+    "LENGTH_REQUIRED": 411,
+    "PRECONDITION_FAILED": 412,
+    "REQUEST_ENTITY_TOO_LARGE": 413,
+    "REQUEST_URI_TOO_LONG": 414,
+    "UNSUPPORTED_MEDIA_TYPE": 415,
+    "REQUESTED_RANGE_NOT_SATISFIED": 416,
+    "EXPECTATION_FAILED": 417,
+    "UNPROCESSABLE_ENTITY": 422,
+    "LOCKED": 423,
+    "FAILED_DEPENDENCY": 424,
+    "INTERNAL_SERVER_ERROR": 500,
+    "NOT_IMPLEMENTED": 501,
+    "BAD_GATEWAY": 502,
+    "SERVICE_UNAVAILABLE": 503,
+    "GATEWAY_TIMEOUT": 504,
+    "INSUFFICIENT_STORAGE": 506,
+  }
+
+
+class RestRequest(object):
+  """
+  Attributes:
+   - method
+   - uri
+   - parameters
+   - headers
+   - body
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'method', None, None, ), # 1
+    (2, TType.STRING, 'uri', None, None, ), # 2
+    (3, TType.MAP, 'parameters', (TType.STRING,None,TType.STRING,None), None, ), # 3
+    (4, TType.MAP, 'headers', (TType.STRING,None,TType.STRING,None), None, ), # 4
+    (5, TType.STRING, 'body', None, None, ), # 5
+  )
+
+  def __init__(self, method=None, uri=None, parameters=None, headers=None, body=None,):
+    self.method = method
+    self.uri = uri
+    self.parameters = parameters
+    self.headers = headers
+    self.body = body
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I32:
+          self.method = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.uri = iprot.readString().decode('utf-8')
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.MAP:
+          self.parameters = {}
+          (_ktype1, _vtype2, _size0 ) = iprot.readMapBegin() 
+          for _i4 in xrange(_size0):
+            _key5 = iprot.readString().decode('utf-8')
+            _val6 = iprot.readString().decode('utf-8')
+            self.parameters[_key5] = _val6
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.MAP:
+          self.headers = {}
+          (_ktype8, _vtype9, _size7 ) = iprot.readMapBegin() 
+          for _i11 in xrange(_size7):
+            _key12 = iprot.readString().decode('utf-8')
+            _val13 = iprot.readString().decode('utf-8')
+            self.headers[_key12] = _val13
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.body = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('RestRequest')
+    if self.method is not None:
+      oprot.writeFieldBegin('method', TType.I32, 1)
+      oprot.writeI32(self.method)
+      oprot.writeFieldEnd()
+    if self.uri is not None:
+      oprot.writeFieldBegin('uri', TType.STRING, 2)
+      oprot.writeString(self.uri.encode('utf-8'))
+      oprot.writeFieldEnd()
+    if self.parameters is not None:
+      oprot.writeFieldBegin('parameters', TType.MAP, 3)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.parameters))
+      for kiter14,viter15 in self.parameters.items():
+        oprot.writeString(kiter14.encode('utf-8'))
+        oprot.writeString(viter15.encode('utf-8'))
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.headers is not None:
+      oprot.writeFieldBegin('headers', TType.MAP, 4)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.headers))
+      for kiter16,viter17 in self.headers.items():
+        oprot.writeString(kiter16.encode('utf-8'))
+        oprot.writeString(viter17.encode('utf-8'))
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.body is not None:
+      oprot.writeFieldBegin('body', TType.STRING, 5)
+      oprot.writeString(self.body)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.method is None:
+      raise TProtocol.TProtocolException(message='Required field method is unset!')
+    if self.uri is None:
+      raise TProtocol.TProtocolException(message='Required field uri is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)
+
+class RestResponse(object):
+  """
+  Attributes:
+   - status
+   - headers
+   - body
+  """
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'status', None, None, ), # 1
+    (2, TType.MAP, 'headers', (TType.STRING,None,TType.STRING,None), None, ), # 2
+    (3, TType.STRING, 'body', None, None, ), # 3
+  )
+
+  def __init__(self, status=None, headers=None, body=None,):
+    self.status = status
+    self.headers = headers
+    self.body = body
+
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I32:
+          self.status = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.headers = {}
+          (_ktype19, _vtype20, _size18 ) = iprot.readMapBegin() 
+          for _i22 in xrange(_size18):
+            _key23 = iprot.readString().decode('utf-8')
+            _val24 = iprot.readString().decode('utf-8')
+            self.headers[_key23] = _val24
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.body = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('RestResponse')
+    if self.status is not None:
+      oprot.writeFieldBegin('status', TType.I32, 1)
+      oprot.writeI32(self.status)
+      oprot.writeFieldEnd()
+    if self.headers is not None:
+      oprot.writeFieldBegin('headers', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.headers))
+      for kiter25,viter26 in self.headers.items():
+        oprot.writeString(kiter25.encode('utf-8'))
+        oprot.writeString(viter26.encode('utf-8'))
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.body is not None:
+      oprot.writeFieldBegin('body', TType.STRING, 3)
+      oprot.writeString(self.body)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+
+  def validate(self):
+    if self.status is None:
+      raise TProtocol.TProtocolException(message='Required field status is unset!')
+    return
+
+
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+  def __ne__(self, other):
+    return not (self == other)