Esempio n. 1
0
/**
 * Write to read with optional fields
 */
static void
test_simple (void)
{
  TTestSimple *s1 = NULL, *s2 = NULL, *s3 = NULL;

  s1 = g_object_new (T_TEST_TYPE_SIMPLE, NULL);
  s2 = g_object_new (T_TEST_TYPE_SIMPLE, NULL);
  s3 = g_object_new (T_TEST_TYPE_SIMPLE, NULL);

  // write-to-read with optional fields
  s1->im_optional = 10;
  assert (s1->__isset_im_default == FALSE);
  assert (s1->__isset_im_optional == FALSE);  
  write_to_read (THRIFT_STRUCT (s1), THRIFT_STRUCT (s2), NULL, NULL);
  assert (s2->__isset_im_default = TRUE);
  assert (s2->__isset_im_optional == FALSE);
  assert (s2->im_optional == 0);

  s1->__isset_im_optional = TRUE;
  write_to_read (THRIFT_STRUCT (s1), THRIFT_STRUCT (s3), NULL, NULL);
  assert (s3->__isset_im_default == TRUE);
  assert (s3->__isset_im_optional == TRUE);
  assert (s3->im_optional == 10);

  g_object_unref (s1);
  g_object_unref (s2);
}
Esempio n. 2
0
/**
 * Writing between default and required.
 */
static void
test_tricky2 (void)
{
  TTestTricky1 *t1 = NULL;
  TTestTricky3 *t3 = NULL;

  t1 = g_object_new (T_TEST_TYPE_TRICKY1, NULL);
  t3 = g_object_new (T_TEST_TYPE_TRICKY3, NULL);

  write_to_read (THRIFT_STRUCT (t1), THRIFT_STRUCT (t3), NULL, NULL);
  write_to_read (THRIFT_STRUCT (t3), THRIFT_STRUCT (t1), NULL, NULL);

  assert (t1->__isset_im_default == TRUE);

  g_object_unref (t1);
  g_object_unref (t3);
}
Esempio n. 3
0
/**
 * Writing between optional and required.
 */
static void
test_tricky3 (void)
{
  TTestTricky2 *t2 = NULL;
  TTestTricky3 *t3 = NULL;

  t2 = g_object_new (T_TEST_TYPE_TRICKY2, NULL);
  t3 = g_object_new (T_TEST_TYPE_TRICKY3, NULL);

  t2->__isset_im_optional = TRUE;

  write_to_read (THRIFT_STRUCT (t2), THRIFT_STRUCT (t3), NULL, NULL);
  write_to_read (THRIFT_STRUCT (t3), THRIFT_STRUCT (t2), NULL, NULL);

  g_object_unref (t2);
  g_object_unref (t3);
}
static gboolean
thrift_dispatch_processor_real_dispatch_call (ThriftDispatchProcessor *self,
                                              ThriftProtocol *in,
                                              ThriftProtocol *out,
                                              gchar *fname,
                                              gint32 seqid,
                                              GError **error)
{
  ThriftTransport *transport;
  ThriftApplicationException *xception;
  gchar *message;
  gint32 result;
  gboolean dispatch_result = FALSE;

  THRIFT_UNUSED_VAR (self);

  /* By default, return an application exception to the client indicating the
     method name is not recognized. */

  if ((thrift_protocol_skip (in, T_STRUCT, error) < 0) ||
      (thrift_protocol_read_message_end (in, error) < 0))
    return FALSE;

  g_object_get (in, "transport", &transport, NULL);
  result = thrift_transport_read_end (transport, error);
  g_object_unref (transport);
  if (result < 0)
    return FALSE;

  if (thrift_protocol_write_message_begin (out,
                                           fname,
                                           T_EXCEPTION,
                                           seqid,
                                           error) < 0)
    return FALSE;
  message = g_strconcat ("Invalid method name: '", fname, "'", NULL);
  xception =
    g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION,
                  "type",    THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN_METHOD,
                  "message", message,
                  NULL);
  g_free (message);
  result = thrift_struct_write (THRIFT_STRUCT (xception),
                                out,
                                error);
  g_object_unref (xception);
  if ((result < 0) ||
      (thrift_protocol_write_message_end (out, error) < 0))
    return FALSE;

  g_object_get (out, "transport", &transport, NULL);
  dispatch_result =
    ((thrift_transport_write_end (transport, error) >= 0) &&
     (thrift_transport_flush (transport, error) >= 0));
  g_object_unref (transport);

  return dispatch_result;
}
Esempio n. 5
0
/**
 * Writing between optional and default
 */
static void
test_tricky1 (void)
{
  TTestTricky1 *t1 = NULL;
  TTestTricky2 *t2 = NULL;

  t1 = g_object_new (T_TEST_TYPE_TRICKY1, NULL);
  t2 = g_object_new (T_TEST_TYPE_TRICKY2, NULL);

  t2->im_optional = 10;
  write_to_read (THRIFT_STRUCT (t2), THRIFT_STRUCT (t1), NULL, NULL);
  write_to_read (THRIFT_STRUCT (t1), THRIFT_STRUCT (t2), NULL, NULL);

  assert (t1->__isset_im_default == FALSE);
  assert (t2->__isset_im_optional == TRUE);
  assert (t1->im_default == t2->im_optional);
  assert (t1->im_default == 0);

  g_object_unref (t1);
  g_object_unref (t2);
}
Esempio n. 6
0
gboolean calculator_client_send_calculate (CalculatorIf * iface, const gint32 logid, const Work * w, GError ** error)
{
  gint32 cseqid = 0;
  ThriftProtocol * protocol = SHARED_SERVICE_CLIENT (iface)->output_protocol;

  if (thrift_protocol_write_message_begin (protocol, "calculate", T_CALL, cseqid, error) < 0)
    return FALSE;

  {
    gint32 ret;
    gint32 xfer = 0;

    
    if ((ret = thrift_protocol_write_struct_begin (protocol, "calculate_args", error)) < 0)
      return 0;
    xfer += ret;
    if ((ret = thrift_protocol_write_field_begin (protocol, "logid", T_I32, 1, error)) < 0)
      return 0;
    xfer += ret;
    if ((ret = thrift_protocol_write_i32 (protocol, logid, error)) < 0)
      return 0;
    if ((ret = thrift_protocol_write_field_end (protocol, error)) < 0)
      return 0;
    xfer += ret;
    if ((ret = thrift_protocol_write_field_begin (protocol, "w", T_STRUCT, 2, error)) < 0)
      return 0;
    xfer += ret;
    if ((ret = thrift_struct_write (THRIFT_STRUCT (w), protocol, error)) < 0)
      return 0;
    xfer += ret;

    if ((ret = thrift_protocol_write_field_end (protocol, error)) < 0)
      return 0;
    xfer += ret;
    if ((ret = thrift_protocol_write_field_stop (protocol, error)) < 0)
      return 0;
    xfer += ret;
    if ((ret = thrift_protocol_write_struct_end (protocol, error)) < 0)
      return 0;
    xfer += ret;

  }

  if (thrift_protocol_write_message_end (protocol, error) < 0)
    return FALSE;
  if (!thrift_transport_flush (protocol->transport, error))
    return FALSE;
  if (!thrift_transport_write_end (protocol->transport, error))
    return FALSE;

  return TRUE;
}
Esempio n. 7
0
/**
 * Catch an optional not set exception.  To quote the
 * C++ test, "Mu-hu-ha-ha-ha!"
 */
static void
test_tricky4 (void)
{
  TTestTricky2 *t2 = NULL;
  TTestTricky3 *t3 = NULL;
  GError *read_error = NULL;

  t2 = g_object_new (T_TEST_TYPE_TRICKY2, NULL);
  t3 = g_object_new (T_TEST_TYPE_TRICKY3, NULL);

  // throws protocol exception
  write_to_read (THRIFT_STRUCT (t2), THRIFT_STRUCT (t3), NULL, &read_error);
  assert (read_error != NULL);
  g_error_free (read_error);

  write_to_read (THRIFT_STRUCT (t3), THRIFT_STRUCT (t2), NULL, NULL);

  assert (t2->__isset_im_optional);

  g_object_unref (t2);
  g_object_unref (t3);
}
gboolean bucket_store_mapping_client_recv_get_mapping (BucketStoreMappingIf * iface, GHashTable ** _return, BucketStoreMappingException ** e, GError ** error)
{

    gint32 rseqid;
    gchar * fname;
    ThriftMessageType mtype;
    ThriftProtocol * protocol = BUCKET_STORE_MAPPING_CLIENT (iface)->input_protocol;

    if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0)
    {
        if (fname) g_free (fname);
        return FALSE;
    }

    if (mtype == T_EXCEPTION) {
        if (fname) g_free (fname);
        ThriftApplicationException *xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
        thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, xception->type, "application error: %s", xception->message);
        g_object_unref (xception);
        return FALSE;
    } else if (mtype != T_REPLY) {
        if (fname) g_free (fname);
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
        return FALSE;
    } else if (strncmp (fname, "getMapping", 10) != 0) {
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, error);
        thrift_transport_read_end (protocol->transport, error);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected getMapping", fname);
        if (fname) g_free (fname);
        return FALSE;
    }
    if (fname) g_free (fname);

    {
        gint32 ret;
        gint32 xfer = 0;
        gchar *name = NULL;
        ThriftType ftype;
        gint16 fid;
        guint32 len = 0;
        gpointer data = NULL;


        /* satisfy -Wall in case these aren't used */
        THRIFT_UNUSED_VAR (len);
        THRIFT_UNUSED_VAR (data);

        /* read the struct begin marker */
        if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
        {
            if (name) g_free (name);
            return 0;
        }
        xfer += ret;
        if (name) g_free (name);
        name = NULL;

        /* read the struct fields */
        while (1)
        {
            /* read the beginning of a field */
            if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
            {
                if (name) g_free (name);
                return 0;
            }
            xfer += ret;
            if (name) g_free (name);
            name = NULL;

            /* break if we get a STOP field */
            if (ftype == T_STOP)
            {
                break;
            }

            switch (fid)
            {
            case 0:
                if (ftype == T_MAP)
                {
                    {
                        guint32 size;
                        ThriftType key_type;
                        ThriftType value_type;

                        /* read the map begin marker */
                        if ((ret = thrift_protocol_read_map_begin (protocol, &key_type, &value_type, &size, error)) < 0)
                            return 0;
                        xfer += ret;

                        /* iterate through each of the map's fields */
                        guint32 i;
                        for (i = 0; i < size; i++)
                        {
                            gint32* key0 = g_new (gint32, 1);
                            HostPort * val1 = NULL;
                            if ((ret = thrift_protocol_read_i32 (protocol, &*key0, error)) < 0)
                                return 0;
                            xfer += ret;
                            if ( val1 != NULL)
                            {
                                g_object_unref (val1);
                            }
                            val1 = g_object_new (TYPE_HOST_PORT, NULL);
                            if ((ret = thrift_struct_read (THRIFT_STRUCT (val1), protocol, error)) < 0)
                            {
                                g_object_unref (val1);
                                return 0;
                            }
                            xfer += ret;
                            g_hash_table_insert ((GHashTable *)*_return, (gpointer) key0, (gpointer) val1);
                        }

                        /* read the map end marker */
                        if ((ret = thrift_protocol_read_map_end (protocol, error)) < 0)
                            return 0;
                        xfer += ret;
                    }
                } else {
                    if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                }
                break;
            case 1:
                if (ftype == T_STRUCT)
                {
                    /* This struct is an exception */
                    if ( *e != NULL)
                    {
                        g_object_unref (*e);
                    }
                    *e = g_object_new (TYPE_BUCKET_STORE_MAPPING_EXCEPTION, NULL);
                    if ((ret = thrift_struct_read (THRIFT_STRUCT (*e), protocol, error)) < 0)
                    {
                        g_object_unref (*e);
                        return 0;
                    }
                    xfer += ret;
                } else {
                    if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                }
                break;
            default:
                if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                    return 0;
                xfer += ret;
                break;
            }
            if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
                return 0;
            xfer += ret;
        }

        if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
            return 0;
        xfer += ret;

    }

    if (thrift_protocol_read_message_end (protocol, error) < 0)
        return FALSE;

    if (!thrift_transport_read_end (protocol->transport, error))
        return FALSE;

    if (*e != NULL)
    {
        g_set_error (error, BUCKET_STORE_MAPPING_EXCEPTION_ERROR, BUCKET_STORE_MAPPING_EXCEPTION_ERROR_CODE, "BucketStoreMappingException");
        return FALSE;
    }
    return TRUE;
}
Esempio n. 9
0
static gboolean
t_test_second_service_processor_process_secondtest_string (TTestSecondServiceProcessor *self,
        gint32 sequence_id,
        ThriftProtocol *input_protocol,
        ThriftProtocol *output_protocol,
        GError **error)
{
    gboolean result = TRUE;
    ThriftTransport * transport;
    TTestSecondServiceSecondtestStringArgs * args =
        g_object_new (T_TEST_TYPE_SECOND_SERVICE_SECONDTEST_STRING_ARGS, NULL);

    g_object_get (input_protocol, "transport", &transport, NULL);

    if ((thrift_struct_read (THRIFT_STRUCT (args), input_protocol, error) != -1) &&
            (thrift_protocol_read_message_end (input_protocol, error) != -1) &&
            (thrift_transport_read_end (transport, error) != FALSE))
    {
        gchar * thing;
        gchar * return_value;
        TTestSecondServiceSecondtestStringResult * result_struct;

        g_object_get (args,
                      "thing", &thing,
                      NULL);

        g_object_unref (transport);
        g_object_get (output_protocol, "transport", &transport, NULL);

        result_struct = g_object_new (T_TEST_TYPE_SECOND_SERVICE_SECONDTEST_STRING_RESULT, NULL);
        g_object_get (result_struct, "success", &return_value, NULL);

        if (t_test_second_service_handler_secondtest_string (T_TEST_SECOND_SERVICE_IF (self->handler),
                &return_value,
                thing,
                error) == TRUE)
        {
            g_object_set (result_struct, "success", return_value, NULL);
            if (return_value != NULL)
                g_free (return_value);

            result =
                ((thrift_protocol_write_message_begin (output_protocol,
                        "secondtestString",
                        T_REPLY,
                        sequence_id,
                        error) != -1) &&
                 (thrift_struct_write (THRIFT_STRUCT (result_struct),
                                       output_protocol,
                                       error) != -1));
        }
        else
        {
            if (*error == NULL)
                g_warning ("SecondService.secondtestString implementation returned FALSE "
                           "but did not set an error");

            ThriftApplicationException *xception =
                g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION,
                              "type",    *error != NULL ? (*error)->code :
                              THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN,
                              "message", *error != NULL ? (*error)->message : NULL,
                              NULL);
            g_clear_error (error);

            result =
                ((thrift_protocol_write_message_begin (output_protocol,
                        "secondtestString",
                        T_EXCEPTION,
                        sequence_id,
                        error) != -1) &&
                 (thrift_struct_write (THRIFT_STRUCT (xception),
                                       output_protocol,
                                       error) != -1));

            g_object_unref (xception);
        }

        if (thing != NULL)
            g_free (thing);
        g_object_unref (result_struct);

        if (result == TRUE)
            result =
                ((thrift_protocol_write_message_end (output_protocol, error) != -1) &&
                 (thrift_transport_write_end (transport, error) != FALSE) &&
                 (thrift_transport_flush (transport, error) != FALSE));
    }
    else
        result = FALSE;

    g_object_unref (transport);
    g_object_unref (args);

    return result;
}
Esempio n. 10
0
gboolean t_test_second_service_client_recv_secondtest_string (TTestSecondServiceIf * iface, gchar ** _return, GError ** error)
{

    gint32 rseqid;
    gchar * fname = NULL;
    ThriftMessageType mtype;
    ThriftProtocol * protocol = T_TEST_SECOND_SERVICE_CLIENT (iface)->input_protocol;

    if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0)
    {
        if (fname) g_free (fname);
        return FALSE;
    }

    if (mtype == T_EXCEPTION) {
        if (fname) g_free (fname);
        ThriftApplicationException *xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
        thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, xception->type, "application error: %s", xception->message);
        g_object_unref (xception);
        return FALSE;
    } else if (mtype != T_REPLY) {
        if (fname) g_free (fname);
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
        return FALSE;
    } else if (strncmp (fname, "secondtestString", 16) != 0) {
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, error);
        thrift_transport_read_end (protocol->transport, error);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected secondtestString", fname);
        if (fname) g_free (fname);
        return FALSE;
    }
    if (fname) g_free (fname);

    {
        gint32 ret;
        gint32 xfer = 0;
        gchar *name = NULL;
        ThriftType ftype;
        gint16 fid;
        guint32 len = 0;
        gpointer data = NULL;


        /* satisfy -Wall in case these aren't used */
        THRIFT_UNUSED_VAR (len);
        THRIFT_UNUSED_VAR (data);

        /* read the struct begin marker */
        if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
        {
            if (name) g_free (name);
            return 0;
        }
        xfer += ret;
        if (name) g_free (name);
        name = NULL;

        /* read the struct fields */
        while (1)
        {
            /* read the beginning of a field */
            if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
            {
                if (name) g_free (name);
                return 0;
            }
            xfer += ret;
            if (name) g_free (name);
            name = NULL;

            /* break if we get a STOP field */
            if (ftype == T_STOP)
            {
                break;
            }

            switch (fid)
            {
            case 0:
                if (ftype == T_STRING)
                {
                    if (*_return != NULL)
                    {
                        g_free(*_return);
                        *_return = NULL;
                    }

                    if ((ret = thrift_protocol_read_string (protocol, &*_return, error)) < 0)
                        return 0;
                    xfer += ret;
                } else {
                    if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                }
                break;
            default:
                if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                    return 0;
                xfer += ret;
                break;
            }
            if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
                return 0;
            xfer += ret;
        }

        if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
            return 0;
        xfer += ret;

    }

    if (thrift_protocol_read_message_end (protocol, error) < 0)
        return FALSE;

    if (!thrift_transport_read_end (protocol->transport, error))
        return FALSE;

    return TRUE;
}
Esempio n. 11
0
static gboolean
calculator_processor_process_calculate (CalculatorProcessor *self,
                                        gint32 sequence_id,
                                        ThriftProtocol *input_protocol,
                                        ThriftProtocol *output_protocol,
                                        GError **error)
{
  gboolean result = TRUE;
  ThriftTransport * transport;
  ThriftApplicationException *xception;
  CalculatorCalculateArgs * args =
    g_object_new (TYPE_CALCULATOR_CALCULATE_ARGS, NULL);

  g_object_get (input_protocol, "transport", &transport, NULL);

  if ((thrift_struct_read (THRIFT_STRUCT (args), input_protocol, error) != -1) &&
      (thrift_protocol_read_message_end (input_protocol, error) != -1) &&
      (thrift_transport_read_end (transport, error) != FALSE))
  {
    gint logid;
    Work * w;
    InvalidOperation * ouch = NULL;
    gint return_value;
    CalculatorCalculateResult * result_struct;

    g_object_get (args,
                  "logid", &logid,
                  "w", &w,
                  NULL);

    g_object_unref (transport);
    g_object_get (output_protocol, "transport", &transport, NULL);

    result_struct = g_object_new (TYPE_CALCULATOR_CALCULATE_RESULT, NULL);
    g_object_get (result_struct, "success", &return_value, NULL);

    if (calculator_handler_calculate (CALCULATOR_IF (self->handler),
                                      (gint32 *)&return_value,
                                      logid,
                                      w,
                                      &ouch,
                                      error) == TRUE)
    {
      g_object_set (result_struct, "success", return_value, NULL);

      result =
        ((thrift_protocol_write_message_begin (output_protocol,
                                               "calculate",
                                               T_REPLY,
                                               sequence_id,
                                               error) != -1) &&
         (thrift_struct_write (THRIFT_STRUCT (result_struct),
                               output_protocol,
                               error) != -1));
    }
    else
    {
      if (ouch != NULL)
      {
        g_object_set (result_struct,
                      "ouch", ouch,
                      NULL);

        result =
          ((thrift_protocol_write_message_begin (output_protocol,
                                                 "calculate",
                                                 T_REPLY,
                                                 sequence_id,
                                                 error) != -1) &&
           (thrift_struct_write (THRIFT_STRUCT (result_struct),
                                 output_protocol,
                                 error) != -1));
      }
      else
      {
        if (*error == NULL)
          g_warning ("Calculator.calculate implementation returned FALSE "
                     "but did not set an error");

        xception =
          g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION,
                        "type",    *error != NULL ? (*error)->code :
                                   THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN,
                        "message", *error != NULL ? (*error)->message : NULL,
                        NULL);
        g_clear_error (error);

        result =
          ((thrift_protocol_write_message_begin (output_protocol,
                                                 "calculate",
                                                 T_EXCEPTION,
                                                 sequence_id,
                                                 error) != -1) &&
           (thrift_struct_write (THRIFT_STRUCT (xception),
                                 output_protocol,
                                 error) != -1));

        g_object_unref (xception);
      }
    }

    if (w != NULL)
      g_object_unref (w);
    g_object_unref (result_struct);

    if (result == TRUE)
      result =
        ((thrift_protocol_write_message_end (output_protocol, error) != -1) &&
         (thrift_transport_write_end (transport, error) != FALSE) &&
         (thrift_transport_flush (transport, error) != FALSE));
  }
  else
    result = FALSE;

  g_object_unref (transport);
  g_object_unref (args);

  return result;
}
Esempio n. 12
0
static gboolean
calculator_processor_process_ping (CalculatorProcessor *self,
                                   gint32 sequence_id,
                                   ThriftProtocol *input_protocol,
                                   ThriftProtocol *output_protocol,
                                   GError **error)
{
  gboolean result = TRUE;
  ThriftTransport * transport;
  ThriftApplicationException *xception;
  CalculatorPingArgs * args =
    g_object_new (TYPE_CALCULATOR_PING_ARGS, NULL);

  g_object_get (input_protocol, "transport", &transport, NULL);

  if ((thrift_struct_read (THRIFT_STRUCT (args), input_protocol, error) != -1) &&
      (thrift_protocol_read_message_end (input_protocol, error) != -1) &&
      (thrift_transport_read_end (transport, error) != FALSE))
  {
    CalculatorPingResult * result_struct;

    g_object_unref (transport);
    g_object_get (output_protocol, "transport", &transport, NULL);

    result_struct = g_object_new (TYPE_CALCULATOR_PING_RESULT, NULL);

    if (calculator_handler_ping (CALCULATOR_IF (self->handler),
                                 error) == TRUE)
    {
      result =
        ((thrift_protocol_write_message_begin (output_protocol,
                                               "ping",
                                               T_REPLY,
                                               sequence_id,
                                               error) != -1) &&
         (thrift_struct_write (THRIFT_STRUCT (result_struct),
                               output_protocol,
                               error) != -1));
    }
    else
    {
      if (*error == NULL)
        g_warning ("Calculator.ping implementation returned FALSE "
                   "but did not set an error");

      xception =
        g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION,
                      "type",    *error != NULL ? (*error)->code :
                                 THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN,
                      "message", *error != NULL ? (*error)->message : NULL,
                      NULL);
      g_clear_error (error);

      result =
        ((thrift_protocol_write_message_begin (output_protocol,
                                               "ping",
                                               T_EXCEPTION,
                                               sequence_id,
                                               error) != -1) &&
         (thrift_struct_write (THRIFT_STRUCT (xception),
                               output_protocol,
                               error) != -1));

      g_object_unref (xception);
    }

    g_object_unref (result_struct);

    if (result == TRUE)
      result =
        ((thrift_protocol_write_message_end (output_protocol, error) != -1) &&
         (thrift_transport_write_end (transport, error) != FALSE) &&
         (thrift_transport_flush (transport, error) != FALSE));
  }
  else
    result = FALSE;

  g_object_unref (transport);
  g_object_unref (args);

  return result;
}
Esempio n. 13
0
gboolean calculator_client_recv_calculate (CalculatorIf * iface, gint32* _return, InvalidOperation ** ouch, GError ** error)
{
  gint32 rseqid;
  gchar * fname = NULL;
  ThriftMessageType mtype;
  ThriftProtocol * protocol = SHARED_SERVICE_CLIENT (iface)->input_protocol;
  ThriftApplicationException *xception;

  if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0) {
    if (fname) g_free (fname);
    return FALSE;
  }

  if (mtype == T_EXCEPTION) {
    if (fname) g_free (fname);
    xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
    thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
    thrift_protocol_read_message_end (protocol, NULL);
    thrift_transport_read_end (protocol->transport, NULL);
    g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR,xception->type, "application error: %s", xception->message);
    g_object_unref (xception);
    return FALSE;
  } else if (mtype != T_REPLY) {
    if (fname) g_free (fname);
    thrift_protocol_skip (protocol, T_STRUCT, NULL);
    thrift_protocol_read_message_end (protocol, NULL);
    thrift_transport_read_end (protocol->transport, NULL);
    g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
    return FALSE;
  } else if (strncmp (fname, "calculate", 9) != 0) {
    thrift_protocol_skip (protocol, T_STRUCT, NULL);
    thrift_protocol_read_message_end (protocol,error);
    thrift_transport_read_end (protocol->transport, error);
    g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected calculate", fname);
    if (fname) g_free (fname);
    return FALSE;
  }
  if (fname) g_free (fname);

  {
    gint32 ret;
    gint32 xfer = 0;
    gchar *name = NULL;
    ThriftType ftype;
    gint16 fid;
    guint32 len = 0;
    gpointer data = NULL;
    

    /* satisfy -Wall in case these aren't used */
    THRIFT_UNUSED_VAR (len);
    THRIFT_UNUSED_VAR (data);

    /* read the struct begin marker */
    if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
    {
      if (name) g_free (name);
      return 0;
    }
    xfer += ret;
    if (name) g_free (name);
    name = NULL;

    /* read the struct fields */
    while (1)
    {
      /* read the beginning of a field */
      if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
      {
        if (name) g_free (name);
        return 0;
      }
      xfer += ret;
      if (name) g_free (name);
      name = NULL;

      /* break if we get a STOP field */
      if (ftype == T_STOP)
      {
        break;
      }

      switch (fid)
      {
        case 0:
          if (ftype == T_I32)
          {
            if ((ret = thrift_protocol_read_i32 (protocol, &*_return, error)) < 0)
              return 0;
            xfer += ret;
          } else {
            if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
              return 0;
            xfer += ret;
          }
          break;
        case 1:
          if (ftype == T_STRUCT)
          {
            /* This struct is an exception */
            if ( *ouch != NULL)
            {
              g_object_unref (*ouch);
            }
            *ouch = g_object_new (TYPE_INVALID_OPERATION, NULL);
            if ((ret = thrift_struct_read (THRIFT_STRUCT (*ouch), protocol, error)) < 0)
            {
              g_object_unref (*ouch);
              *ouch = NULL;
              return 0;
            }
            xfer += ret;
          } else {
            if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
              return 0;
            xfer += ret;
          }
          break;
        default:
          if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
            return 0;
          xfer += ret;
          break;
      }
      if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
        return 0;
      xfer += ret;
    }

    if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
      return 0;
    xfer += ret;

  }

  if (thrift_protocol_read_message_end (protocol, error) < 0)
    return FALSE;

  if (!thrift_transport_read_end (protocol->transport, error))
    return FALSE;

  if (*ouch != NULL)
  {
      g_set_error (error, INVALID_OPERATION_ERROR, INVALID_OPERATION_ERROR_CODE, "InvalidOperation");
      return FALSE;
  }
  return TRUE;
}