static Variant HHVM_METHOD(Memcache, get, const Variant& key,
VRefParam flags /*= null*/) {
auto data = Native::data<MemcacheData>(this_);
if (!hasAvailableServers(data)) {
return false;
}
if (key.isArray()) {
std::vector<const char *> real_keys;
std::vector<size_t> key_len;
Array keyArr = key.toArray();
real_keys.reserve(keyArr.size());
key_len.reserve(keyArr.size());
for (ArrayIter iter(keyArr); iter; ++iter) {
auto key = iter.second().toString();
String serializedKey = memcache_prepare_key(key);
char *k = new char[serializedKey.length()+1];
std::strcpy(k, serializedKey.c_str());
real_keys.push_back(k);
key_len.push_back(serializedKey.length());
}
if (!real_keys.empty()) {
const char *payload = nullptr;
size_t payload_len = 0;
uint32_t flags = 0;
const char *res_key = nullptr;
size_t res_key_len = 0;
memcached_result_st result;
memcached_return_t ret = memcached_mget(&data->m_memcache, &real_keys[0],
&key_len[0], real_keys.size());
memcached_result_create(&data->m_memcache, &result);
// To mimic PHP5 should return empty array at failure.
Array return_val = Array::Create();
while ((memcached_fetch_result(&data->m_memcache, &result, &ret))
!= nullptr) {
if (ret != MEMCACHED_SUCCESS) {
// should probably notify about errors
continue;
}
payload = memcached_result_value(&result);
payload_len = memcached_result_length(&result);
flags = memcached_result_flags(&result);
res_key = memcached_result_key_value(&result);
res_key_len = memcached_result_key_length(&result);
return_val.set(String(res_key, res_key_len, CopyString),
memcache_fetch_from_storage(payload,
payload_len, flags));
}
memcached_result_free(&result);
for ( size_t i = 0 ; i < real_keys.size() ; i++ ) {
delete [] real_keys[i];
}
return return_val;
}
} else {
char *payload = nullptr;
size_t payload_len = 0;
uint32_t flags = 0;
memcached_return_t ret;
String serializedKey = memcache_prepare_key(key.toString());
if (serializedKey.length() == 0) {
return false;
}
payload = memcached_get(&data->m_memcache, serializedKey.c_str(),
serializedKey.length(), &payload_len, &flags, &ret);
/* This is for historical reasons from libmemcached*/
if (ret == MEMCACHED_END) {
ret = MEMCACHED_NOTFOUND;
}
if (ret == MEMCACHED_NOTFOUND) {
return false;
}
if (ret != MEMCACHED_SUCCESS) {
return false;
}
Variant retval = memcache_fetch_from_storage(payload, payload_len, flags);
free(payload);
return retval;
}
return false;
}
Variant c_Memcache::t_get(CVarRef key, VRefParam flags /*= null*/) {
INSTANCE_METHOD_INJECTION_BUILTIN(Memcache, Memcache::get);
TAINT_OBSERVER(TAINT_BIT_ALL, TAINT_BIT_NONE);
if (key.is(KindOfArray)) {
std::vector<const char *> real_keys;
std::vector<size_t> key_len;
Array keyArr = key.toArray();
real_keys.reserve(keyArr.size());
key_len.reserve(keyArr.size());
for (ArrayIter iter(keyArr); iter; ++iter) {
real_keys.push_back(const_cast<char *>(iter.second().toString().c_str()));
key_len.push_back(iter.second().toString().length());
}
if (!real_keys.empty()) {
const char *payload = NULL;
size_t payload_len = 0;
uint32_t flags = 0;
const char *res_key = NULL;
size_t res_key_len = 0;
memcached_result_st result;
memcached_return_t ret = memcached_mget(&m_memcache, &real_keys[0],
&key_len[0], real_keys.size());
memcached_result_create(&m_memcache, &result);
Array return_val;
while ((memcached_fetch_result(&m_memcache, &result, &ret)) != NULL) {
if (ret != MEMCACHED_SUCCESS) {
// should probably notify about errors
continue;
}
payload = memcached_result_value(&result);
payload_len = memcached_result_length(&result);
flags = memcached_result_flags(&result);
res_key = memcached_result_key_value(&result);
res_key_len = memcached_result_key_length(&result);
return_val.set(String(res_key, res_key_len, CopyString),
memcache_fetch_from_storage(payload,
payload_len, flags));
}
memcached_result_free(&result);
return return_val;
}
} else {
char *payload = NULL;
size_t payload_len = 0;
uint32_t flags = 0;
memcached_return_t ret;
String skey = key.toString();
if (skey.length() == 0) {
return false;
}
payload = memcached_get(&m_memcache, skey.c_str(), skey.length(),
&payload_len, &flags, &ret);
/* This is for historical reasons from libmemcached*/
if (ret == MEMCACHED_END) {
ret = MEMCACHED_NOTFOUND;
}
if (ret == MEMCACHED_NOTFOUND) {
return false;
}
Variant retval = memcache_fetch_from_storage(payload, payload_len, flags);
free(payload);
return retval;
}
return false;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
char *string;
size_t string_length;
uint32_t flags;
memcached_return_t rc;
memcached_server_st *servers;
int return_code= 0;
options_parse(argc, argv);
initialize_sockets();
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return EXIT_FAILURE;
}
while (optind < argc)
{
string= memcached_get(memc, argv[optind], strlen(argv[optind]),
&string_length, &flags, &rc);
if (rc == MEMCACHED_SUCCESS)
{
if (opt_displayflag)
{
if (opt_verbose)
printf("key: %s\nflags: ", argv[optind]);
printf("%x\n", flags);
}
else
{
if (opt_verbose)
{
printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
argv[optind], flags, string_length);
}
if (opt_file)
{
FILE *fp;
size_t written;
fp= fopen(opt_file, "w");
if (!fp)
{
perror("fopen");
return_code= -1;
break;
}
written= fwrite(string, 1, string_length, fp);
if (written != string_length)
{
fprintf(stderr, "error writing file (written %zu, should be %zu)\n", written, string_length);
return_code= -1;
break;
}
if (fclose(fp))
{
fprintf(stderr, "error closing file\n");
return_code= -1;
break;
}
}
else
{
printf("%.*s\n", (int)string_length, string);
}
free(string);
}
}
else if (rc != MEMCACHED_NOTFOUND)
{
fprintf(stderr, "memcat: %s: memcache error %s",
argv[optind], memcached_strerror(memc, rc));
if (memcached_last_error_errno(memc))
{
fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
}
fprintf(stderr, "\n");
return_code= -1;
break;
}
else // Unknown Issue
{
fprintf(stderr, "memcat: %s not found\n", argv[optind]);
return_code= -1;
}
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return return_code;
}
/*
* main()
*/
int main (int argc, char **argv)
{
char *server_list;
char *key;
char *value;
size_t value_len;
uint32_t flags;
memcached_return err;
/*
* Get option.
*/
if (argc != 3) {
printf("Argument error.\n");
return -1;
}
server_list = argv[1];
key = argv[2];
/*
* Init.
*/
if (mmc_init(server_list) != 0) {
printf("mmc_init() failed.\n");
return -1;
}
while (1) {
/*
* Get.
*/
value = memcached_get(pmmc, key, strlen(key), &value_len, &flags, &err);
if (err == MEMCACHED_SUCCESS) {
printf("key[%s] value[%s] len[%d]\n", key, value, value_len);
if (value)
free(value);
} else {
if (err == MEMCACHED_NOTFOUND) {
printf("MEMCACHED_NOTFOUND\n");
} else {
printf("memcached_get() error [%d]\n", err);
}
}
/*
* Set.
*/
err = memcached_set(pmmc, key, strlen(key), "",
0, 0, 0);
if (err != MEMCACHED_SUCCESS) {
printf("memcached_set() error [%d]\n", err);
}
sleep(1);
}
mmc_cleanup();
return 0;
}
