template <class T> ACE_Future_Rep<T> *
ACE_Future_Rep<T>::create (void)
{
// Yes set ref count to zero.
ACE_Future_Rep<T> *temp = internal_create ();
#if defined (ACE_NEW_THROWS_EXCEPTIONS)
if (temp == 0)
ACE_throw_bad_alloc;
#else
ACE_ASSERT (temp != 0);
#endif /* ACE_NEW_THROWS_EXCEPTIONS */
return temp;
}
/* This function starts the thread execution by calling the specified function
* and passing it this thread object and a user-defined argument.
*/
void kthread_start(struct kthread *self, void (*run_func)(struct kthread *, void *), void *user_arg) {
pthread_attr_t attr;
void **arg_array = (void **) kmalloc(3 * sizeof(void *));
arg_array[0] = run_func;
arg_array[1] = self;
arg_array[2] = user_arg;
assert(! self->running_flag);
self->running_flag = 1;
internal_attr_init(&attr);
internal_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
internal_create(&self->thread_id, &attr, kthread_start_internal, arg_array);
internal_attr_destroy(&attr);
}
/**
* 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;
}
Samurai::IO::Net::DatagramSocket::DatagramSocket(Samurai::IO::Net::DatagramEventHandler* eh, const Samurai::IO::Net::SocketAddress& bindAddr)
: SocketBase(bindAddr, Datagram), eventHandler(eh), myPacket(0)
{
internal_create();
setMonitor(Samurai::IO::Net::SocketMonitor::MRead);
}
Samurai::IO::Net::DatagramSocket::DatagramSocket() : SocketBase(Datagram), eventHandler(0), myPacket(0) {
QERR("Samurai::IO::Net::DatagramSocket::DatagramSocket(): Not implemented");
internal_create();
}
Samurai::IO::Net::DatagramSocket::DatagramSocket(DatagramEventHandler* eh, uint16_t bindport)
: SocketBase(Samurai::IO::Net::InetAddress("0.0.0.0"), bindport, Datagram), eventHandler(eh), myPacket(0)
{
internal_create();
setMonitor(Samurai::IO::Net::SocketMonitor::MRead);
}
/**
* 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;
}
