Ejemplo n.º 1
0
void *
xrealloc (void *p, size_t n)
{
  void *result = realloc (p, n);
  if (result == NULL && (n > 0 || p == NULL))
    oom_error ("realloc", n);
  return result;
}
static int prepare_int_parameter(struct deltacloud_create_parameter *param,
				 const char *name, int value)
{
  param->name = strdup(name);
  if (param->name == NULL) {
    oom_error();
    return -1;
  }

  if (asprintf(&param->value, "%d", value) < 0) {
    SAFE_FREE(param->name);
    oom_error();
    return -1;
  }

  return 0;
}
Ejemplo n.º 3
0
static int parse_one_blob(xmlNodePtr cur, xmlXPathContextPtr ctxt,
			  void *output)
{
  struct deltacloud_bucket_blob *thisblob = (struct deltacloud_bucket_blob *)output;
  struct deltacloud_bucket_blob_metadata *thisentry;
  xmlNodePtr meta_cur, entry_cur, oldnode;
  int ret = -1;

  oldnode = ctxt->node;

  memset(thisblob, 0, sizeof(struct deltacloud_bucket_blob));

  thisblob->href = getXPathString("string(./@href)", ctxt);
  thisblob->id = getXPathString("string(./@id)", ctxt);
  thisblob->bucket_id = getXPathString("string(./bucket)", ctxt);
  thisblob->content_length = getXPathString("string(./content_length)", ctxt);
  thisblob->content_type = getXPathString("string(./content_type)", ctxt);
  thisblob->last_modified = getXPathString("string(./last_modified)", ctxt);
  thisblob->content_href = getXPathString("string(./content/@href)", ctxt);

  meta_cur = cur->children;
  while (meta_cur != NULL) {
    if (meta_cur->type == XML_ELEMENT_NODE &&
	STREQ((const char *)meta_cur->name, "user_metadata")) {

      entry_cur = meta_cur->children;
      while (entry_cur != NULL) {
	if (entry_cur->type == XML_ELEMENT_NODE &&
	    STREQ((const char *)entry_cur->name, "entry")) {

	  ctxt->node = entry_cur;

	  thisentry = calloc(1, sizeof(struct deltacloud_bucket_blob_metadata));
	  if (thisentry == NULL) {
	    deltacloud_free_bucket_blob(thisblob);
	    oom_error();
	    goto cleanup;
	  }

	  thisentry->key = getXPathString("string(./@key)", ctxt);
	  thisentry->value = getXPathString("string(.)", ctxt);

	  if (thisentry->value != NULL) {
	    strip_trailing_whitespace(thisentry->value);
	    strip_leading_whitespace(thisentry->value);
	  }

	  /* add_to_list can't fail */
	  add_to_list(&thisblob->metadata,
		      struct deltacloud_bucket_blob_metadata, thisentry);
	}

	entry_cur = entry_cur->next;
      }
    }
int parse_addresses_xml(xmlNodePtr root, xmlXPathContextPtr ctxt,
			struct deltacloud_address **addresses)
{
  struct deltacloud_address *thisaddr;
  char *address;
  xmlNodePtr oldnode, cur;
  int ret = -1;

  *addresses = NULL;

  oldnode = ctxt->node;

  ctxt->node = root;
  cur = root->children;
  while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE &&
	STREQ((const char *)cur->name, "address")) {

      address = getXPathString("string(./address)", ctxt);
      if (address != NULL) {
	thisaddr = calloc(1, sizeof(struct deltacloud_address));
	if (thisaddr == NULL) {
	  SAFE_FREE(address);
	  oom_error();
	  goto cleanup;
	}

	thisaddr->address = address;

	/* add_to_list can't fail */
	add_to_list(addresses, struct deltacloud_address, thisaddr);
      }
      /* address is allowed to be NULL, so skip it here */
    }
    cur = cur->next;
  }

  ret = 0;

 cleanup:
  ctxt->node = oldnode;
  if (ret < 0)
    free_address_list(addresses);

  return ret;
}
static int parse_lb_instance_xml(xmlNodePtr root, xmlXPathContextPtr ctxt,
				 struct deltacloud_loadbalancer_instance **instances)
{
  struct deltacloud_loadbalancer_instance *thisinst;
  xmlNodePtr oldnode, cur;
  int ret = -1;

  *instances = NULL;

  oldnode = ctxt->node;

  ctxt->node = root;
  cur = root->children;
  while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE &&
	STREQ((const char *)cur->name, "instance")) {

      thisinst = calloc(1, sizeof(struct deltacloud_loadbalancer_instance));
      if (thisinst == NULL) {
	oom_error();
	goto cleanup;
      }

      thisinst->href = (char *)xmlGetProp(cur, BAD_CAST "href");
      thisinst->id = (char *)xmlGetProp(cur, BAD_CAST "id");

      if (parse_link_xml(cur->children, &(thisinst->links)) < 0) {
	free_lb_instance(thisinst);
	SAFE_FREE(thisinst);
	goto cleanup;
      }

      /* add_to_list can't fail */
      add_to_list(instances, struct deltacloud_loadbalancer_instance, thisinst);
    }
    cur = cur->next;
  }

  ret = 0;

 cleanup:
  ctxt->node = oldnode;

  return ret;
}
static int parse_storage_snapshot_xml(xmlNodePtr cur, xmlXPathContextPtr ctxt,
				      void **data)
{
  struct deltacloud_storage_snapshot **storage_snapshots = (struct deltacloud_storage_snapshot **)data;
  struct deltacloud_storage_snapshot *thissnapshot;
  int ret = -1;
  xmlNodePtr oldnode;

  oldnode = ctxt->node;

  while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE &&
	STREQ((const char *)cur->name, "storage_snapshot")) {

      ctxt->node = cur;

      thissnapshot = calloc(1, sizeof(struct deltacloud_storage_snapshot));
      if (thissnapshot == NULL) {
	oom_error();
	goto cleanup;
      }

      if (parse_one_storage_snapshot(cur, ctxt, thissnapshot) < 0) {
	/* parse_one_storage_snapshot is expected to have set its own error */
	SAFE_FREE(thissnapshot);
	goto cleanup;
      }

      /* add_to_list can't fail */
      add_to_list(storage_snapshots, struct deltacloud_storage_snapshot,
		  thissnapshot);
    }
    cur = cur->next;
  }

  ret = 0;

 cleanup:
  ctxt->node = oldnode;
  if (ret < 0)
    deltacloud_free_storage_snapshot_list(storage_snapshots);

  return ret;
}
static int parse_listener_xml(xmlNodePtr root, xmlXPathContextPtr ctxt,
			      struct deltacloud_loadbalancer_listener **listeners)
{
  struct deltacloud_loadbalancer_listener *thislistener;
  xmlNodePtr oldnode, cur;
  int ret = -1;

  *listeners = NULL;

  oldnode = ctxt->node;

  ctxt->node = root;
  cur = root->children;
  while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE &&
	STREQ((const char *)cur->name, "listener")) {

      thislistener = calloc(1, sizeof(struct deltacloud_loadbalancer_listener));
      if (thislistener == NULL) {
	oom_error();
	goto cleanup;
      }

      thislistener->protocol = (char *)xmlGetProp(cur, BAD_CAST "protocol");
      thislistener->load_balancer_port = getXPathString("string(./listener/load_balancer_port)",
							ctxt);
      thislistener->instance_port = getXPathString("string(./listener/instance_port)",
						   ctxt);

      /* add_to_list can't fail */
      add_to_list(listeners, struct deltacloud_loadbalancer_listener,
		  thislistener);
    }
    cur = cur->next;
  }

  ret = 0;

 cleanup:
  ctxt->node = oldnode;

  return ret;
}
static int parse_loadbalancer_xml(xmlNodePtr cur, xmlXPathContextPtr ctxt,
				  void **data)
{
  struct deltacloud_loadbalancer **lbs = (struct deltacloud_loadbalancer **)data;
  struct deltacloud_loadbalancer *thislb;
  int ret = -1;
  xmlNodePtr oldnode;

  oldnode = ctxt->node;

  while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE &&
	STREQ((const char *)cur->name, "load_balancer")) {

      ctxt->node = cur;

      thislb = calloc(1, sizeof(struct deltacloud_loadbalancer));
      if (thislb == NULL) {
	oom_error();
	goto cleanup;
      }

      if (parse_one_loadbalancer(cur, ctxt, thislb) < 0) {
	/* parse_one_loadbalancer is expected to have set its own error */
	SAFE_FREE(thislb);
	goto cleanup;
      }

      /* add_to_list can't fail */
      add_to_list(lbs, struct deltacloud_loadbalancer, thislb);
    }
    cur = cur->next;
  }

  ret = 0;

 cleanup:
  ctxt->node = oldnode;
  if (ret < 0)
    deltacloud_free_loadbalancer_list(lbs);

  return ret;
}
Ejemplo n.º 9
0
int parse_metric_xml(xmlNodePtr cur, xmlXPathContextPtr ctxt,
			      void **data)
{
  struct deltacloud_metric **metrics = (struct deltacloud_metric **)data;
  struct deltacloud_metric *thismetric;
  xmlNodePtr oldnode;
  int ret = -1;
  *metrics = NULL;
  oldnode = ctxt->node;
  cur = cur->children->next->next->next->children;
  while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE) {
      thismetric = calloc(1, sizeof(struct deltacloud_metric));
      thismetric->name = strdup((const char *)cur->name);

      ctxt->node = cur;

      if (thismetric == NULL) {
	oom_error();
	goto cleanup;
      }

      if (parse_metric_value_xml(cur, ctxt, thismetric) < 0) {
	/* parse_one_instance is expected to have set its own error */
	SAFE_FREE(thismetric);
	goto cleanup;
      }
      /* add_to_list can't fail */

      add_to_list(metrics, struct deltacloud_metric, thismetric);
    }
    cur = cur->next;
  }

  ret = 0;

 cleanup:
  if (ret < 0)
    deltacloud_free_metric_list(metrics);
  ctxt->node = oldnode;

  return ret;
}
/**
 * A function to create a new load balancer.
 * @param[in] api The deltacloud_api structure representing the connection
 * @param[in] name The name to give to the new load balancer
 * @param[in] realm_id The realm ID to put the new load balancer in
 * @param[in] protocol The protocol to load balance
 * @param[in] balancer_port The port the load balancer listens on
 * @param[in] instance_port The port the load balancer balances to
 * @param[in] params An array of deltacloud_create_parameter structures that
 *                   represent any optional parameters to pass into the
 *                   create call
 * @param[in] params_length An integer describing the length of the params
 *                          array
 * @returns 0 on success, -1 on error
 */
int deltacloud_create_loadbalancer(struct deltacloud_api *api, const char *name,
				   const char *realm_id, const char *protocol,
				   int balancer_port, int instance_port,
				   struct deltacloud_create_parameter *params,
				   int params_length)
{
  struct deltacloud_create_parameter *internal_params;
  int ret = -1;
  int pos;

  if (!valid_api(api) || !valid_arg(name) || !valid_arg(realm_id)
      || !valid_arg(protocol))
    return -1;
  if (balancer_port < 0 || balancer_port > 65536) {
    invalid_argument_error("balancer_port must be between 0 and 65536");
    return -1;
  }
  if (instance_port < 0 || instance_port > 65536) {
    invalid_argument_error("instance_port must be between 0 and 65536");
    return -1;
  }

  if (params_length < 0) {
    invalid_argument_error("params_length must be >= 0");
    return -1;
  }

  internal_params = calloc(params_length + 5,
			   sizeof(struct deltacloud_create_parameter));
  if (internal_params == NULL) {
    oom_error();
    return -1;
  }

  pos = copy_parameters(internal_params, params, params_length);
  if (pos < 0)
    /* copy_parameters already set the error */
    goto cleanup;

  if (deltacloud_prepare_parameter(&internal_params[pos++], "name", name) < 0 ||
      deltacloud_prepare_parameter(&internal_params[pos++], "realm_id", realm_id) < 0 ||
      deltacloud_prepare_parameter(&internal_params[pos++], "listener_protocol", protocol) < 0)
    /* deltacloud_prepare_parameter already set the error */
    goto cleanup;

  if (prepare_int_parameter(&internal_params[pos++], "listener_balancer_port",
			    balancer_port) < 0)
    /* prepare_int_parameter already set the error */
    goto cleanup;

  if (prepare_int_parameter(&internal_params[pos++], "listener_instance_port",
			    instance_port) < 0)
    /* prepare_int_parameter already set the error */
    goto cleanup;

  if (internal_create(api, "load_balancers", internal_params, pos, NULL,
		      NULL) < 0)
    /* internal_create already set the error */
    goto cleanup;

  ret = 0;

 cleanup:
  free_parameters(internal_params, pos);
  SAFE_FREE(internal_params);

  return ret;
}
static int lb_register_unregister(struct deltacloud_api *api,
				  struct deltacloud_loadbalancer *balancer,
				  const char *instance_id,
				  struct deltacloud_create_parameter *params,
				  int params_length,
				  const char *link)
{
  struct deltacloud_link *thislink;
  struct deltacloud_create_parameter *internal_params;
  char *href;
  int ret = -1;
  int pos;
  int rc;

  if (!valid_api(api) || !valid_arg(balancer) || !valid_arg(instance_id))
    return -1;

  if (params_length < 0) {
    invalid_argument_error("params_length must be >= 0");
    return -1;
  }

  thislink = api_find_link(api, "load_balancers");
  if (thislink == NULL)
    /* api_find_link set the error */
    return -1;

  internal_params = calloc(params_length + 1,
			   sizeof(struct deltacloud_create_parameter));
  if (internal_params == NULL) {
    oom_error();
    return -1;
  }

  pos = copy_parameters(internal_params, params, params_length);
  if (pos < 0)
    /* copy_parameters already set the error */
    goto cleanup;

  if (deltacloud_prepare_parameter(&internal_params[pos++], "instance_id",
				   instance_id) < 0)
    /* deltacloud_prepare_parameter already set the error */
    goto cleanup;

  if (asprintf(&href, "%s/%s/%s", thislink->href, balancer->id, link) < 0) {
    oom_error();
    goto cleanup;
  }

  rc = internal_post(api, href, internal_params, pos, NULL, NULL);
  SAFE_FREE(href);
  if (rc < 0)
    /* internal_post already set the error */
    goto cleanup;

  ret = 0;

 cleanup:
  free_parameters(internal_params, pos);
  SAFE_FREE(internal_params);

  return ret;
}
/**
 * A function to create a new storage snapshot.
 * @param[in] api The deltacloud_api structure representing the connection
 * @param[in] volume The volume to take the snapshot from
 * @param[in] params An array of deltacloud_create_parameter structures that
 *                   represent any optional parameters to pass into the
 *                   create call
 * @param[in] params_length An integer describing the length of the params
 *                          array
 * @param[out] snap_id The snapshot_id returned by the create call
 * @returns 0 on success, -1 on error
 */
int deltacloud_create_storage_snapshot(struct deltacloud_api *api,
				       struct deltacloud_storage_volume *volume,
				       struct deltacloud_create_parameter *params,
				       int params_length,
				       char **snap_id)
{
  struct deltacloud_create_parameter *internal_params;
  struct deltacloud_storage_snapshot snap;
  char *data = NULL;
  int ret = -1;
  int pos;

  if (!valid_api(api) || !valid_arg(volume))
    return -1;

  if (params_length < 0) {
    invalid_argument_error("params_length must be >= 0");
    return -1;
  }

  internal_params = calloc(params_length + 1,
			   sizeof(struct deltacloud_create_parameter));
  if (internal_params == NULL) {
    oom_error();
    return -1;
  }

  pos = copy_parameters(internal_params, params, params_length);
  if (pos < 0)
    /* copy_parameters already set the error */
    goto cleanup;

  if (deltacloud_prepare_parameter(&internal_params[pos++], "volume_id",
				   volume->id) < 0)
    /* deltacloud_create_parameter already set the error */
    goto cleanup;

  if (internal_create(api, "storage_snapshots", internal_params, pos, &data,
		      NULL) < 0)
    /* internal_create already set the error */
    goto cleanup;

  if (snap_id != NULL) {
    if (internal_xml_parse(data, "storage_snapshot", parse_one_storage_snapshot,
			   1, &snap) < 0)
      /* internal_xml_parse set the error */
      goto cleanup;

    *snap_id = strdup(snap.id);
    deltacloud_free_storage_snapshot(&snap);
    if (*snap_id == NULL) {
      oom_error();
      goto cleanup;
    }
  }

  ret = 0;

 cleanup:
  free_parameters(internal_params, pos);
  SAFE_FREE(internal_params);
  SAFE_FREE(data);

  return ret;
}