Aerospike.cpp

Go to the documentation of this file.

#ifdef _USE_AEROSPIKE_DB_


#include "Aerospike.hpp"

#include <string.h>


namespace HCE {

AerospikeDB::AerospikeDB() {
        //citrusleaf_init ();
        _clc = citrusleaf_cluster_create();
        if (!_clc) {
                throw Poco::Exception("clc is not created");
        }
    cl_write_parameters_set_default(&_clwp);
    if(_writeUnique) {
        //cl_write_parameters_set_unique(&_clwp); // not declared
        _clwp.unique = true;
    }
}

AerospikeDB::~AerospikeDB() {
        if (_clc) {
            citrusleaf_cluster_destroy(_clc);
        }
        //citrusleaf_shutdown();
}

void AerospikeDB::setDriverUrl( const std::string & dbUrl) {
        Poco::URI url(dbUrl);
        std::string host = url.getHost();
        unsigned short port = url.getPort();
        citrusleaf_cluster_add_host(_clc, host.c_str(), port, TIMEOUT);
}

void AerospikeDB::put(const std::string& key, const std::string& value) {
    BaseDB::_error = ACTION_SUCCESS;
        cl_object key_obj;
        citrusleaf_object_init_str(&key_obj, key.c_str());
    /*
    cl_bin values;
    strcpy( values.bin_name, docs[DEFAULT_DOCUMENT].c_str());
    citrusleaf_object_init_str(&values.object, values.c_str());
    int return_value = citrusleaf_put(_clc, _dbName.c_str(), sets[DEFAULT_SET].c_str(), &key_obj, &values, 1, &_clwp);
    */
    cl_bin values[2];
    strcpy( values[0].bin_name, "key");
    strcpy( values[1].bin_name, "value");
    citrusleaf_object_init_str(&values[0].object, key.c_str());
    citrusleaf_object_init_str(&values[1].object, value.c_str());
    int return_value = citrusleaf_put(_clc, _dbName.c_str(), sets[DEFAULT_SET].c_str(), &key_obj, values, 2, &_clwp);

        if( return_value != CITRUSLEAF_OK ) {
                std::cerr << "Failure setting values " << return_value << std::endl;
        _error = (return_value==CITRUSLEAF_FAIL_KEY_EXISTS) ? PUT_FAIL_KEY_EXISTS : ACTION_GENERAL_FAILURE;
        }
}

std::string  AerospikeDB::get(const std::string& key) {
     BaseDB::_error = DOCUMENT_NOT_PRESENT;
    cl_object key_obj;
    citrusleaf_object_init_str(&key_obj, key.c_str());
    cl_bin *cl_v = NULL;
    uint32_t generation;
    int cl_v_len;
    int rv = citrusleaf_get_all(_clc, _dbName.c_str(), sets[DEFAULT_SET].c_str(), &key_obj, &cl_v, &cl_v_len, TIMEOUT, &generation);
    if (rv != CITRUSLEAF_OK) {
        std::cerr << "get failed - " << rv << std::endl;
        if (cl_v) free(cl_v);
        return std::string ("");
    }
    std::string s;
    for (int i=0;i< cl_v_len;i++) {
        #ifdef _DEBUG_
                fprintf(stderr, "%d:  bin %s ",i,cl_v[i].bin_name);
        #endif
        switch (cl_v[i].object.type) {
        case CL_STR:
                        #ifdef _DEBUG_
                        fprintf(stderr, "type string: value %s\n", cl_v[i].object.u.str);
                #endif
                s = cl_v[i].object.u.str;
                _error = DOCUMENT_PRESENT;
                break;
        case CL_INT:
                #ifdef _DEBUG_
                        fprintf(stderr, "type int: value %ld64\n",cl_v[i].object.u.i64);
                #endif
                break;
        default:
                #ifdef _DEBUG_
                        fprintf(stderr, "type unknown! (%d)\n",(int)cl_v[i].object.type);
                #endif
                break;
        }
    }
    for (int i = 0; i < cl_v_len; i++) {
        citrusleaf_object_free(&cl_v[i].object);
    }
    if (cl_v) free(cl_v);
    return s;
}

std::vector<std::string> AerospikeDB::documents;
int cb (char *ns, cf_digest *keyd,
    char *set, uint32_t generation, uint32_t record_ttl,
    cl_bin *bins, int n_bins, bool is_last, void *udata) {
    /*
    std::cout << "Set: " << set << std::endl
                 << "Namespace: " << ns << std::endl
                 << "Generation: " << generation << std::endl
                 << "record_ttl: " << record_ttl << std::endl
                 << "n_bins: " << n_bins << std::endl
                 << "cl_bin: " << bins->bin_name << std::endl
                 << "cl_bin: " << bins->object.u.str << std::endl
                 << "udata: " << udata << std::endl
    << "============================================" << std::endl;
    AerospikeDB::count++;
    */
    AerospikeDB::documents.push_back(bins->object.u.str);
}

std::vector<std::string> AerospikeDB::get_all() {
    //AerospikeDB::count = 0;
    AerospikeDB::documents.clear();
    cf_vector* pcfv = citrusleaf_scan_all_nodes(_clc, (char*)_dbName.c_str(), (char*)sets[DEFAULT_SET].c_str(), 0, 0, false, 100, cb, 0, 0);
    //std::cout << "Count: " << AerospikeDB::count << std::endl;
    return AerospikeDB::documents;
}

void  AerospikeDB::del(const std::string& key) {
        BaseDB::_error = ACTION_SUCCESS;
        cl_object key_obj;
        citrusleaf_object_init_str(&key_obj, key.c_str());
        int return_value = citrusleaf_delete(_clc, _dbName.c_str(), sets[DEFAULT_SET].c_str(), &key_obj, NULL);
        if( return_value != CITRUSLEAF_OK ) {
                _error = ACTION_GENERAL_FAILURE;
        }
}


} 


#endif