void my_set_group(BuxtonClient client, BuxtonKey key)
{
BuxtonKey group;
/*create a group*/
group=buxton_key_create("test_group",NULL,"user",STRING);
if(buxton_create_group(client,group,NULL,NULL,true)){
printf("create group call failed.\n");
buxton_key_free(group);
return;
}
buxton_key_free(group);
}
/*Initialization of group*/
void buxtond_set_group(char *group, char *layer)
{
client_connection();
save_errno();
if(_layer){
free(_layer);
}
if(_group){
free(_group);
}
_layer = strdup(layer);
if(!_layer){
printf("Layer assignment failed. Aborting operation.\n");
return;
}
_group = strdup(group);
if(!_group){
printf("Group assignment failed. Aborting operation.\n");
return;
}
BuxtonKey g = buxton_key_create(_group, NULL, _layer, STRING);
int status;
if (buxton_create_group(client, g, cg_cb, &status, true)){
printf("Create group call failed.\n");
} else {
printf("Switched to group: %s, layer: %s.\n", buxton_key_get_group(g), buxton_key_get_layer(g));
errno = saved_errno;
}
buxton_key_free(g);
}
void notify_cb(BuxtonResponse response, void *data)
{
bool *status = (bool *)data;
BuxtonKey key;
int32_t *value;
char *name;
if (buxton_response_status(response) != 0) {
*status = false;
return;
}
key = buxton_response_key(response);
name = buxton_key_get_name(key);
value = (int32_t*)buxton_response_value(response);
if (value) {
printf("key %s updated with new value %d\n", name, *value);
} else {
printf("key %s was removed\n", name);
}
buxton_key_free(key);
free(value);
free(name);
}
void buxtond_remove_group2(char *group_name, char *layer)
{
client_connection();
BuxtonKey group = buxton_group_create(group_name, layer);
if (buxton_remove_group(client, group, rg_cb, NULL, true)){
printf("Remove group call failed.\n");
}
buxton_key_free(group);
}
/*create a buxtond side group*/
void buxtond_create_group(BuxtonKey group)
{
client_connection();
if (buxton_create_group(client, group, NULL, NULL, true)){
printf("Create group call failed.\n");
buxton_key_free(group);
return;
}
/*TODO*/
//buxton_key_free(group);
}
void buxton_close(BuxtonClient client)
{
_BuxtonClient *c;
BuxtonKey key = NULL;
Iterator i;
/* Free all remaining allocated keys */
HASHMAP_FOREACH_KEY(key, key, key_hash, i) {
hashmap_remove_value(key_hash, key, key);
buxton_key_free(key);
}
BuxtonKey buxtond_create_group2(char *group_name, char *layer)
{
client_connection();
BuxtonKey group = buxton_key_create(group_name, NULL, layer, STRING);
if (buxton_create_group(client, group, NULL, NULL, true)){
printf("Create group call failed.\n");
buxton_key_free(group);
return;
}
return group;
/*Buxton free key? TODO*/
}
int main(void)
{
BuxtonClient client;
BuxtonKey key;
struct pollfd pfd[1];
int r;
int32_t gvalue = -1;
int fd;
if ((fd = buxton_open(&client)) < 0) {
printf("couldn't connect\n");
return -1;
}
/*
* A fully qualified key-name is being created since both group and key-name are not null.
* Group: "hello", Key-name: "test", Layer: "user", DataType: INT
*/
key = buxton_key_create("hello", "test", "user", BUXTON_TYPE_INT32);
if (!key) {
return -1;
}
if (buxton_get_value(client, key, get_cb,
&gvalue, false)) {
printf("get call failed to run\n");
return -1;
}
pfd[0].fd = fd;
pfd[0].events = POLLIN;
pfd[0].revents = 0;
r = poll(pfd, 1, 5000);
if (r <= 0) {
printf("poll error\n");
return -1;
}
if (!buxton_client_handle_response(client)) {
printf("bad response from daemon\n");
return -1;
}
if (gvalue >= 0) {
printf("got value: %d\n", gvalue);
}
buxton_key_free(key);
buxton_close(client);
return 0;
}
int main(void){
BuxtonClient client;
int fd;/*file descriptor*/
BuxtonKey key;
struct response_info gotten;
/*open client*/
if (buxton_open(&client)<0){
printf("Failed to open client.\n");
return -1;
}
printf("Connection successful.\n");
/*create a key*/
key=buxton_key_create("test_group","test_key_name","user",INT32);
/*print group name*/
printf("group: %s \n", buxton_key_get_group(key));
/*print the key name*/
printf("key: %s \n", buxton_key_get_name(key));
/*print the layer name*/
printf("layer: %s \n", buxton_key_get_layer(key));
/*unset the value of the key*/
if (buxton_unset_value(client, key, usv_cb, NULL,true)){
printf("Unset call failed to run.\n");
}
key=buxton_key_create("test_group","test_key_name","user",UINT32);
/*get value*/
if(buxton_get_value(client, key, gv_cb, &gotten,true)){
printf("get_value call failed.\n");
}
if(!gotten.status){
printf("No value has been set.\n");
/*create a group and set a key value*/
printf("setting value...\n");
my_set_group(client,key);
my_set_key(client,key);
}else{
/*print the gotten value*/
my_set_key(client,key);
printf("the value is was changed from %i.\n", gotten.value);
}
/*free the key*/
buxton_key_free(key);
/*close the client*/
buxton_close(client);
}
void set_cb(BuxtonResponse response, void *data)
{
BuxtonKey key;
char *name;
if (buxton_response_status(response) != 0) {
printf("Failed to set value\n");
return;
}
key = buxton_response_key(response);
name = buxton_key_get_name(key);
printf("Set value for key %s\n", name);
buxton_key_free(key);
free(name);
}
int main(void)
{
BuxtonClient client;
BuxtonKey key;
struct pollfd pfd[1];
int r;
int fd;
int32_t set;
if ((fd = buxton_open(&client)) < 0) {
printf("couldn't connect\n");
return -1;
}
key = buxton_key_create("hello", "test", "user", BUXTON_TYPE_INT32);
if (!key) {
return -1;
}
set = 10;
if (buxton_set_value(client, key, &set, set_cb,
NULL, false)) {
printf("set call failed to run\n");
return -1;
}
pfd[0].fd = fd;
pfd[0].events = POLLIN;
pfd[0].revents = 0;
r = poll(pfd, 1, 5000);
if (r <= 0) {
printf("poll error\n");
return -1;
}
if (!buxton_client_handle_response(client)) {
printf("bad response from daemon\n");
return -1;
}
buxton_key_free(key);
buxton_close(client);
return 0;
}
void buxtond_set_bool(char *key, bool value)
{
/*make sure client connection is open*/
client_connection();
/*create key*/
BuxtonKey _key = buxton_key_create(_group, strdup(key), _layer, BOOLEAN);
/*Return value and status*/
struct vstatus ret;
ret.type = BOOLEAN;
ret.bval = value;
save_errno();
if(buxton_set_value(client, _key, &value, bs_cb, &ret, true)){
printf("Set bool call failed.\n");
}
if (!ret.status){
errno = EACCES;
} else {
errno = saved_errno;
}
buxton_key_free(_key);
}
bool buxtond_get_bool(char *key)
{
/*make sure client connection is open*/
client_connection();
/*create key*/
BuxtonKey _key = buxton_key_create(_group, strdup(key), _layer, BOOLEAN);
/*return value*/
struct vstatus ret;
ret.type = BOOLEAN;
save_errno();
/*get value*/
if (buxton_get_value(client, _key, bgb_cb, &ret, true)){
printf("Get bool call failed.\n");
}
if (!ret.status){
errno = EACCES;
} else {
errno = saved_errno;
}
buxton_key_free(_key);
return ret.bval;
}
int main(void)
{
BuxtonClient client;
BuxtonKey key;
int32_t gvalue = -1;
int fd;
if ((fd = buxton_open(&client)) < 0) {
printf("couldn't connect\n");
return -1;
}
/*
* A fully qualified key-name is being created since both group and key-name are not null.
* Group: "hello", Key-name: "test", Layer: "user", DataType: INT
*/
key = buxton_key_create("hello", "test", "user", INT32);
if (!key) {
return -1;
}
if (buxton_get_value(client, key, get_cb,
&gvalue, true)) {
printf("get call failed to run\n");
return -1;
}
if (gvalue >= 0) {
printf("got value: %d\n", gvalue);
}
buxton_key_free(key);
buxton_close(client);
return 0;
}
void buxtond_set_int32(char *key, int32_t value)
{
/*make sure client connection is open*/
client_connection();
/*check if a key has been created*/
/*create key */
BuxtonKey _key = buxton_key_create(_group, strdup(key), _layer, INT32);
/*Return value and status*/
struct vstatus ret;
ret.type = INT32;
ret.i32val = value;
save_errno();
/*call buxton_set_value for type INT32*/
if (buxton_set_value(client, _key, &value, bs_cb, &ret, true)){
printf("Set int32_t call failed.\n");
return;
}
if (!ret.status){
errno = EACCES;
} else {
errno = saved_errno;
}
buxton_key_free(_key);
}
int main(void)
{
BuxtonClient client;
BuxtonKey key;
bool status = true;
struct pollfd pfd[1];
int r;
int fd;
int repoll_count = 10;
if ((fd = buxton_open(&client)) < 0) {
printf("couldn't connect\n");
return -1;
}
key = buxton_key_create("hello", "test", NULL, INT32);
if (!key) {
return -1;
}
if (buxton_register_notification(client, key, notify_cb, &status, false)) {
printf("set call failed to run\n");
return -1;
}
repoll:
pfd[0].fd = fd;
pfd[0].events = POLLIN;
pfd[0].revents = 0;
r = poll(pfd, 1, 5000);
if (r < 0) {
printf("poll error\n");
return -1;
} else if (r == 0) {
if (repoll_count-- > 0) {
goto out;
}
goto repoll;
}
if (!buxton_client_handle_response(client)) {
printf("bad response from daemon\n");
return -1;
}
if (!status) {
printf("Failed to register for notification\n");
return -1;
}
goto repoll;
out:
if (buxton_unregister_notification(client, key, NULL, NULL, true)) {
printf("Unregistration of notification failed\n");
return -1;
}
buxton_key_free(key);
buxton_close(client);
return 0;
}
/*buxton_set_value callback for all buxton data types*/
void bs_cb(BuxtonResponse response, void *data){
struct vstatus *ret = (struct vstatus*)data;
//struct vstatus set = *ret;
char * type = "HOUSTON";
ret->status = 0;
/*check response before switch*/
if (buxton_response_status(response)){
printf("Failed to set value.\n");
return;
}
ret->status =1;
switch(ret->type){
case STRING:
{
char * val = ret->sval;
type = "string";
break;
}
case INT32:
{
int32_t val = ret->i32val;
type = "int32_t";
/*GoToBuxtonResponseStatusCheck*/
printf("Value to be set: %i(int32_t)\n", val);
break;
}
case UINT32:
{
uint32_t val = ret->ui32val;
type = "uint32_t";
break;
}
case INT64:
{
int64_t val = ret->i64val;
type = "int64_t";
break;
}
case UINT64:
{
uint64_t val = ret->ui64val;
type = "uint64_t";
break;
}
case FLOAT:
{
float val = ret->fval;
type = "float";
break;
}
case DOUBLE:
{
double val = ret->dval;
type = "double";
break;
}
case BOOLEAN:
{
bool val = ret->bval;
type = "bool";
break;
}
}
printf("Success: %s value has been set. ", type);
BuxtonKey k = buxton_response_key(response);
printf("Key: %s, Group: %s, Layer: %s.\n", buxton_key_get_name(k), buxton_key_get_group(k), buxton_key_get_layer(k));
buxton_key_free(k);
}
/*buxton_key_free insert char key name and type*/
void buxtond_key_free(char * key_name, BuxtonDataType type)
{
BuxtonKey k = buxton_key_create(_group, strdup(key_name), _layer, type);
buxton_key_free(k);
}
