sync

testing_api_cmd_object_upload.c (5520B)

---

 /*
   This file is part of SYNC
   Copyright (C) 2014-2026 Taler Systems SA
 
   SYNC is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 3, or
   (at your option) any later version.
 
   SYNC is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public
   License along with SYNC; see the file COPYING.  If not, see
   <http://www.gnu.org/licenses/>
 */
 /**
  * @file testing/testing_api_cmd_object_upload.c
  * @brief command to upload an object to the sync backend service.
  * @author Iván Ávalos
  */
 #include "platform.h"
 #include "sync/sync_service.h"
 #include "sync/sync_testing_lib.h"
 #include <taler/taler_util.h>
 #include <taler/taler_signatures.h>
 #include <taler/taler_testing_lib.h>
 #include <gnunet/gnunet_curl_lib.h>
 
 
 /**
  * State for an "object upload" CMD.
  */
 struct ObjectUploadState
 {
 
   /**
    * URL of the sync backend.
    */
   const char *sync_url;
 
   /**
    * Reference to a command that provides account keys.
    */
   const char *account_reference;
 
   /**
    * Eddsa private key.
    */
   struct SYNC_AccountPrivateKeyP sync_priv;
 
   /**
    * Eddsa public key.
    */
   struct SYNC_AccountPublicKeyP sync_pub;
 
   /**
    * UID of the object.
    */
   struct SYNC_ObjectUID uid;
 
   /**
    * Object data.
    */
   const void *data;
 
   /**
    * Number of bytes in @e data.
    */
   size_t data_size;
 
   /**
    * Expected HTTP status code.
    */
   unsigned int http_status;
 
   /**
    * The interpreter state.
    */
   struct TALER_TESTING_Interpreter *is;
 
   /**
    * Handle for the library object upload operation.
    */
   struct SYNC_BlockOperation *bop;
 
 };
 
 
 /**
  * Function called when we're done processing the
  * object upload.
  *
  * @param cls the `struct ObjectUploadState`
  * @param ud details about the upload operation
  */
 static void
 object_upload_finished (void *cls,
                         const struct SYNC_BlockOperationDetails *ud)
 {
   struct ObjectUploadState *ous = cls;
 
   ous->bop = NULL;
   if (ud->http_status != ous->http_status)
   {
     TALER_TESTING_unexpected_status (ous->is,
                                      ud->http_status,
                                      ous->http_status);
     return;
   }
   TALER_TESTING_interpreter_next (ous->is);
 }
 
 
 /**
  * Run an "object upload" CMD.
  *
  * @param cls closure.
  * @param cmd command currently being run.
  * @param is interpreter state.
  */
 static void
 object_upload_run (void *cls,
                    const struct TALER_TESTING_Command *cmd,
                    struct TALER_TESTING_Interpreter *is)
 {
   struct ObjectUploadState *ous = cls;
 
   (void) cmd;
   ous->is = is;
 
   {
     const struct TALER_TESTING_Command *ref;
     const struct SYNC_AccountPrivateKeyP *priv;
     const struct SYNC_AccountPublicKeyP *pub;
 
     ref = TALER_TESTING_interpreter_lookup_command (is,
                                                     ous->account_reference);
     if (NULL == ref)
     {
       GNUNET_break (0);
       goto fail;
     }
     if ( (GNUNET_OK !=
           TALER_TESTING_get_trait_sync_account_priv (ref,
                                                      &priv)) ||
          (GNUNET_OK !=
           TALER_TESTING_get_trait_sync_account_pub (ref,
                                                     &pub)) )
     {
       GNUNET_break (0);
       goto fail;
     }
     ous->sync_priv = *priv;
     ous->sync_pub = *pub;
   }
 
   ous->bop = SYNC_object_upload (
     TALER_TESTING_interpreter_get_context (is),
     ous->sync_url,
     &ous->sync_priv,
     &ous->uid,
     ous->data_size,
     ous->data,
     &object_upload_finished,
     ous);
   if (NULL == ous->bop)
     goto fail;
 
   return;
 
 fail:
   GNUNET_break (0);
   TALER_TESTING_interpreter_fail (is);
 }
 
 
 /**
  * Free the state of an "object upload" CMD, and possibly
  * cancel it if it did not complete.
  *
  * @param cls closure.
  * @param cmd command being freed.
  */
 static void
 object_upload_cleanup (void *cls,
                        const struct TALER_TESTING_Command *cmd)
 {
   struct ObjectUploadState *ous = cls;
 
   if (NULL != ous->bop)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Command '%s' did not complete (object upload)\n",
                 cmd->label);
     SYNC_block_operation_cancel (ous->bop);
     ous->bop = NULL;
   }
   GNUNET_free (ous);
 }
 
 
 struct TALER_TESTING_Command
 SYNC_TESTING_cmd_object_upload (const char *label,
                                 const char *sync_url,
                                 const char *account_reference,
                                 const struct SYNC_ObjectUID *uid,
                                 unsigned int http_status,
                                 const void *data,
                                 size_t data_size)
 {
   struct ObjectUploadState *ous;
 
   ous = GNUNET_new (struct ObjectUploadState);
   ous->sync_url = sync_url;
   ous->account_reference = account_reference;
   if (NULL != uid)
     ous->uid = *uid;
   ous->http_status = http_status;
   ous->data = data;
   ous->data_size = data_size;
   {
     struct TALER_TESTING_Command cmd = {
       .cls = ous,
       .label = label,
       .run = &object_upload_run,
       .cleanup = &object_upload_cleanup,
       .traits = NULL
     };
 
     return cmd;
   }
 }
 
 
 /* end of testing_api_cmd_object_upload.c */