def encode(n, proto_factory=TBinaryProtocolFactory()):
    ab = make_addressbook()
    start = time.time()
    for i in range(n):
        serialize(ab, proto_factory)
    end = time.time()
    print("encode\t-> {}".format(end - start))

  def testSerializeThenDeserialize(self):
    obj = Xtruct2(i32_thing=1,
                  struct_thing=Xtruct(string_thing="foo"))

    s1 = serialize(obj)
    for i in range(10):
      self.assertEquals(s1, serialize(obj))
      objcopy = Xtruct2()
      deserialize(objcopy, serialize(obj))
      self.assertEquals(obj, objcopy)

    obj = Xtruct(string_thing="bar")
    objcopy = Xtruct()
    deserialize(objcopy, serialize(obj))
    self.assertEquals(obj, objcopy)

 def render_task_json(scheduled_task):
   """Render a single task into json. This is baroque, but it uses thrift to
   give us all of the job status data, while allowing us to compose it with
   other stuff and pretty-print it.
   """
   return json.loads(serialize(scheduled_task,
       protocol_factory=TJSONProtocol.TSimpleJSONProtocolFactory()))

    def test_launchTask_deserialization_fail(self):  # noqa
        proxy_driver = ProxyDriver()

        role = getpass.getuser()
        task_info = mesos_pb2.TaskInfo()
        task_info.name = task_info.task_id.value = "broken"
        task_info.data = serialize(
            AssignedTask(
                task=TaskConfig(
                    job=JobKey(role=role, environment="env", name="name"),
                    owner=Identity(role=role, user=role),
                    executorConfig=ExecutorConfig(name=AURORA_EXECUTOR_NAME, data="garbage"),
                )
            )
        )

        te = FastThermosExecutor(
            runner_provider=make_provider(safe_mkdtemp()), sandbox_provider=DefaultTestSandboxProvider()
        )
        te.launchTask(proxy_driver, task_info)
        proxy_driver.wait_stopped()

        updates = proxy_driver.method_calls["sendStatusUpdate"]
        assert len(updates) == 2
        assert updates[0][0][0].state == mesos_pb2.TASK_STARTING
        assert updates[1][0][0].state == mesos_pb2.TASK_FAILED

  def render_quota(self, write_json, quota_resp):
    def get_quota_json(quota):
      result = {}
      result['cpu'] = quota.numCpus
      result['ram'] = float(quota.ramMb) / 1024
      result['disk'] = float(quota.diskMb) / 1024
      return result

    def get_quota_str(quota):
      result = []
      result.append('  CPU: %s' % quota.numCpus)
      result.append('  RAM: %f GB' % (float(quota.ramMb) / 1024))
      result.append('  Disk: %f GB' % (float(quota.diskMb) / 1024))
      return result

    if write_json:
      return serialize(quota_resp.result.getQuotaResult,
          protocol_factory=TJSONProtocol.TSimpleJSONProtocolFactory())
    else:
      quota_result = quota_resp.result.getQuotaResult
      result = ['Allocated:']
      result += get_quota_str(quota_result.quota)
      if quota_result.prodConsumption:
        result.append('Production resources consumed:')
        result += get_quota_str(quota_result.prodConsumption)
      if quota_result.nonProdConsumption:
        result.append('Non-production resources consumed:')
        result += get_quota_str(quota_result.nonProdConsumption)
      return '\n'.join(result)

  def render_quota(self, write_json, quota_resp):
    def get_quota_str(quota):
      resource_details = ResourceManager.resource_details_from_quota(quota)
      return ('  %s: %s%s' % (
          r.resource_type.display_name,
          r.value,
          r.resource_type.display_unit) for r in resource_details)

    if write_json:
      return serialize(quota_resp.result.getQuotaResult,
          protocol_factory=TJSONProtocol.TSimpleJSONProtocolFactory())
    else:
      quota_result = quota_resp.result.getQuotaResult
      result = ['Allocated:']
      result += get_quota_str(quota_result.quota)
      if quota_result.prodSharedConsumption:
        result.append('Production shared pool resources consumed:')
        result += get_quota_str(quota_result.prodSharedConsumption)
      if quota_result.prodDedicatedConsumption:
        result.append('Production dedicated pool resources consumed:')
        result += get_quota_str(quota_result.prodDedicatedConsumption)
      if quota_result.nonProdSharedConsumption:
        result.append('Non-production shared pool resources consumed:')
        result += get_quota_str(quota_result.nonProdSharedConsumption)
      if quota_result.nonProdDedicatedConsumption:
        result.append('Non-production dedicated pool resources consumed:')
        result += get_quota_str(quota_result.nonProdDedicatedConsumption)
      return '\n'.join(result)

    def render_quota(self, write_json, quota_resp):
        def get_quota_json(quota):
            result = {}
            result["cpu"] = quota.numCpus
            result["ram"] = float(quota.ramMb) / 1024
            result["disk"] = float(quota.diskMb) / 1024
            return result

        def get_quota_str(quota):
            result = []
            result.append("  CPU: %s" % quota.numCpus)
            result.append("  RAM: %f GB" % (float(quota.ramMb) / 1024))
            result.append("  Disk: %f GB" % (float(quota.diskMb) / 1024))
            return result

        if write_json:
            return serialize(
                quota_resp.result.getQuotaResult, protocol_factory=TJSONProtocol.TSimpleJSONProtocolFactory()
            )
        else:
            quota_result = quota_resp.result.getQuotaResult
            result = ["Allocated:"]
            result += get_quota_str(quota_result.quota)
            if quota_result.prodConsumption:
                result.append("Production resources consumed:")
                result += get_quota_str(quota_result.prodConsumption)
            if quota_result.nonProdConsumption:
                result.append("Non-production resources consumed:")
                result += get_quota_str(quota_result.nonProdConsumption)
            return "\n".join(result)

def decode(n, proto_factory=TBinaryProtocolFactory()):
    ab = ttypes.AddressBook()
    ab_encoded = serialize(make_addressbook())
    start = time.time()
    for i in range(n):
        deserialize(ab, ab_encoded, proto_factory)
    end = time.time()
    print("decode\t-> {}".format(end - start))

def create_address(host, port):
    """Serialize the given address to thrift ServerAddress.

    :type host: str
    :type port: int
    :rtype: str
    """
    address = ServerAddress(host, port)
    return serialize(address)

 def serialize_content(content):
     """ Серилизация контента товара для БД Cassandra.
     :param content: контент, который необходимо сериализовать
     :return: строка
     """
     p = WarehouseMethods.build_dict_for_WareContentDto(content)
     content = WarehouseMethods.get_WareContentDto(**p)
     content_obj = serialize(content)
     service_log.put("Serialized content: %s" % str(content_obj))
     return content_obj

 def next_tuple(self):
     try:
         msg_body = next(self.msg_bodies)
         msg = Message(type=MsgType.TYPE_A, body=msg_body, score=98.7654321)
         ser_msg = b2a_base64(serialize(msg))
         self.log('emitting message: {}'.format(msg))
         self.log('serialized message: {}'.format(ser_msg))
         self.emit([ser_msg], tup_id=hash(msg))
     except StopIteration:
         sleep(10)
         pass

  def testSerializeThenDeserialize(self):
    obj = Xtruct2(i32_thing=1,
                  struct_thing=Xtruct(string_thing="foo"))

    s1 = serialize(obj)
    for i in range(10):
      self.assertEquals(s1, serialize(obj))
      objcopy = Xtruct2()
      deserialize(objcopy, serialize(obj))
      self.assertEquals(obj, objcopy)

    obj = Xtruct(string_thing="bar")
    objcopy = Xtruct()
    deserialize(objcopy, serialize(obj))
    self.assertEquals(obj, objcopy)

    # test booleans
    obj = Bools(im_true=True, im_false=False)
    objcopy = Bools()
    deserialize(objcopy, serialize(obj))
    self.assertEquals(obj, objcopy)

    # test enums
    for num, name in Numberz._VALUES_TO_NAMES.items():
      obj = Bonk(message='enum Numberz value %d is string %s' % (num, name), type=num)
      objcopy = Bonk()
      deserialize(objcopy, serialize(obj))
      self.assertEquals(obj, objcopy)

  def test_launchTask_deserialization_fail(self):
    proxy_driver = ProxyDriver()

    task_info = mesos_pb.TaskInfo()
    task_info.name = task_info.task_id.value = 'broken'
    task_info.data = serialize(AssignedTask(task=TaskConfig(executorConfig=ExecutorConfig(
        name=AURORA_EXECUTOR_NAME,
        data='garbage'))))

    te = ThermosExecutor(
        runner_provider=make_provider(safe_mkdtemp()),
        sandbox_provider=DefaultTestSandboxProvider)
    te.launchTask(proxy_driver, task_info)

    updates = proxy_driver.method_calls['sendStatusUpdate']
    assert len(updates) == 1
    assert updates[0][0][0].state == mesos_pb.TASK_FAILED

def make_task(thermos_config, assigned_ports={}, **kw):
  role = getpass.getuser()
  task_id = thermos_config.task().name().get() + '-001'
  at = AssignedTask(
      taskId=task_id,
      task=TaskConfig(
          executorConfig=ExecutorConfig(
              name=AURORA_EXECUTOR_NAME,
              data=thermos_config.json_dumps()),
          job=JobKey(role=role, environment='env', name='name')),
      assignedPorts=assigned_ports,
      **kw)
  td = mesos_pb2.TaskInfo()
  td.task_id.value = task_id
  td.name = thermos_config.task().name().get()
  td.data = serialize(at)
  return td

   def render_task_json(scheduled_task):
       """Render a single task into json. This is baroque, but it uses thrift to
 give us all of the job status data, while allowing us to compose it with
 other stuff and pretty-print it.
 """
       task = json.loads(serialize(scheduled_task, protocol_factory=TJSONProtocol.TSimpleJSONProtocolFactory()))
       # Now, clean it up: take all fields that are actually enums, and convert
       # their values to strings.
       task["status"] = ScheduleStatus._VALUES_TO_NAMES[task["status"]]
       events = sorted(task["taskEvents"], key=lambda event: event["timestamp"])
       for event in events:
           event["status"] = ScheduleStatus._VALUES_TO_NAMES[event["status"]]
       # convert boolean fields to boolean value names.
       assigned = task["assignedTask"]
       task_config = assigned["task"]
       task_config["isService"] = task_config["isService"] != 0
       if "production" in task_config:
           task_config["production"] = task_config["production"] != 0
       return task

 def render_task_json(scheduled_task):
   """Render a single task into json. This is baroque, but it uses thrift to
   give us all of the job status data, while allowing us to compose it with
   other stuff and pretty-print it.
   """
   task = json.loads(serialize(scheduled_task,
       protocol_factory=TJSONProtocol.TSimpleJSONProtocolFactory()))
   # Now, clean it up: take all fields that are actually enums, and convert
   # their values to strings.
   task['status'] = ScheduleStatus._VALUES_TO_NAMES[task['status']]
   for event in task['taskEvents']:
     event['status'] = ScheduleStatus._VALUES_TO_NAMES[event['status']]
   # convert boolean fields to boolean value names.
   assigned = task['assignedTask']
   task_config = assigned['task']
   task_config['isService'] = (task_config['isService'] != 0)
   if 'production' in task_config:
     task_config['production'] = (task_config['production'] != 0)
   return task

 def encoder_bytes(self, data):
     return serialize(test_ttypes.Bin(data))

 def encoder_integer(self, data):
     return serialize(test_ttypes.Int(data))

 def encoder_float(self, data):
     return serialize(test_ttypes.Float(data))

 def encoder_boolean(self, data):
     return serialize(test_ttypes.Bool(data))