markow
/
ckpool
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Replace all use of instance for user_instance_t with user for clarity

master
ckolivas 10 years ago
parent
192c2d0dbc
commit
eb9e3d06c5
1 changed files with 96 additions and 96 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 192
      src/stratifier.c

192
src/stratifier.c
Unescape View File

@ -1393,7 +1393,7 @@ static void drop_client(sdata_t *sdata, int64_t id)
{
int dropped = 0, aged = 0, killed = 0;
stratum_instance_t *client, *tmp;
user_instance_t *instance = NULL;
user_instance_t *user = NULL;
time_t now_t = time(NULL);
ckpool_t *ckp = NULL;
bool dec = false;
@ -1403,7 +1403,7 @@ static void drop_client(sdata_t *sdata, int64_t id)
ck_wlock(&sdata->instance_lock);
client = __instance_by_id(sdata, id);
if (client) {
instance = client->user_instance;
user = client->user_instance;
if (client->authorised) {
dec = true;
ckp = client->ckp;
@ -1411,7 +1411,7 @@ static void drop_client(sdata_t *sdata, int64_t id)
/* If the client is still holding a reference, don't drop them
* now but wait till the reference is dropped */
if (likely(!client->ref))
dropped = __drop_client(sdata, client, instance);
dropped = __drop_client(sdata, client, user);
else
client->dropped = true;
client->authorised = false;
@ -1451,7 +1451,7 @@ static void drop_client(sdata_t *sdata, int64_t id)
/* Decrease worker count outside of instance_lock to avoid recursive
* locking */
if (dec)
dec_worker(ckp, instance);
dec_worker(ckp, user);
}
static void stratum_broadcast_message(sdata_t *sdata, const char *msg)
@ -1487,18 +1487,18 @@ static void reconnect_clients(sdata_t *sdata, const char *cmd)
static void reset_bestshares(sdata_t *sdata)
{
user_instance_t *instance, *tmpuser;
user_instance_t *user, *tmpuser;
stratum_instance_t *client, *tmp;
ck_rlock(&sdata->instance_lock);
HASH_ITER(hh, sdata->stratum_instances, client, tmp) {
client->best_diff = 0;
}
HASH_ITER(hh, sdata->user_instances, instance, tmpuser) {
HASH_ITER(hh, sdata->user_instances, user, tmpuser) {
worker_instance_t *worker;
instance->best_diff = 0;
DL_FOREACH(instance->worker_instances, worker) {
user->best_diff = 0;
DL_FOREACH(user->worker_instances, worker) {
worker->best_diff = 0;
}
}
@ -2066,42 +2066,42 @@ static double dsps_from_key(json_t *val, const char *key)
}
/* Enter holding a reference count */
static void read_userstats(ckpool_t *ckp, user_instance_t *instance)
static void read_userstats(ckpool_t *ckp, user_instance_t *user)
{
char s[512];
json_t *val;
FILE *fp;
int ret;
snprintf(s, 511, "%s/users/%s", ckp->logdir, instance->username);
snprintf(s, 511, "%s/users/%s", ckp->logdir, user->username);
fp = fopen(s, "re");
if (!fp) {
LOGINFO("User %s does not have a logfile to read", instance->username);
LOGINFO("User %s does not have a logfile to read", user->username);
return;
}
memset(s, 0, 512);
ret = fread(s, 1, 511, fp);
fclose(fp);
if (ret < 1) {
LOGINFO("Failed to read user %s logfile", instance->username);
LOGINFO("Failed to read user %s logfile", user->username);
return;
}
val = json_loads(s, 0, NULL);
if (!val) {
LOGINFO("Failed to json decode user %s logfile: %s", instance->username, s);
LOGINFO("Failed to json decode user %s logfile: %s", user->username, s);
return;
}
tv_time(&instance->last_share);
instance->dsps1 = dsps_from_key(val, "hashrate1m");
instance->dsps5 = dsps_from_key(val, "hashrate5m");
instance->dsps60 = dsps_from_key(val, "hashrate1hr");
instance->dsps1440 = dsps_from_key(val, "hashrate1d");
instance->dsps10080 = dsps_from_key(val, "hashrate7d");
json_get_double(&instance->best_diff, val, "bestshare");
LOGINFO("Successfully read user %s stats %f %f %f %f %f %f", instance->username,
instance->dsps1, instance->dsps5, instance->dsps60, instance->dsps1440,
instance->dsps10080, instance->best_diff);
tv_time(&user->last_share);
user->dsps1 = dsps_from_key(val, "hashrate1m");
user->dsps5 = dsps_from_key(val, "hashrate5m");
user->dsps60 = dsps_from_key(val, "hashrate1hr");
user->dsps1440 = dsps_from_key(val, "hashrate1d");
user->dsps10080 = dsps_from_key(val, "hashrate7d");
json_get_double(&user->best_diff, val, "bestshare");
LOGINFO("Successfully read user %s stats %f %f %f %f %f %f", user->username,
user->dsps1, user->dsps5, user->dsps60, user->dsps1440,
user->dsps10080, user->best_diff);
json_decref(val);
}
@ -2151,7 +2151,7 @@ static user_instance_t *generate_user(ckpool_t *ckp, stratum_instance_t *client,
const char *workername)
{
char *base_username = strdupa(workername), *username;
bool new_instance = false, new_worker = false;
bool new_user = false, new_worker = false;
sdata_t *sdata = ckp->data;
worker_instance_t *tmp;
user_instance_t *user;
@ -2171,7 +2171,7 @@ static user_instance_t *generate_user(ckpool_t *ckp, stratum_instance_t *client,
user = ckzalloc(sizeof(user_instance_t));
user->auth_backoff = 3; /* Set initial backoff to 3 seconds */
strcpy(user->username, username);
new_instance = true;
new_user = true;
user->id = sdata->user_instance_id++;
HASH_ADD_STR(sdata->user_instances, username, user);
}
@ -2196,12 +2196,12 @@ static user_instance_t *generate_user(ckpool_t *ckp, stratum_instance_t *client,
DL_APPEND(user->clients, client);
ck_wunlock(&sdata->instance_lock);
if (CKP_STANDALONE(ckp) && new_instance)
if (CKP_STANDALONE(ckp) && new_user)
read_userstats(ckp, user);
if (CKP_STANDALONE(ckp) && new_worker)
read_workerstats(ckp, client->worker_instance);
if (new_instance && !ckp->proxy) {
if (new_user && !ckp->proxy) {
/* Is this a btc address based username? */
if (len > 26 && len < 35)
user->btcaddress = test_address(ckp, username);
@ -2219,7 +2219,7 @@ static user_instance_t *generate_user(ckpool_t *ckp, stratum_instance_t *client,
* entered with client holding a ref count. */
static int send_recv_auth(stratum_instance_t *client)
{
user_instance_t *user_instance = client->user_instance;
user_instance_t *user = client->user_instance;
ckpool_t *ckp = client->ckp;
sdata_t *sdata = ckp->data;
char *buf = NULL, *json_msg;
@ -2233,7 +2233,7 @@ static int send_recv_auth(stratum_instance_t *client)
sprintf(cdfield, "%lu,%lu", now.tv_sec, now.tv_nsec);
val = json_object();
json_set_string(val, "username", user_instance->username);
json_set_string(val, "username", user->username);
json_set_string(val, "workername", client->workername);
json_set_string(val, "poolinstance", ckp->name);
json_set_string(val, "useragent", client->useragent);
@ -2244,7 +2244,7 @@ static int send_recv_auth(stratum_instance_t *client)
json_set_string(val, "createby", "code");
json_set_string(val, "createcode", __func__);
json_set_string(val, "createinet", client->address);
if (user_instance->btcaddress)
if (user->btcaddress)
json_msg = ckdb_msg(ckp, val, ID_ADDRAUTH);
else
json_msg = ckdb_msg(ckp, val, ID_AUTH);
@ -2280,7 +2280,7 @@ static int send_recv_auth(stratum_instance_t *client)
cmd = response;
strsep(&cmd, "=");
LOGINFO("User %s Worker %s got auth response: %s cmd: %s",
user_instance->username, client->workername,
user->username, client->workername,
response, cmd);
val = json_loads(cmd, 0, &err_val);
if (unlikely(!val))
@ -2289,13 +2289,13 @@ static int send_recv_auth(stratum_instance_t *client)
json_get_string(&secondaryuserid, val, "secondaryuserid");
json_get_int(&worker->mindiff, val, "difficultydefault");
client->suggest_diff = worker->mindiff;
if (!user_instance->auth_time)
user_instance->auth_time = time(NULL);
if (!user->auth_time)
user->auth_time = time(NULL);
}
if (secondaryuserid && (!safecmp(response, "ok.authorise") ||
!safecmp(response, "ok.addrauth"))) {
if (!user_instance->secondaryuserid)
user_instance->secondaryuserid = secondaryuserid;
if (!user->secondaryuserid)
user->secondaryuserid = secondaryuserid;
else
dealloc(secondaryuserid);
ret = 0;
@ -2348,7 +2348,7 @@ static void queue_delayed_auth(stratum_instance_t *client)
static json_t *parse_authorise(stratum_instance_t *client, json_t *params_val, json_t **err_val,
const char *address, int *errnum)
{
user_instance_t *user_instance;
user_instance_t *user;
ckpool_t *ckp = client->ckp;
bool ret = false;
const char *buf;
@ -2385,16 +2385,16 @@ static json_t *parse_authorise(stratum_instance_t *client, json_t *params_val, j
*err_val = json_string("Invalid character in username");
goto out;
}
user_instance = client->user_instance = generate_user(ckp, client, buf);
client->user_id = user_instance->id;
user = client->user_instance = generate_user(ckp, client, buf);
client->user_id = user->id;
ts_realtime(&now);
client->start_time = now.tv_sec;
strcpy(client->address, address);
client->workername = strdup(buf);
if (user_instance->failed_authtime) {
if (user->failed_authtime) {
time_t now_t = time(NULL);
if (now_t < user_instance->failed_authtime + user_instance->auth_backoff) {
if (now_t < user->failed_authtime + user->auth_backoff) {
LOGNOTICE("Client %ld worker %s rate limited due to failed auth attempts",
client->id, buf);
client->dropped = true;
@ -2407,13 +2407,13 @@ static json_t *parse_authorise(stratum_instance_t *client, json_t *params_val, j
/* Preauth workers for the first 10 minutes after the user is
* first authorised by ckdb to avoid floods of worker auths.
* *errnum is implied zero already so ret will be set true */
if (user_instance->auth_time && time(NULL) - user_instance->auth_time < 600)
if (user->auth_time && time(NULL) - user->auth_time < 600)
queue_delayed_auth(client);
else
*errnum = send_recv_auth(client);
if (!*errnum)
ret = true;
else if (*errnum < 0 && user_instance->secondaryuserid) {
else if (*errnum < 0 && user->secondaryuserid) {
/* This user has already been authorised but ckdb is
* offline so we assume they already exist but add the
* auth request to the queued messages. */
@ -2423,19 +2423,19 @@ static json_t *parse_authorise(stratum_instance_t *client, json_t *params_val, j
}
if (ret) {
client->authorised = ret;
user_instance->authorised = ret;
inc_worker(ckp, user_instance);
user->authorised = ret;
inc_worker(ckp, user);
LOGNOTICE("Authorised client %ld worker %s as user %s", client->id, buf,
user_instance->username);
user_instance->auth_backoff = 3; /* Reset auth backoff time */
user->username);
user->auth_backoff = 3; /* Reset auth backoff time */
} else {
LOGNOTICE("Client %ld worker %s failed to authorise as user %s", client->id, buf,
user_instance->username);
user_instance->failed_authtime = time(NULL);
user_instance->auth_backoff <<= 1;
user->username);
user->failed_authtime = time(NULL);
user->auth_backoff <<= 1;
/* Cap backoff time to 10 mins */
if (user_instance->auth_backoff > 600)
user_instance->auth_backoff = 600;
if (user->auth_backoff > 600)
user->auth_backoff = 600;
}
out:
return json_boolean(ret);
@ -2487,7 +2487,7 @@ static void add_submit(ckpool_t *ckp, stratum_instance_t *client, int diff, bool
{
worker_instance_t *worker = client->worker_instance;
double tdiff, bdiff, dsps, drr, network_diff, bias;
user_instance_t *instance = client->user_instance;
user_instance_t *user = client->user_instance;
int64_t next_blockid, optimal;
sdata_t *sdata = ckp->data;
tv_t now_t;
@ -2535,13 +2535,13 @@ static void add_submit(ckpool_t *ckp, stratum_instance_t *client, int diff, bool
copy_tv(&worker->last_share, &now_t);
worker->idle = false;
tdiff = sane_tdiff(&now_t, &instance->last_share);
decay_time(&instance->dsps1, diff, tdiff, 60);
decay_time(&instance->dsps5, diff, tdiff, 300);
decay_time(&instance->dsps60, diff, tdiff, 3600);
decay_time(&instance->dsps1440, diff, tdiff, 86400);
decay_time(&instance->dsps10080, diff, tdiff, 604800);
copy_tv(&instance->last_share, &now_t);
tdiff = sane_tdiff(&now_t, &user->last_share);
decay_time(&user->dsps1, diff, tdiff, 60);
decay_time(&user->dsps5, diff, tdiff, 300);
decay_time(&user->dsps60, diff, tdiff, 3600);
decay_time(&user->dsps1440, diff, tdiff, 86400);
decay_time(&user->dsps10080, diff, tdiff, 604800);
copy_tv(&user->last_share, &now_t);
client->idle = false;
client->ssdc++;
@ -2808,10 +2808,10 @@ static json_t *parse_submit(stratum_instance_t *client, json_t *json_msg,
json_t *params_val, json_t **err_val)
{
bool share = false, result = false, invalid = true, submit = false;
user_instance_t *user_instance = client->user_instance;
user_instance_t *user = client->user_instance;
double diff = client->diff, wdiff = 0, sdiff = -1;
char hexhash[68] = {}, sharehash[32], cdfield[64];
const char *user, *job_id, *ntime, *nonce;
const char *workername, *job_id, *ntime, *nonce;
char *fname = NULL, *s, *nonce2;
enum share_err err = SE_NONE;
ckpool_t *ckp = client->ckp;
@ -2841,8 +2841,8 @@ static json_t *parse_submit(stratum_instance_t *client, json_t *json_msg,
*err_val = JSON_ERR(err);
goto out;
}
user = json_string_value(json_array_get(params_val, 0));
if (unlikely(!user || !strlen(user))) {
workername = json_string_value(json_array_get(params_val, 0));
if (unlikely(!workername || !strlen(workername))) {
err = SE_NO_USERNAME;
*err_val = JSON_ERR(err);
goto out;
@ -2871,7 +2871,7 @@ static json_t *parse_submit(stratum_instance_t *client, json_t *json_msg,
*err_val = JSON_ERR(err);
goto out;
}
if (safecmp(user, client->workername)) {
if (safecmp(workername, client->workername)) {
err = SE_WORKER_MISMATCH;
*err_val = JSON_ERR(err);
goto out;
@ -2913,12 +2913,12 @@ static json_t *parse_submit(stratum_instance_t *client, json_t *json_msg,
worker_instance_t *worker = client->worker_instance;
client->best_diff = sdiff;
LOGINFO("User %s worker %s client %ld new best diff %lf", user_instance->username,
LOGINFO("User %s worker %s client %ld new best diff %lf", user->username,
worker->workername, client->id, sdiff);
if (sdiff > worker->best_diff)
worker->best_diff = sdiff;
if (sdiff > user_instance->best_diff)
user_instance->best_diff = sdiff;
if (sdiff > user->best_diff)
user->best_diff = sdiff;
}
bswap_256(sharehash, hash);
__bin2hex(hexhash, sharehash, 32);
@ -2985,7 +2985,7 @@ out_unlock:
json_set_int(val, "clientid", client->id);
json_set_string(val, "enonce1", client->enonce1);
if (!CKP_STANDALONE(ckp))
json_set_string(val, "secondaryuserid", user_instance->secondaryuserid);
json_set_string(val, "secondaryuserid", user->secondaryuserid);
json_set_string(val, "nonce2", nonce2);
json_set_string(val, "nonce", nonce);
json_set_string(val, "ntime", ntime);
@ -3001,7 +3001,7 @@ out_unlock:
json_set_string(val, "createcode", __func__);
json_set_string(val, "createinet", ckp->serverurl[client->server]);
json_set_string(val, "workername", client->workername);
json_set_string(val, "username", user_instance->username);
json_set_string(val, "username", user->username);
if (ckp->logshares) {
fp = fopen(fname, "ae");
@ -3042,11 +3042,11 @@ out:
val = json_object();
json_set_int(val, "clientid", client->id);
if (!CKP_STANDALONE(ckp))
json_set_string(val, "secondaryuserid", user_instance->secondaryuserid);
json_set_string(val, "secondaryuserid", user->secondaryuserid);
json_set_string(val, "enonce1", client->enonce1);
json_set_int(val, "workinfoid", sdata->current_workbase->id);
json_set_string(val, "workername", client->workername);
json_set_string(val, "username", user_instance->username);
json_set_string(val, "username", user->username);
json_object_set(val, "error", *err_val);
json_set_int(val, "errn", err);
json_set_string(val, "createdate", cdfield);
@ -3137,7 +3137,7 @@ static void set_worker_mindiff(ckpool_t *ckp, const char *workername, int mindif
{
worker_instance_t *worker = NULL, *tmp;
char *username = strdupa(workername), *ignore;
user_instance_t *instance = NULL;
user_instance_t *user = NULL;
stratum_instance_t *client;
sdata_t *sdata = ckp->data;
@ -3146,18 +3146,18 @@ static void set_worker_mindiff(ckpool_t *ckp, const char *workername, int mindif
/* Find the user first */
ck_rlock(&sdata->instance_lock);
HASH_FIND_STR(sdata->user_instances, username, instance);
HASH_FIND_STR(sdata->user_instances, username, user);
ck_runlock(&sdata->instance_lock);
/* They may just have not connected yet */
if (!instance) {
if (!user) {
LOGINFO("Failed to find user %s in set_worker_mindiff", username);
return;
}
/* Then find the matching worker instance */
/* Then find the matching worker user */
ck_rlock(&sdata->instance_lock);
DL_FOREACH(instance->worker_instances, tmp) {
DL_FOREACH(user->worker_instances, tmp) {
if (!safecmp(workername, tmp->workername)) {
worker = tmp;
break;
@ -3186,7 +3186,7 @@ static void set_worker_mindiff(ckpool_t *ckp, const char *workername, int mindif
* if we can. Otherwise it will only act as a clamp on next share
* submission. */
ck_rlock(&sdata->instance_lock);
DL_FOREACH(instance->clients, client) {
DL_FOREACH(user->clients, client) {
if (client->worker_instance != worker)
continue;
/* Per connection suggest diff overrides worker mindiff ugh */
@ -3861,7 +3861,7 @@ static void *statsupdate(void *arg)
char suffix1[16], suffix5[16], suffix15[16], suffix60[16], cdfield[64];
char suffix360[16], suffix1440[16], suffix10080[16];
char_entry_t *char_list = NULL, *char_t, *chartmp_t;
user_instance_t *instance, *tmpuser;
user_instance_t *user, *tmpuser;
stratum_instance_t *client, *tmp;
double sps1, sps5, sps15, sps60;
int idle_workers = 0;
@ -3898,15 +3898,15 @@ static void *statsupdate(void *arg)
}
}
HASH_ITER(hh, sdata->user_instances, instance, tmpuser) {
HASH_ITER(hh, sdata->user_instances, user, tmpuser) {
worker_instance_t *worker;
bool idle = false;
if (!instance->authorised)
if (!user->authorised)
continue;
/* Decay times per worker */
DL_FOREACH(instance->worker_instances, worker) {
DL_FOREACH(user->worker_instances, worker) {
per_tdiff = tvdiff(&now, &worker->last_share);
if (per_tdiff > 60) {
decay_time(&worker->dsps1, 0, per_tdiff, 60);
@ -3948,28 +3948,28 @@ static void *statsupdate(void *arg)
}
/* Decay times per user */
per_tdiff = tvdiff(&now, &instance->last_share);
per_tdiff = tvdiff(&now, &user->last_share);
if (per_tdiff > 60) {
decay_time(&instance->dsps1, 0, per_tdiff, 60);
decay_time(&instance->dsps5, 0, per_tdiff, 300);
decay_time(&instance->dsps60, 0, per_tdiff, 3600);
decay_time(&instance->dsps1440, 0, per_tdiff, 86400);
decay_time(&instance->dsps10080, 0, per_tdiff, 604800);
decay_time(&user->dsps1, 0, per_tdiff, 60);
decay_time(&user->dsps5, 0, per_tdiff, 300);
decay_time(&user->dsps60, 0, per_tdiff, 3600);
decay_time(&user->dsps1440, 0, per_tdiff, 86400);
decay_time(&user->dsps10080, 0, per_tdiff, 604800);
idle = true;
}
ghs = instance->dsps1 * nonces;
ghs = user->dsps1 * nonces;
suffix_string(ghs, suffix1, 16, 0);
ghs = instance->dsps5 * nonces;
ghs = user->dsps5 * nonces;
suffix_string(ghs, suffix5, 16, 0);
ghs = instance->dsps60 * nonces;
ghs = user->dsps60 * nonces;
suffix_string(ghs, suffix60, 16, 0);
ghs = instance->dsps1440 * nonces;
ghs = user->dsps1440 * nonces;
suffix_string(ghs, suffix1440, 16, 0);
ghs = instance->dsps10080 * nonces;
ghs = user->dsps10080 * nonces;
suffix_string(ghs, suffix10080, 16, 0);
JSON_CPACK(val, "{ss,ss,ss,ss,ss,si,sf}",
@ -3978,10 +3978,10 @@ static void *statsupdate(void *arg)
"hashrate1hr", suffix60,
"hashrate1d", suffix1440,
"hashrate7d", suffix10080,
"workers", instance->workers,
"bestshare", instance->best_diff);
"workers", user->workers,
"bestshare", user->best_diff);
snprintf(fname, 511, "%s/users/%s", ckp->logdir, instance->username);
snprintf(fname, 511, "%s/users/%s", ckp->logdir, user->username);
fp = fopen(fname, "we");
if (unlikely(!fp)) {
LOGERR("Failed to fopen %s", fname);
@ -3991,7 +3991,7 @@ static void *statsupdate(void *arg)
fprintf(fp, "%s\n", s);
if (!idle) {
char_t = ckalloc(sizeof(char_entry_t));
ASPRINTF(&char_t->buf, "User %s:%s", instance->username, s);
ASPRINTF(&char_t->buf, "User %s:%s", user->username, s);
DL_APPEND(char_list, char_t);
}
dealloc(s);

Write Preview
Loading…
Cancel
Save