int RequestProcessor::process(request_prefix_hides_by_proxy *req,
request_prefix_hides_by_proxy *&post_req) {
int ret = TAIR_RETURN_SUCCESS;
vector<tair_client_api*> *clients = invalid_loader->get_client_list(req->group_name);
if (clients != NULL) {
data_entry pkey;
tair_dataentry_set mkey_set;
tair_dataentry_set failed_key_set;
if (req->key != NULL) {
mkey_set.insert(req->key);
split_key(req->key, &pkey, NULL);
} else if (req->key_list != NULL) {
tair_dataentry_set::iterator itr = req->key_list->begin();
split_key(*itr, &pkey, NULL);
while (itr != req->key_list->end()) {
mkey_set.insert(*itr);
++itr;
}
}
for (size_t i = 0; i < clients->size(); ++i) {
tair_client_api *client = clients->at(i);
key_code_map_t key_code_map;
if ((ret = client->hides(req->area, mkey_set, key_code_map)) != TAIR_RETURN_SUCCESS) {
key_code_map_t::iterator itr = key_code_map.begin();
while (itr != key_code_map.end()) {
if (itr->second != TAIR_RETURN_DATA_NOT_EXIST && itr->second != TAIR_RETURN_DATA_EXPIRED) {
data_entry *mkey = new data_entry();
merge_key(pkey, *itr->first, *mkey);
std::vector<std::string> servers;
client->get_server_with_key(*mkey, servers);
log_error("[FATAL ERROR] PrefixHidesFailure: Group %s, DataServer %s.",
req->group_name, servers[0].c_str());
if (failed_key_set.insert(mkey).second == false) {
delete mkey;
}
}
++itr;
}
defree(key_code_map);
}
}
if (!failed_key_set.empty()) {
post_req = new request_prefix_hides_by_proxy();
post_req->set_group_name(req->group_name);
post_req->area = req->area;
tair_dataentry_set::iterator itr = failed_key_set.begin();
while (itr != failed_key_set.end()) {
post_req->add_key(*itr++);
}
}
ret = TAIR_RETURN_SUCCESS;
mkey_set.clear();
} else {
log_error("[FATAL ERROR] cannot find clients, group %s not added, or still loading", req->group_name);
ret = TAIR_RETURN_INVAL_CONN_ERROR;
}
return ret;
}
static void interpret_text_settings(const ds::cfg::Settings &s, std::unordered_map<std::string, ds::cfg::Text>& out) {
// Do the name first, because that determines whether an entry exists.
s.forEachTextKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && right == "name") {
std::string v = s.getText(key, 0, ds::EMPTY_SZ);
if (!v.empty()) {
if (out.empty()) {
out[left] = ds::cfg::Text(v, left, 10.0f, 1.0f, ci::ColorA(1.0f, 1.0f, 1.0f, 1.0f));
} else {
auto found = out.find(left);
if (found != out.end()) {
found->second.mFont = v;
} else {
out[left] = ds::cfg::Text(v, left, 10.0f, 1.0f, ci::ColorA(1.0f, 1.0f, 1.0f, 1.0f));
}
}
}
}
});
// Floats (size, leading)
s.forEachFloatKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && !out.empty()) {
auto found = out.find(left);
if (found != out.end()) {
if (right == "size") found->second.mSize = s.getFloat(key, 0, found->second.mSize);
else if (right == "leading") found->second.mLeading = s.getFloat(key, 0, found->second.mLeading);
}
}
});
// Color (color)
s.forEachColorAKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && !out.empty()) {
auto found = out.find(left);
if (found != out.end()) {
if (right == "color") found->second.mColor = s.getColorA(key, 0, found->second.mColor);
}
}
});
// Text (alignment)
s.forEachTextKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && !out.empty()) {
auto found = out.find(left);
if (found != out.end()) {
if (right == "alignment") {
found->second.mAlignment = ds::ui::Alignment::fromString(s.getText(key, 0, ""));
}
}
}
});
}
static void read_nine_patch_cfg(const std::string& path, std::unordered_map<std::string, ds::cfg::NinePatch>& out) {
ds::cfg::Settings s;
s.readFrom(path, false);
// Do the type first, because that determines whether an entry exists.
s.forEachTextKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && right == "type") {
ds::cfg::NinePatch::Type type = type_from(s.getText(key, 0, ds::EMPTY_SZ));
if (type != ds::cfg::NinePatch::EMPTY) {
if (out.empty()) {
out[left] = ds::cfg::NinePatch(type);
} else {
auto found = out.find(left);
if (found != out.end()) {
found->second.mType = type;
} else {
out[left] = ds::cfg::NinePatch(type);
}
}
}
}
});
// Floats
s.forEachFloatKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && !out.empty()) {
auto found = out.find(left);
if (found != out.end()) {
found->second.mStore.setFloat(right, s.getFloat(key, 0, 0.0f));
}
}
});
// Color (color)
s.forEachColorAKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && !out.empty()) {
auto found = out.find(left);
if (found != out.end()) {
found->second.mStore.setColorA(right, s.getColorA(key, 0, ci::ColorA()));
}
}
});
// Strings (everything but type)
s.forEachTextKey([&s, &out](const std::string& key) {
std::string left, right;
if (split_key(key, left, right) && !out.empty() && right != "type") {
auto found = out.find(left);
if (found != out.end()) {
found->second.mStore.setString(right, s.getText(key, 0, ""));
}
}
});
}
static int prune_p(void *rock,
const char *key, size_t keylen,
const char *data, size_t datalen __attribute__((unused)))
{
struct prunerock *prock = (struct prunerock *) rock;
time_t mark, *expmark = NULL;
duplicate_key_t dkey = DUPLICATE_INITIALIZER;
int r;
prock->count++;
r = split_key(key, keylen, &dkey);
if (r) return 1; /* broken record, want to prune it */
/* grab the rcpt, make sure its a mailbox and lookup its expire time */
if (prock->expire_table && dkey.to[0] && dkey.to[0] != '.') {
expmark = (time_t *) hash_lookup(dkey.to, prock->expire_table);
}
/* grab the mark */
memcpy(&mark, data, sizeof(time_t));
/* check if we should prune this entry */
return (mark < (expmark ? *expmark : prock->expmark));
}
bool set(const std::string &key, int value) const {
HKEY hKey;
DWORD disp;
std::string path;
std::string name;
split_key(key, path, name);
LONG ret = RegCreateKeyEx(HKEY_CURRENT_USER, path.c_str(), 0, "AESKULAP", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &disp);
if( ret != ERROR_SUCCESS )
{
RegCloseKey(hKey);
return false;
}
ret = RegSetValueEx(hKey, name.c_str(), 0, REG_DWORD, (BYTE*)&value, sizeof(value));
RegCloseKey(hKey);
return ret==ERROR_SUCCESS;
}
std::string get_string(const std::string &dir) const {
HKEY hKey;
DWORD ret;
DWORD type;
DWORD len;
char val[512];
std::string retval;
std::string key, name;
split_key(dir, key, name);
ret = RegOpenKeyEx(HKEY_CURRENT_USER, key.c_str(), 0, KEY_READ, &hKey);
if( ret!=ERROR_SUCCESS )
return "";
len = sizeof(val);
ret = RegQueryValueEx(hKey, name.c_str(), NULL, &type, (BYTE*)val, &len);
if( ret!=ERROR_SUCCESS || type != REG_SZ)
retval = "";
else
retval = val;
RegCloseKey(hKey);
return retval;
}
int get_int(const std::string &dir) const {
HKEY hKey;
DWORD ret;
DWORD type;
DWORD len;
DWORD val;
int retval;
std::string key, name;
split_key(dir, key, name);
ret = RegOpenKeyEx(HKEY_CURRENT_USER, key.c_str(), 0, KEY_READ, &hKey);
if( ret!=ERROR_SUCCESS )
return -1;
len = sizeof(val);
type=REG_DWORD;
ret = RegQueryValueEx(hKey, name.c_str(), NULL, &type, (BYTE*)&val, &len);
if( ret!=ERROR_SUCCESS || type != REG_DWORD )
retval = -1;
else
retval = val;
RegCloseKey(hKey);
return retval;
}
static int find_cb(void *rock, const char *key, size_t keylen,
const char *data, size_t datalen)
{
struct findrock *frock = (struct findrock *) rock;
duplicate_key_t dkey = DUPLICATE_INITIALIZER;
time_t mark;
unsigned long uid = 0;
int r;
r = split_key(key, keylen, &dkey);
if (r) return 0; /* ignore broken records */
/* make sure its a mailbox */
if (dkey.to[0] == '.') return 0;
/* grab the mark and uid */
memcpy(&mark, data, sizeof(time_t));
if (datalen > (int) sizeof(mark))
memcpy(&uid, data + sizeof(mark), sizeof(unsigned long));
r = (*frock->proc)(&dkey, mark, uid, frock->rock);
return r;
}
