void PutGetTest::SetUp() { if (PutGetTest::remoteCacheManager == nullptr){ ConfigurationBuilder builder; builder.addServer().host("127.0.0.1").port(11222); builder.protocolVersion(Configuration::PROTOCOL_VERSION_24); builder.balancingStrategyProducer(nullptr); PutGetTest::remoteCacheManager.reset(new RemoteCacheManager(builder.build(), false)); } };
int main(int argc, char** argv) { int result=0; std::cout << "Events and Listeners" << std::endl; { ConfigurationBuilder builder; builder.balancingStrategyProducer(nullptr); builder.protocolVersion(argc > 1 ? argv[1] : Configuration::PROTOCOL_VERSION_24); builder.addServer().host(argc > 2 ? argv[2] : "127.0.0.1").port(argc > 3 ? atoi(argv[3]) : 11222); RemoteCacheManager cacheManager(builder.build(), false); cacheManager.start(); JBasicMarshaller<int> *km = new JBasicMarshaller<int>(); JBasicMarshaller<std::string> *vm = new JBasicMarshaller<std::string>(); RemoteCache<int, std::string> cache = cacheManager.getCache<int, std::string>(km, &Marshaller<int>::destroy, vm, &Marshaller<std::string>::destroy); cache.clear(); std::vector<std::vector<char> > filterFactoryParams; std::vector<std::vector<char> > converterFactoryParams; CacheClientListener<int, std::string> cl(cache); int createdCount=0, modifiedCount=0, removedCount=0, expiredCount=0; // We're using future and promise to have a basic listeners/main thread synch int setFutureEventKey=0; std::promise<void> promise; // Listeners definitions std::function<void(ClientCacheEntryCreatedEvent<int>)> listenerCreated = [&createdCount, &setFutureEventKey, &promise](ClientCacheEntryCreatedEvent<int> e) { createdCount++; if (setFutureEventKey==e.getKey()) { promise.set_value(); }; }; std::function<void(ClientCacheEntryModifiedEvent<int>)> listenerModified = [&modifiedCount, &setFutureEventKey, &promise](ClientCacheEntryModifiedEvent <int> e) { modifiedCount++; if (setFutureEventKey==e.getKey()) { promise.set_value(); } }; std::function<void(ClientCacheEntryRemovedEvent<int>)> listenerRemoved = [&removedCount, &setFutureEventKey, &promise](ClientCacheEntryRemovedEvent <int> e) { removedCount++; if (setFutureEventKey==e.getKey()) { promise.set_value(); } }; std::function<void(ClientCacheEntryExpiredEvent<int>)> listenerExpired = [&expiredCount, &setFutureEventKey, &promise](ClientCacheEntryExpiredEvent <int> e) { expiredCount++; if (setFutureEventKey==e.getKey()) { promise.set_value(); } }; cl.add_listener(listenerCreated); cl.add_listener(listenerModified); cl.add_listener(listenerRemoved); cl.add_listener(listenerExpired); cache.put(1,"v1"); cache.put(2,"v2"); cache.put(3,"v3"); cache.addClientListener(cl, filterFactoryParams, converterFactoryParams); // This tells the listener to fill the promise on event with key = 6 setFutureEventKey=6; cache.put(4,"v4"); cache.put(5,"v5"); cache.put(6,"v6"); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners on Create (Timeout)" << std::endl; return -1; } ASSERT(createdCount, createdCount == 3, result, "created count mismatch"); setFutureEventKey=2; promise= std::promise<void>(); cache.put(1,"v1a"); cache.put(2,"v2a"); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners on Modify (Timeout)" << std::endl; return -1; } ASSERT(modifiedCount, modifiedCount == 2, result, "modified count mismatch"); setFutureEventKey=3; promise= std::promise<void>(); cache.remove(3); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners on Remove (Timeout)" << std::endl; return -1; } ASSERT(removedCount, removedCount == 1, result, "removed count mismatch"); // Now test expired events setFutureEventKey=10; promise= std::promise<void>(); cache.put(11,"nexp"); cache.put(10,"exp1",3); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners (Timeout)" << std::endl; return -1; } promise= std::promise<void>(); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners (Timeout)" << std::endl; return -1; } ASSERT(expiredCount, expiredCount == 1, result, "removed count mismatch"); cache.removeClientListener(cl); // Now add a second listener to check includeCurrentState CS feature CacheClientListener<int, std::string> clCS(cache); clCS.includeCurrentState=true; int createdCountCS=0, modifiedCountCS=0, removedCountCS=0; std::function<void(ClientCacheEntryCreatedEvent<int>)> listenerCreatedCS = [&createdCountCS, &setFutureEventKey, &promise](ClientCacheEntryCreatedEvent<int> e) { createdCountCS++; if (setFutureEventKey==e.getKey()) { promise.set_value(); } }; std::function<void(ClientCacheEntryModifiedEvent<int>)> listenerModifiedCS = [&modifiedCountCS, &setFutureEventKey, &promise](ClientCacheEntryModifiedEvent <int> e) { modifiedCountCS++; if (setFutureEventKey==e.getKey()) { promise.set_value(); } }; std::function<void(ClientCacheEntryRemovedEvent<int>)> listenerRemovedCS = [&removedCountCS, &setFutureEventKey, &promise](ClientCacheEntryRemovedEvent <int> e) { removedCountCS++; if (setFutureEventKey==e.getKey()) { promise.set_value(); } }; clCS.add_listener(listenerCreatedCS); clCS.add_listener(listenerModifiedCS); clCS.add_listener(listenerRemovedCS); setFutureEventKey=8; promise=std::promise<void>(); cache.addClientListener(clCS, filterFactoryParams, converterFactoryParams); cache.put(8,"v8"); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners (Timeout)" << std::endl; return -1; } ASSERT(createdCountCS, createdCountCS == 7, result, "created with current state"); std::cout << "9 Events and Listeners" << std::endl; setFutureEventKey=2; promise=std::promise<void>(); cache.put(1,"v1a"); cache.put(2,"v2a"); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners (Timeout)" << std::endl; return -1; } ASSERT(modifiedCountCS, modifiedCountCS == 2, result, "modified count mismatch"); setFutureEventKey=8; promise=std::promise<void>(); cache.remove(8); if (std::future_status::timeout==promise.get_future().wait_for(std::chrono::seconds(30))) { std::cout << "FAIL: Events and Listeners (Timeout)" << std::endl; return -1; } ASSERT(removedCountCS, removedCountCS == 1, result, "removed count mismatch"); cache.removeClientListener(clCS); cacheManager.stop(); } if (result==0) { std::cout << "PASS: Events and Listeners" << std::endl; } else { std::cout << "FAIL: Events and Listeners" << std::endl; } return result; }
int main(int argc, char** argv) { ConfigurationBuilder nearCacheBuilder; nearCacheBuilder.protocolVersion(argc > 1 ? argv[1] : Configuration::PROTOCOL_VERSION_24); nearCacheBuilder.addServer().host(argc > 2 ? argv[2] : "127.0.0.1").port(argc > 3 ? atoi(argv[3]) : 11222); nearCacheBuilder.balancingStrategyProducer(nullptr); nearCacheBuilder.nearCache().mode(NearCacheMode::INVALIDATED).maxEntries(10); RemoteCacheManager nearCacheManager(nearCacheBuilder.build(), false); JBasicMarshaller<std::string> *km = new JBasicMarshaller<std::string>(); JBasicMarshaller<std::string> *vm = new JBasicMarshaller<std::string>(); try { nearCacheManager.start(); RemoteCache<std::string, std::string> nearCache = nearCacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy); nearCache.clear(); // Read stats to do some checks on hits and miss counter std::map<std::string,std::string> statsBegin= nearCache.stats(); auto hitsBegin = std::stoi(statsBegin["hits"]); auto missesBegin = std::stoi(statsBegin["misses"]); // Only the first get goes to the remote cache and miss the value // then all the gets are resolved nearly nearCache.get("key1"); nearCache.put("key1", "value1"); std::string *rest = nearCache.get("key1"); std::cout << "Got result from near cache:" << ((rest) ? *rest : "null") << std::endl; delete rest; rest = nearCache.get("key1"); delete rest; std::map<std::string,std::string> stats1= nearCache.stats(); auto hits1 = std::stoi(stats1["hits"]); auto misses1 = std::stoi(stats1["misses"]); std::cout << "Remote misses is: " << misses1-missesBegin << "" << std::endl; std::cout << "Remote hits is: " << hits1-hitsBegin << "" << std::endl; for(int i=2; i <= 11; i++) { // fill cache with 10 more entries (11 in total) nearCache.put("key"+std::to_string(i),std::to_string(i)); } // now key1 one should not be near rest = nearCache.get("key1"); // remote get. Stored near (this delete key2 nearly) delete rest; rest = nearCache.get("key2"); // remote get. Stored near (this delete key3 nearly) delete rest; rest = nearCache.get("key1"); // near delete rest; std::map<std::string,std::string> statsEnd= nearCache.stats(); auto hitsEnd = std::stoi(statsEnd["hits"]); auto missesEnd = std::stoi(statsEnd["misses"]); std::cout << "Remote misses is: " << missesEnd-missesBegin << "" << std::endl; std::cout << "Remote hits is: " << hitsEnd-hitsBegin << "" << std::endl; } catch (Exception &e) { } try { nearCacheManager.stop(); } catch (Exception &e) { } }
int main(int argc, char** argv) { std::cout << "Tests for Query" << std::endl; ConfigurationBuilder builder; builder.addServer().host(argc > 1 ? argv[1] : "127.0.0.1").port(argc > 2 ? atoi(argv[2]) : 11222).protocolVersion(Configuration::PROTOCOL_VERSION_24); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); cacheManager.start(); //Create the Protobuf Metadata cache peer with a Protobuf marshaller auto *km = new BasicTypesProtoStreamMarshaller<std::string>(); auto *vm = new BasicTypesProtoStreamMarshaller<std::string>(); auto metadataCache = cacheManager.getCache<std::string, std::string>( km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy,PROTOBUF_METADATA_CACHE_NAME, false); // Install the data model into the Protobuf metadata cache metadataCache.put("sample_bank_account/bank.proto", read("proto/bank.proto")); if (metadataCache.containsKey(ERRORS_KEY_SUFFIX)) { std::cerr << "fail: error in registering .proto model" << std::endl; return -1; } //Create the application cache peer with a Protobuf marshaller auto *testkm = new BasicTypesProtoStreamMarshaller<int>(); auto *testvm = new ProtoStreamMarshaller<sample_bank_account::User>(); auto testCache = cacheManager.getCache<int, sample_bank_account::User>( testkm, &Marshaller<int>::destroy, testvm, &Marshaller<sample_bank_account::User>::destroy, "namedCache", false); //Fill the cache with the application data: two users Tom and Jerry testCache.clear(); sample_bank_account::User_Address a; sample_bank_account::User user1; user1.set_id(3); user1.set_name("Tom"); user1.set_surname("Cat"); user1.set_gender(sample_bank_account::User_Gender_MALE); sample_bank_account::User_Address * addr= user1.add_addresses(); addr->set_street("Via Roma"); addr->set_number(3); addr->set_postcode("202020"); testCache.put(3, user1); user1.set_id(4); user1.set_name("Jerry"); user1.set_surname("Mouse"); addr->set_street("Via Milano"); user1.set_gender(sample_bank_account::User_Gender_MALE); testCache.put(4, user1); // Simple query to get User objects { QueryRequest qr; std::cout << "Query: from sample_bank_account.User" << std::endl; qr.set_jpqlstring("from sample_bank_account.User"); QueryResponse resp = testCache.query(qr); std::vector<sample_bank_account::User> res; unwrapResults(resp, res); for (auto i = 0; i < res.size(); i++) { std::cout << "User(id=" << res[i].id() << ",name=" << res[i].name() << ",surname=" << res[i].surname() << ")" << std::endl; } } // Simple query to get User objects with where condition { QueryRequest qr; std::cout << "from sample_bank_account.User u where u.addresses.street=\"Via Milano\"" << std::endl; qr.set_jpqlstring("from sample_bank_account.User u where u.addresses.street=\"Via Milano\""); QueryResponse resp = testCache.query(qr); std::vector<sample_bank_account::User> res; unwrapResults(resp, res); for (auto i = 0; i < res.size(); i++) { std::cout << "User(id=" << res[i].id() << ",name=" << res[i].name() << ",surname=" << res[i].surname() << ")" << std::endl; } } // Simple query to get projection (name, surname) { QueryRequest qr; std::cout << "Query: select u.name, u.surname from sample_bank_account.User u" << std::endl; qr.set_jpqlstring( "select u.name, u.surname from sample_bank_account.User u"); QueryResponse resp = testCache.query(qr); //Typed resultset std::vector<std::tuple<std::string, std::string> > prjRes; unwrapProjection(resp, prjRes); for (auto i = 0; i < prjRes.size(); i++) { std::cout << "Name: " << std::get<0> (prjRes[i]) << " Surname: " << std::get<1> (prjRes[i]) << std::endl; } } { QueryRequest qr; qr.set_jpqlstring("select count(u.id) from sample_bank_account.User u"); QueryResponse resp = testCache.query(qr); int i = unwrapSingleResult<int>(resp); std::cout << "Result is: " << i << std::endl; } cacheManager.stop(); return 0; }
int main(int argc, char** argv) { int result=0; std::cout << "Tests for CacheManager" << std::endl; { ConfigurationBuilder builder; builder.addServer().host(argc > 1 ? argv[1] : "127.0.0.1").port(argc > 2 ? atoi(argv[2]) : 11222); builder.protocolVersion(Configuration::PROTOCOL_VERSION_24); // builder.balancingStrategyProducer(transport::MyRoundRobinBalancingStrategy::newInstance); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); RemoteCache<std::string, std::string> &cachef1 = cacheManager.getCache<std::string, std::string>(false); RemoteCache<std::string, std::string> &cachet1 = cacheManager.getCache<std::string, std::string>(true); RemoteCache<std::string, std::string> &cachenf1 = cacheManager.getCache<std::string, std::string>("namedCache",false); RemoteCache<std::string, std::string> &cachent1 = cacheManager.getCache<std::string, std::string>("namedCache",true); RemoteCache<std::string, std::string> &cachet2 = cacheManager.getCache<std::string, std::string>(true); RemoteCache<std::string, std::string> &cachef2 = cacheManager.getCache<std::string, std::string>(false); RemoteCache<std::string, std::string> &cachenf2 = cacheManager.getCache<std::string, std::string>("namedCache",false); RemoteCache<std::string, std::string> &cachent2 = cacheManager.getCache<std::string, std::string>("namedCache",true); if (&cachef1 != &cachef2) { std::cerr << "Got two different cache instances(false): " << &cachef1 << " " << &cachef2 << std::endl; result=1; } if (&cachet1 != &cachet2) { std::cerr << "Got two different cache instances(false): " << &cachet1 << " " << &cachet2 << std::endl; result=1; } if (&cachef1 != &cachef2) { std::cerr << "Got two different cache instances(false): " << &cachenf1 << " " << &cachenf2 << std::endl; result=1; } if (&cachef1 != &cachef2) { std::cerr << "Got two different cache instances(false): " << &cachent1 << " " << &cachent2 << std::endl; result=1; } } if (result!=0) return result; std::cout << "PASS: Tests for CacheManager" << std::endl; // Call basic test for every marshaller and every codec std::cout << "Basic Test with BasicMarshaller" << std::endl; { ConfigurationBuilder builder; builder.addServer().host(argc > 1 ? argv[1] : "127.0.0.1").port(argc > 2 ? atoi(argv[2]) : 11222); builder.protocolVersion(Configuration::PROTOCOL_VERSION_24); // builder.balancingStrategyProducer(transport::MyRoundRobinBalancingStrategy::newInstance); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); BasicMarshaller<std::string> *km = new BasicMarshaller<std::string>(); BasicMarshaller<std::string> *vm = new BasicMarshaller<std::string>(); RemoteCache<std::string, std::string> cache = cacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy); cacheManager.start(); result = basicTest<std::string, std::string>(cacheManager, cache); try { std::map<std::string,std::string> s; std::string argName = std::string("a"); std::string argValue = std::string("b"); // execute() operation needs explicit JBossMarshalling<string> format for argument values s.insert(std::pair<std::string, std::string>(argName,JBasicMarshaller<std::string>::addPreamble(argValue))); std::string script ("// mode=local,language=javascript\n " "var cache = cacheManager.getCache(\"namedCache\");\n" "cache.put(\"a\", \"abc\");\n" "cache.put(\"b\", \"b\");\n" "cache.get(\"a\");\n"); std::string script_name("script.js"); std::string p_script_name=JBasicMarshaller<std::string>::addPreamble(script_name); std::string p_script=JBasicMarshaller<std::string>::addPreamble(script); RemoteCache<std::string, std::string> scriptCache=cacheManager.getCache<std::string,std::string>("___script_cache",false); scriptCache.put(p_script_name, p_script); std::vector<unsigned char> execResult = cache.execute(script_name,s); // We know the remote script returns a string and // we use the helper to unmarshall std::string res(JBasicMarshallerHelper::unmarshall<std::string>((char*)execResult.data())); if (res.compare("abc")!=0) { std::cerr << "fail: cache.exec() returned unexpected result"<< std::endl; return 1; } } catch (const Exception& e) { std::cout << "is: " << typeid(e).name() << '\n'; std::cerr << "fail unexpected exception: " << e.what() << std::endl; return 1; } std::cout << "PASS: script execution on server" << std::endl; cacheManager.stop(); } if (result!=0) return result; std::cout << "Basic Test with JBasicMarshaller" << std::endl; { ConfigurationBuilder builder; // builder.balancingStrategyProducer(transport::MyRoundRobinBalancingStrategy::newInstance); builder.balancingStrategyProducer(nullptr); builder.addServer().host(argc > 1 ? argv[1] : "127.0.0.1").port(argc > 2 ? atoi(argv[2]) : 11222); builder.protocolVersion(Configuration::PROTOCOL_VERSION_24); RemoteCacheManager cacheManager(builder.build(), false); JBasicMarshaller<std::string> *km = new JBasicMarshaller<std::string>(); JBasicMarshaller<std::string> *vm = new JBasicMarshaller<std::string>(); RemoteCache<std::string, std::string> cache = cacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy); cacheManager.start(); result = basicTest<std::string, std::string>(cacheManager, cache); try { std::map<std::string,std::string> s; std::string argName = std::string("a"); std::string argValue = std::string("b"); // execute() operation needs explicit JBossMarshalling<string> format for argument values s.insert(std::pair<std::string, std::string>(argName,JBasicMarshaller<std::string>::addPreamble(argValue))); std::string script ("// mode=local,language=javascript\n " "var cache = cacheManager.getCache(\"namedCache\");\n" "cache.put(\"a\", \"abc\");\n" "cache.put(\"b\", \"b\");\n" "cache.get(\"a\");\n"); std::string script_name("script.js"); cacheManager.getCache<std::string,std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy,"___script_cache").put(script_name, script); std::vector<unsigned char> execResult = cache.execute(script_name,s); // We know the remote script returns a string and // we use the helper to unmarshall std::string res(JBasicMarshallerHelper::unmarshall<std::string>((char *)execResult.data())); if (res.compare("abc")!=0) { std::cerr << "fail: cache.exec() returned unexpected result"<< std::endl; return 1; } } catch (const Exception& e) { std::cout << "is: " << typeid(e).name() << '\n'; std::cerr << "fail unexpected exception: " << e.what() << std::endl; return 1; } std::cout << "PASS: script execution on server" << std::endl; cacheManager.stop(); } return result; }
int main(int argc, char** argv) { int result = 0; { ConfigurationBuilder builder; simple_data = "writer"; secret_data = "somePassword"; builder.protocolVersion(argc > 1 ? argv[1] : Configuration::PROTOCOL_VERSION_24); builder.addServer().host(argc > 2 ? argv[2] : "127.0.0.1").port(argc > 3 ? atoi(argv[3]) : 11222); builder.security().authentication().saslMechanism("PLAIN").serverFQDN( "node0").callbackHandler(callbackHandler).enable(); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); BasicMarshaller<std::string> *km = new BasicMarshaller<std::string>(); BasicMarshaller<std::string> *vm = new BasicMarshaller<std::string>(); RemoteCache<std::string, std::string> cache = cacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy, std::string("authCache")); cacheManager.start(); cache.put("key", "value"); try { std::shared_ptr<std::string> ret(cache.get("key")); std::cerr << "FAIL: 'writer' should not read" << std::endl; return -1; } catch (Exception& ex) { } std::cout << "PASS: '******' sasl authorization" << std::endl; cacheManager.stop(); } { ConfigurationBuilder builder; simple_data = "reader"; secret_data = "password"; builder.protocolVersion(argc > 1 ? argv[1] : Configuration::PROTOCOL_VERSION_24); builder.addServer().host(argc > 2 ? argv[2] : "127.0.0.1").port(argc > 3 ? atoi(argv[3]) : 11222); builder.security().authentication().saslMechanism("DIGEST-MD5").serverFQDN( "node0").callbackHandler(callbackHandler).enable(); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); BasicMarshaller<std::string> *km = new BasicMarshaller<std::string>(); BasicMarshaller<std::string> *vm = new BasicMarshaller<std::string>(); RemoteCache<std::string, std::string> cache = cacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy, std::string("authCache")); cacheManager.start(); std::shared_ptr<std::string> ret(cache.get("key")); try { cache.put("key", "value"); std::cerr << "FAIL: 'reader' should not write" << std::endl; return -1; } catch (Exception& ex) { } std::cout << "PASS: '******' sasl authorization" << std::endl; cacheManager.stop(); } #if !defined _WIN32 && !defined _WIN64 { kinit(); ConfigurationBuilder builder; simple_data = "*****@*****.**"; secret_data = "lessStrongPassword"; builder.protocolVersion(argc > 1 ? argv[1] : Configuration::PROTOCOL_VERSION_24); builder.addServer().host(argc > 2 ? argv[2] : "127.0.0.1").port(argc > 3 ? atoi(argv[3]) : 11222); builder.security().authentication().saslMechanism("GSSAPI").serverFQDN( "node0").callbackHandler(callbackHandler).enable(); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); BasicMarshaller<std::string> *km = new BasicMarshaller<std::string>(); BasicMarshaller<std::string> *vm = new BasicMarshaller<std::string>(); RemoteCache<std::string, std::string> cache = cacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy, std::string("authCache")); cacheManager.start(); try { cache.put("key", "value"); std::shared_ptr<std::string> ret(cache.get("key")); result = 0; } catch (Exception& ex) { std::cerr << "FAIL: 'supervisor' should read and write" << std::endl; result = -1; } cacheManager.stop(); std::cout << "PASS: '******' sasl authorization" << std::endl; kdestroy(); } #endif return result; }
// Hotrod 2.8 with mediatype allows to store and retrieve entries in different data format // this can be done specifying the mediatype for the communication int main(int argc, char** argv) { ConfigurationBuilder builder; builder.protocolVersion(Configuration::PROTOCOL_VERSION_28); builder.addServer().host("127.0.0.1").port(11222); builder.balancingStrategyProducer(nullptr); RemoteCacheManager cacheManager(builder.build(), false); cacheManager.start(); std::cout << "Tests for CacheManager" << std::endl; Marshaller<std::string> *km = new JBasicMarshaller<std::string>(); Marshaller<std::string> *vm = new JBasicMarshaller<std::string>(); RemoteCache<std::string, std::string> cache = cacheManager.getCache<std::string, std::string>(km, &Marshaller<std::string>::destroy, vm, &Marshaller<std::string>::destroy, std::string("transcodingCache")); // Define a data format for json DataFormat<std::string, std::string> df; df.keyMediaType = MediaType(APPLICATION_UNKNOWN_TYPE); df.valueMediaType = MediaType(APPLICATION_JSON_TYPE); df.valueMarshaller.reset(new BasicMarshaller<std::string>()); RemoteCache<std::string, std::string> cacheJson = cache.withDataFormat(&df); // Define a data forma for jboss marshaller DataFormat<std::string, std::string> df1; df1.keyMediaType = MediaType(APPLICATION_JBOSS_MARSHALLING_TYPE); df1.valueMediaType = MediaType(APPLICATION_JBOSS_MARSHALLING_TYPE); RemoteCache<std::string, std::string> cacheJBoss = cache.withDataFormat(&df1); std::string k1("key13"); std::string k2("key14"); std::string v1("boron"); std::string v2("chlorine"); cache.clear(); // put cache.put(k1, v1); std::unique_ptr<std::string> rv(cache.get(k1)); assert_not_null("get returned null!", __LINE__, rv); if (rv->compare(v1)) { std::cerr << "get/put fail for " << k1 << " got " << *rv << " expected " << v1 << std::endl; return 1; } cache.put(k2, v2); std::unique_ptr<std::string> rv2(cache.get(k2)); assert_not_null("get returned null!", __LINE__, rv2); if (rv2->compare(v2)) { std::cerr << "get/put fail for " << k2 << " got " << *rv2 << " expected " << v2 << std::endl; return 1; } std::unique_ptr<std::string> rv2Json(cacheJson.get(k2)); assert_not_null("get returned null!", __LINE__, rv2Json); if (rv2Json->compare("\"chlorine\"")) { std::cerr << "get/put fail for " << k2 << " got " << *rv2 << " expected \"boron\"" << std::endl; return 1; } std::unique_ptr<std::string> rv2JBoss(cacheJBoss.get(k2)); assert_not_null("get returned null!", __LINE__, rv2JBoss); if (rv2JBoss->compare(v2)) { std::cerr << "get/put fail for " << k2 << " got " << *rv2JBoss << " expected " << v2 << std::endl; return 1; } }