PeerStreamer

int get_from_cloud(struct cloud_helper_context *context, char *key, uint8_t *header_ptr, int header_size);

/**

 * @brief Put on the cloud the value for a specified key.

 * This function transparently handles the sending routines.

 * @param[in] context The contex representing the desired cloud_helper instance.

int put_on_cloud(struct cloud_helper_context *context, char *key, uint8_t *buffer_ptr, int buffer_size);

/**

 * @param[in] context The contex representing the desired cloud_helper instance.

 * @return nodeID identifying the cloud.

 */

/**

 * @brief Check if the specified node references the cloud

#include <stdint.h>

#include <semaphore.h>

#include <pthread.h>

#include "net_helper.h"

  void* (*cloud_helper_init)(struct nodeID *local, const char *config);

  int (*get_from_cloud)(void *context, char *key, uint8_t *header_ptr, int header_size);

  int (*put_on_cloud)(void *context, char *key, uint8_t *buffer_ptr, int buffer_size);

  int (*is_cloud_node)(void *context, struct nodeID* node);

  int (*wait4cloud)(void *context, struct timeval *tout);

  int (*recv_from_cloud)(void *context, uint8_t *buffer_ptr, int buffer_size);

struct file_cloud_context {

  const char *path;

  sem_t sem;

  uint8_t *out_buffer[10];

  struct mem_offset out_len[10];

  int out_cnt;

  char key[100];

  uint8_t value[100];

  int value_len;

};

      sem_wait(&ctx->cloud->sem);

      memcpy(buffer_ptr, e.value, e.value_len);

      len->end += e.value_len;      

      ctx->cloud->key_error = 0;

      sem_post(&ctx->cloud->sem);

      break;

    if (strcmp(e.key, ctx->key) == 0){

      memcpy(e.value, ctx->value, ctx->value_len);

      e.value_len = ctx->value_len;

      fseek(fd, -sizeof(e), SEEK_CUR);

      fwrite(&e, sizeof(e), 1, fd);

      found = 1;

    strcpy(e.key, ctx->key);

    memcpy(e.value, ctx->value, ctx->value_len);

    e.value_len = ctx->value_len;    

    fwrite(&e, sizeof(e), 1, fd);

  }

  fflush(fd);

  return 0;  

}

{

  struct file_cloud_context *ctx;

  ctx = (struct file_cloud_context *)context;

}

int file_cloud_is_cloud_node(void *context, struct nodeID* node)

  .get_from_cloud = &file_cloud_get_from_cloud,

  .put_on_cloud = &file_cloud_put_on_cloud,

  .get_cloud_node = &file_cloud_get_cloud_node,

  .is_cloud_node = &file_cloud_is_cloud_node,

  .wait4cloud = file_cloud_wait4cloud,

  .recv_from_cloud = file_cloud_recv_from_cloud

 *

 *  This is a small test program for the cloud interface

 *  To try the simple test: run it with

 *

 *    -g  GET key from cloud

 *    -p  PUT key=value on cloud

 *    -e  check if ip:port references the cloud

 *    -c  set the configuration of the cloud provider

 *

static const char *config;

static int operation;

static char *key;

static char *value;

  int o;

  char *temp;

    switch(o) {

    case 'c':

      config = strdup(optarg);

        break;

    case 'n':

      operation = GET_CLOUD_NODE;

      break;

    case 'e':

      operation = EQ_CLOUD_NODE;

      } else if (err == 0) {

	printf("Key not present on the cloud\n");

      } else {

	buffer[sizeof(buffer) - 1] = '\0';

	printf("%s\n", buffer);

      }

    } else if (err == 0){

      printf("No response from cloud\n");

    }

    break;

  case GET_CLOUD_NODE:

    break;

  case EQ_CLOUD_NODE:

    t = create_node(key, atoi(value));

	   is_cloud_node(cloud, t));

    break;

  }

  return context->ch->put_on_cloud(context->ch_context, key, buffer_ptr, buffer_size);

}

{

}

int is_cloud_node(struct cloud_helper_context *context, struct nodeID* node)

#include <stdlib.h>

#include <stdint.h>

#include <dlfcn.h>

#include "cloud_helper_iface.h"

#include "config.h"

  void* (*cloud_helper_init)(struct nodeID *local, const char *config);

  int (*get_from_cloud)(void *context, char *key, uint8_t *header_ptr, int header_size);

  int (*put_on_cloud)(void *context, char *key, uint8_t *buffer_ptr, int buffer_size);

  int (*is_cloud_node)(void *context, struct nodeID* node);

  int (*wait4cloud)(void *context, struct timeval *tout);

  int (*recv_from_cloud)(void *context, uint8_t *buffer_ptr, int buffer_size);

  return context->delegate->put_on_cloud(context->delegate_context, key, buffer_ptr, buffer_size);

}

{

}

int delegate_is_cloud_node(struct cloud_helper_impl_context *context, struct nodeID* node)

  .get_from_cloud = delegate_cloud_get_from_cloud,

  .put_on_cloud = delegate_cloud_put_on_cloud,

  .get_cloud_node = delegate_cloud_get_cloud_node,

  .is_cloud_node = delegate_is_cloud_node,

  .wait4cloud = delegate_cloud_wait4cloud,

  .recv_from_cloud = delegate_cloud_recv_from_cloud,

#ifndef CLOUD_HELPER_IFACE

#define CLOUD_HELPER_IFACE

#include "net_helper.h"

struct cloud_helper_impl_context;

  struct cloud_helper_impl_context* (*cloud_helper_init)(struct nodeID *local, const char *config);

  int (*get_from_cloud)(struct cloud_helper_impl_context *context, char *key, uint8_t *header_ptr, int header_size);

  int (*put_on_cloud)(struct cloud_helper_impl_context *context, char *key, uint8_t *buffer_ptr, int buffer_size);

  int (*is_cloud_node)(struct cloud_helper_impl_context *context, struct nodeID* node);

  int (*wait4cloud)(struct cloud_helper_impl_context *context, struct timeval *tout);

  int (*recv_from_cloud)(struct cloud_helper_impl_context *context, uint8_t *buffer_ptr, int buffer_size);