コード例 #1
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
static void ramcloudRead(void *item, void *data)
{
    wstr i = *(wstr*)item;
    struct ramcloudData *d = data;
    uint32_t actual_len;
    uint64_t version;
    uint64_t len = RAMCLOUD_DEFAULT_VALUE_LEN;

    wheatLog(WHEAT_DEBUG, "%s read key %s", __func__, i);
    wstr val = wstrNewLen(NULL, len);
    Status s = rc_read(global.client, d->table_id, i, wstrlen(i), NULL, &version, val, len, &actual_len);
    if (s != STATUS_OK) {
        if (s != STATUS_OBJECT_DOESNT_EXIST) {
            wheatLog(WHEAT_WARNING, " failed to read %s: %s", i, statusToString(s));
        }
        wstrFree(val);
        return ;
    }

    while (actual_len > len) {
        wstrFree(val);
        len = actual_len;
        val = wstrNewLen(NULL, actual_len);
        if (val == NULL) {
            wheatLog(WHEAT_WARNING, " failed to alloc memory");
            return ;
        }

        s = rc_read(global.client, d->table_id, i, wstrlen(i), NULL, &version, val, len, &actual_len);
        if (s != STATUS_OK) {
            if (s != STATUS_OBJECT_DOESNT_EXIST) {
                wheatLog(WHEAT_WARNING, " failed to read %s: %s", i, statusToString(s));
            }
            wstrFree(val);
            return ;
        }
    }

    d->retrieval_len += actual_len;
    arrayPush(d->retrievals, &val);
    struct slice ss = {(uint8_t*)(i), wstrlen(i)};
    arrayPush(d->retrievals_keys, &ss);
    ss.data = (uint8_t*)val;
    ss.len = actual_len - FLAG_SIZE;
    arrayPush(d->retrievals_vals, &ss);
    arrayPush(d->retrievals_flags, &val[actual_len-FLAG_SIZE]);
    arrayPush(d->retrievals_versions, &version);
}
コード例 #2
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
int initRamcloud(struct protocol *p)
{
    char *locator;
    char *cluster_name;
    struct configuration *conf;
    conf = getConfiguration("ramcloud-server-locator");
    locator = conf->target.ptr;
    conf = getConfiguration("ramcloud-cluster-name");
    cluster_name = conf->target.ptr;
    if (!locator || !cluster_name) {
        wheatLog(WHEAT_WARNING, "%s lack of necessary config", __func__);
        goto err;
    }

    Status s = rc_connect(locator, cluster_name, &global.client);
    if (s != STATUS_OK) {
        wheatLog(WHEAT_WARNING, "%s connect to %s: %s", __func__, locator, statusToString(s));
        goto err;
    }
    global.tables = dictCreate(&intDictType);
    ASSERT(gethostname(hostname, 255));
    wheatLog(WHEAT_NOTICE, "%s hostname is %s", __func__, hostname);
    return WHEAT_OK;

 err:
    return WHEAT_WRONG;
}
コード例 #3
0
static int ProcessRequest(lua_State *L, ModbusUserData* pModbusUserData, uint8_t isCustom) {
    uint8_t* pBuffer = NULL;
    uint16_t bufferLength = 0;
    SerialStatus status;

    if (isCustom) {
        status = MODBUS_SER_CreateCustomRequest(&(pModbusUserData->serializer), &(pModbusUserData->request));
    } else {
        status = MODBUS_SER_CreateRequest(&(pModbusUserData->serializer), &(pModbusUserData->request));
    }
    if (status != SERIAL_STATUS_OK) {
        if (pModbusUserData->allocated != NULL) {
            free(pModbusUserData->allocated);
            pModbusUserData->allocated = NULL;
        }
        lua_pushnil(L);
        lua_pushstring(L, statusToString(status));
        return 2;
    } else {
        MODBUS_SER_GetRequestPDU(&(pModbusUserData->serializer), &pBuffer, &bufferLength);
        lua_pushlstring(L, (const char*) pBuffer, (size_t) bufferLength);
        lua_pushinteger(L, MODBUS_SER_GetExpectedResponseLength(&(pModbusUserData->serializer)));
        return 2;
    }
}
コード例 #4
0
ファイル: client.cpp プロジェクト: tshipa/wilink
QString ChatClient::statusType() const
{
    if (clientPresence().type() == QXmppPresence::Available)
        return statusToString(clientPresence().availableStatusType());
    else
        return "offline";
}
コード例 #5
0
std::string TaskDeadline::taskDetailsToString() {
	std::ostringstream output;
	output << getTaskDesc() << std::endl;
	output << dateTimeToString() << std::endl;
	output << statusToString() << std::endl;
	return output.str();
}
コード例 #6
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
static void ramcloudSet(struct ramcloudData *d, wstr key, struct array *vals, uint32_t vlen, uint16_t flag, struct RejectRules *rule)
{
    wheatLog(WHEAT_DEBUG, "%s set key %s", __func__, key);
    uint64_t version;
    int i = 0;
    struct slice *slice;
    wstr val = wstrNewLen(NULL, vlen+sizeof(flag));
    while (i < narray(vals)) {
        slice = arrayIndex(vals, i);
        val = wstrCatLen(val, (char*)slice->data, slice->len);
        ++i;
    }
    val = wstrCatLen(val, (char*)&flag, FLAG_SIZE);

    Status s = rc_write(global.client, d->table_id, key, wstrlen(key), val, wstrlen(val),
                        rule, &version);
    wstrFree(val);
    if (s != STATUS_OK) {
        // cas command
        if (rule->versionNeGiven) {
            if (s == STATUS_WRONG_VERSION)
                sliceTo(&d->storage_response, (uint8_t*)EXISTS, sizeof(EXISTS)-1);
            else if (s == STATUS_OBJECT_DOESNT_EXIST)
                sliceTo(&d->storage_response, (uint8_t*)NOT_FOUND, sizeof(NOT_FOUND)-1);
        } else if ((rule->doesntExist && s == STATUS_OBJECT_DOESNT_EXIST) ||
                   (rule->exists && s == STATUS_OBJECT_EXISTS)) {
            sliceTo(&d->storage_response, (uint8_t*)NOT_STORED, sizeof(NOT_STORED)-1);
        } else {
            wheatLog(WHEAT_WARNING, "%s failed to set %s: %s", __func__, key, statusToString(s));
            sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
        }
    } else {
        sliceTo(&d->storage_response, (uint8_t*)STORED, sizeof(STORED)-1);
    }
}
コード例 #7
0
std::string TaskDeadline::outputToString() {
	std::ostringstream output;
	output << getTaskType() << "<>"; 
	output << getTaskDesc() << "<>";
	output << _deadline.dateToString(true) << " " << _deadline.timeToString() << "<>";
	output << statusToString() << std::endl;
	return output.str();
}
コード例 #8
0
ファイル: Task.cpp プロジェクト: akshatd/Tasky
string Task::toString(){
	string outputString;
	//outputString = TYPE_KEY_WORD + typeToString() + NEW_LINE;
	outputString = TITLE_KEY_WORD + _title + NEW_LINE;
	outputString += STATUS_KEY_WORD + statusToString() + NEW_LINE;
	outputString += START_KEY_WORD + startToString() + NEW_LINE;
	outputString += END_KEY_WORD + endToString() + NEW_LINE;
	outputString += COMMENT_KEY_WORD + _comment;

	return outputString;
}
コード例 #9
0
ファイル: Task.cpp プロジェクト: akshatd/Tasky
vector<string> Task::toStringVector(){
	vector<string> stringVector;
	string s[6] = {"Type: " + typeToString(),
		"Title: " + _title, 
		"Status: " + statusToString(), 
		"Start: " + startToString(), 
		"End: " + endToString(), 
		"Comment: " + _comment};

	for(unsigned int i = 0; i < 6; i++){
		stringVector.push_back(s[i]);
	}

	return stringVector;
}
コード例 #10
0
ファイル: sickdefines.cpp プロジェクト: naderman/gearbox
std::string errorTypeToString( uChar errorType )
{
    // Bottom two bits are the same as status
    stringstream ss;
    ss << statusToString( errorType && 0x03 );

    if ( errorType & ERROR_TYPE_NO_LONGER_RELEVANT_MASK )
    {
        ss << " (no longer relevant)";
    }
    else
    {
        ss << " (still relevant)";
    }
    return ss.str();
}
コード例 #11
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
static void ramcloudDelete(struct ramcloudData* d, wstr key, struct RejectRules *rule)
{
    wheatLog(WHEAT_DEBUG, "%s delete key %s", __func__, key);
    uint64_t version;
    Status s = rc_remove(global.client, d->table_id, key, wstrlen(key), rule, &version);
    if (s != STATUS_OK) {
        if (s == STATUS_OBJECT_DOESNT_EXIST) {
            sliceTo(&d->storage_response, (uint8_t*)NOT_FOUND, sizeof(NOT_FOUND)-1);
        } else {
            wheatLog(WHEAT_WARNING, "%s failed to remove %s: %s", __func__, key, statusToString(s));
            sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
        }
    } else {
        sliceTo(&d->storage_response, (uint8_t*)DELETED, sizeof(DELETED)-1);
    }
}
void ImageListModelProxy::add(ImageListItem item)
{
    QList<QStandardItem*> list = createRow();

    QStringList strList;

    strList << item.name() << item.path() << item.size() << statusToString(m_initStatus);
    qDebug() << strList;
    for(int i = 0; i < c_columnCount; ++i)
    {
        list.at(i)->setText(strList.at(i));
    }
    if(m_model == NULL)
    {
        qDebug() << "Internal Error#m_model is NULL.";
        return;
    }
    m_model->appendRow(list);
}
コード例 #13
0
static int l_MODBUS_InitContext(lua_State *L) {
    SerialStatus status = SERIAL_STATUS_UNEXPECTED_ERROR;
    ModbusRequestMode mode = MODBUS_RTU;

    // store a modbuscontext address
    ModbusUserData* pModbusUserData = (ModbusUserData*) lua_newuserdata(L, sizeof(ModbusUserData));
    memset(pModbusUserData, 0, sizeof(ModbusUserData));

    // set its metatable
    luaL_getmetatable(L, MODULE_NAME);
    lua_setmetatable(L, -2);

    if (!lua_isnil(L, 1)) {
        if (!lua_isstring(L, 1)) {
            luaL_error(L, "'mode' should be 'RTU', 'ASCII' or 'TCP'\n");
        } else {
            const char* strMode = lua_tostring(L, 1);
            if (strcmp(strMode, MODE_RTU) == 0) {
                mode = MODBUS_RTU;
            } else if (strcmp(strMode, MODE_ASCII) == 0) {
                mode = MODBUS_ASCII;
            } else if (strcmp(strMode, MODE_TCP) == 0) {
                mode = MODBUS_TCP;
            } else {
                luaL_error(L, "'mode' should be 'RTU', 'ASCII' or 'TCP'\n");
            }
        }
    }

    status = MODBUS_SER_InitSerializer(&(pModbusUserData->serializer), (void*)mode);
    if (status != SERIAL_STATUS_OK) {
        MODBUS_SER_ReleaseSerializer(&(pModbusUserData->serializer));
        lua_pushnil(L);
        lua_pushstring(L, statusToString(status));
        return 2;
    }
    else {
        return 1;
    }
}
コード例 #14
0
/*!
    \qmlproperty string NetworkInfo::networkStatus

    Returns this NetworkInfo's network status.
*/
QString QDeclarativeNetworkInfo::networkStatus()
{
    return statusToString(QSystemNetworkInfo::networkStatus(m_mode));
}
コード例 #15
0
/*!
   \internal

   This function is called when the client connects from the networkSignalStrengthChanged()
   notification.

   \sa connectNotify()
*/
void QDeclarativeNetworkInfo::networkStatusChanged(QSystemNetworkInfo::NetworkMode mode, QSystemNetworkInfo::NetworkStatus status)
{
    if(mode == m_mode) {
        Q_EMIT statusChanged(statusToString(status));
    }
}
コード例 #16
0
static int l_MODBUS_ReceiveResponse(lua_State *L) {
    char charTab[80] = { 0 };
    uint8_t n = 0;
    size_t bufferLength = 0;

    ModbusUserData* pModbusUserData = (ModbusUserData *) luaL_checkudata(L, 1, MODULE_NAME);
    const char* buffer = luaL_checklstring(L, 2, &bufferLength);
    ModbusSpecifics *pSpecifics = (ModbusSpecifics*)pModbusUserData->serializer.pSpecifics;

    // copy to response buffer
    memset(pModbusUserData->serializer.pResponseBuffer, 0, pModbusUserData->serializer.responseBufferLength * sizeof(uint8_t));
    memcpy(pModbusUserData->serializer.pResponseBuffer, buffer, bufferLength);
    pModbusUserData->serializer.responseBufferLength = bufferLength;

    // extract data from response
    SerialStatus status = MODBUS_SER_AnalyzeResponse(&(pModbusUserData->serializer), MODBUS_SER_CheckResponse(&(pModbusUserData->serializer)));
    // push results
    switch (status) {
    case SERIAL_STATUS_OK:
      if (pSpecifics->isCustom) {
        lua_pushlstring(L, pSpecifics->response.value.pValues, pSpecifics->response.byteCount);
        n = 1;
        break;
      }
        switch (pSpecifics->response.function) {
        case MODBUS_FUNC_READ_COILS:
        case MODBUS_FUNC_READ_DISCRETE_INPUTS:
        case MODBUS_FUNC_READ_HOLDING_REGISTERS:
        case MODBUS_FUNC_READ_INPUT_REGISTERS:
        case MODBUS_FUNC_SEND_RAW_DATA:
            // push read result
            lua_pushlstring(L, pSpecifics->response.value.pValues, pSpecifics->response.byteCount);

            n = 1;
            break;

        case MODBUS_FUNC_WRITE_SINGLE_COIL:
        case MODBUS_FUNC_WRITE_SINGLE_REGISTER:
        case MODBUS_FUNC_WRITE_MULTIPLE_COILS:
        case MODBUS_FUNC_WRITE_MULTIPLE_REGISTERS:
            // push status
            lua_pushstring(L, "ok");

            n = 1;
            break;

        default:
            // push nil
            lua_pushnil(L);
            // push error string
            lua_pushstring(L, "modbus response error unhandled function");

            n = 2;
            break;
        }
        break;

    case SERIAL_STATUS_RESPONSE_EXCEPTION:
        // push nil
        lua_pushnil(L);
        // push error string
        sprintf(charTab, "%s - %s", statusToString(status), MODBUS_SER_GetExceptionString(pSpecifics->response.exception));
        lua_pushstring(L, charTab);

        n = 2;
        break;

    default:
        // push nil
        lua_pushnil(L);
        // push error string
        lua_pushstring(L, statusToString(status));

        n = 2;
        break;
    }

    // free value
    if (pModbusUserData->allocated != NULL) {
        free(pModbusUserData->allocated);
        pModbusUserData->allocated = NULL;
    }

    return n;
}
コード例 #17
0
ファイル: ServerManager.cpp プロジェクト: 1514louluo/acl
// 该函数由主线程中的定时器调用
void ServerManager::buildStatus()
{
	// 因为在子线程中也会读取 json_ 对象,所以对单例成员变量
	// json_ 进行加锁保护,为了防止主线程被长期阻塞在锁上,所以
	// 采用了尝试加锁方式
	if (lock_.try_lock() == false)
		return;

	json_.reset();
	xml_.reset();

	acl::json_node& json_servers = json_.create_array();
	json_.get_root().add_child("server", json_servers);

	acl::xml_node& xml_servers = xml_.create_node("server");
	xml_.get_root().add_child(xml_servers);

	long long total_conns = 0, total_used = 0, total_qlen = 0;
	long long total_max_threads = 0, total_curr_threads = 0;
	long long total_busy_threads = 0;
	acl::string load_s;
	(void) sysload::get_load(&load_s);  // 获得当前系统的负载

	std::vector<ServerConnection*>::const_iterator cit = conns_.begin();
	for (; cit != conns_.end(); ++cit)
	{
		total_conns += (*cit)->get_conns();
		total_used += (*cit)->get_used();
		total_qlen += (*cit)->get_qlen();
		total_max_threads += (*cit)->get_max_threads();
		total_curr_threads += (*cit)->get_curr_threads();
		total_busy_threads += (*cit)->get_busy_threads();

		acl::json_node& json_server = json_.create_node();
		json_server.add_number("conns", (*cit)->get_conns())
			.add_number("used", (*cit)->get_used())
			.add_number("pid", (*cit)->get_pid())
			.add_number("max_threads", (*cit)->get_max_threads())
			.add_number("curr_threads", (*cit)->get_curr_threads())
			.add_number("busy_threads", (*cit)->get_busy_threads())
			.add_number("qlen", (*cit)->get_qlen())
			.add_text("type", (*cit)->get_type());
		json_servers.add_child(json_server);

		xml_servers.add_child("proc", true)
			.add_child("conns", (long long int)
					(*cit)->get_conns())
			.add_child("used", (long long int) (*cit)->get_used())
			.add_child("pid", (long long int) (*cit)->get_pid())
			.add_child("max_threads", (long long int)
					(*cit)->get_max_threads())
			.add_child("curr_threads", (long long int)
					(*cit)->get_curr_threads())
			.add_child("busy_threads", (long long int)
					(*cit)->get_busy_threads())
			.add_child("qlen", (long long int) (*cit)->get_qlen())
			.add_child("type", (*cit)->get_type().c_str());
	}

	json_.get_root().add_number("conns", total_conns)
		.add_number("used", total_used)
		.add_number("qlen", total_qlen)
		.add_number("max_threads", total_max_threads)
		.add_number("curr_threads", total_curr_threads)
		.add_number("busy_threads", total_busy_threads)
		.add_text("addr", var_cfg_local_addr.c_str())
		.add_text("load", load_s.c_str());

	xml_servers.add_attr("conns", total_conns)
		.add_attr("used", total_used)
		.add_attr("qlen", total_qlen)
		.add_attr("max_threads", total_max_threads)
		.add_attr("curr_threads", total_curr_threads)
		.add_attr("busy_threads", total_busy_threads)
		.add_attr("addr", var_cfg_local_addr.c_str())
		.add_attr("load", load_s.c_str());

#if 0
	acl::json_node& n = json_.create_node();
	n.add_number("conns", 1).add_number("used", 2)
		.add_number("pid", 1).add_number("max_threads", 10)
		.add_number("curr_threads", 1).add_number("busy_threads", 2)
		.add_number("qlen", 0).add_text("type", "default");
	servers.add_child(n);
	acl::json_node& m = json_.create_node();
	m.add_number("conns", 2).add_number("used", 3)
		.add_number("pid", 2).add_number("max_threads", 10)
		.add_number("curr_threads", 2).add_number("busy_threads", 1)
		.add_number("qlen", 0).add_text("type", "default");
	servers.add_child(m);

	acl::string buf;
	statusToString(buf);
	printf(">>>buf: %s\r\n", buf.c_str());
#endif

	lock_.unlock();
}
コード例 #18
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
static int getTableId(int owner, uint64_t *table_id)
{
    struct dictEntry *entry = dictFind(global.tables, (void*)(intptr_t)owner);
    if (entry) {
        *table_id = dictGetUnsignedIntegerVal(entry);
        return WHEAT_OK;
    } else {
        char name[256];
        int l = sprintf(name, "%s_%d", hostname, owner);
        name[l] = '\0';
        Status s = rc_getTableId(global.client, name, table_id);
        if (s != STATUS_OK) {
            if (s == STATUS_TABLE_DOESNT_EXIST) {
                wheatLog(WHEAT_DEBUG, "%s table %s not exists, create it, s", __func__, name);
                s = rc_createTable(global.client, name, 1);
                if (s != STATUS_OK) {
                    wheatLog(WHEAT_WARNING, "%s failed to create table %s: %s", __func__, name, statusToString(s));
                    return WHEAT_WRONG;
                }
                s = rc_getTableId(global.client, name, table_id);
            }
            if (s != STATUS_OK) {
                wheatLog(WHEAT_WARNING, "%s failed to get table %s: %s", __func__, name, statusToString(s));
                return WHEAT_WRONG;
            }
        }
        dictAdd(global.tables, name, (void*)(intptr_t)(*table_id));
        return WHEAT_OK;
    }
}
コード例 #19
0
ファイル: qPkBackend.cpp プロジェクト: KDE/kcm-grub2
void QPkBackend::slotUpdateProgress()
{
    Q_EMIT progress(statusToString(m_t->status()), m_t->percentage());
}
コード例 #20
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
static void ramcloudAppend(struct ramcloudData *d, wstr key, struct array *vals, uint32_t vlen, uint16_t flag, int append)
{
    uint32_t actual_len;
    uint64_t version;
    uint64_t len = RAMCLOUD_DEFAULT_VALUE_LEN;

again:
    wheatLog(WHEAT_DEBUG, "%s read key %s", __func__, key);

    wstr origin_val = wstrNewLen(NULL, len);
    wstr val;
    Status s = rc_read(global.client, d->table_id, key, wstrlen(key), NULL, &version, origin_val, len, &actual_len);
    if (s != STATUS_OK) {
        if (s != STATUS_OBJECT_DOESNT_EXIST) {
            wheatLog(WHEAT_WARNING, " failed to read %s: %s", key, statusToString(s));
            sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
        } else {
            sliceTo(&d->storage_response, (uint8_t*)NOT_STORED, sizeof(NOT_STORED)-1);
        }
        wstrFree(origin_val);
        return ;
    }

    while (actual_len > len) {
        wstrFree(origin_val);
        len = actual_len;
        origin_val = wstrNewLen(NULL, actual_len);
        if (origin_val == NULL) {
            sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
            wheatLog(WHEAT_WARNING, " failed to alloc memory");
            return ;
        }

        s = rc_read(global.client, d->table_id, key, wstrlen(key), NULL, &version, origin_val, len, &actual_len);
        if (s != STATUS_OK) {
            if (s != STATUS_OBJECT_DOESNT_EXIST) {
                wheatLog(WHEAT_WARNING, " failed to read %s: %s", key, statusToString(s));
                sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
            } else {
                sliceTo(&d->storage_response, (uint8_t*)NOT_STORED, sizeof(NOT_STORED)-1);
            }
            wstrFree(origin_val);
            return ;
        }
    }

    wstrupdatelen(origin_val, actual_len-FLAG_SIZE);
    if (append) {
        val = origin_val;
        // reduce flag size
    } else {
        val = wstrNewLen(NULL, vlen);
    }

    int i = 0;
    while (i < narray(vals)) {
        struct slice *slice;
        slice = arrayIndex(vals, i);
        val = wstrCatLen(val, (char*)slice->data, slice->len);
        len += slice->len;
        ++i;
    }

    if (!append) {
        val = wstrCatLen(val, origin_val, wstrlen(origin_val));
        wstrFree(origin_val);
    }
    val = wstrCatLen(val, (char*)&flag, FLAG_SIZE);

    struct RejectRules rule;
    memset(&rule, 0, sizeof(rule));
    rule.doesntExist = 1;
    rule.versionNeGiven = 1;
    rule.givenVersion = version;
    s = rc_write(global.client, d->table_id, key, wstrlen(key), val, wstrlen(val),
                        &rule, NULL);
    wstrFree(val);
    if (s != STATUS_OK) {
        if (s == STATUS_OBJECT_DOESNT_EXIST) {
            sliceTo(&d->storage_response, (uint8_t*)NOT_STORED, sizeof(NOT_STORED)-1);
            return ;
        } else if (s == STATUS_WRONG_VERSION) {
            goto again;
        }

        wheatLog(WHEAT_WARNING, " failed to write %s: %s", key, statusToString(s));
        sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
        return ;
    }
    sliceTo(&d->storage_response, (uint8_t*)STORED, sizeof(STORED)-1);
}
コード例 #21
0
bool GetParameterIn::operator()(void)
{	
	if (m_parameter.compare("hello") == 0)
	{
		m_response = "Welcome to SAN node terminal";
		return true;
	}
	
	if (m_parameter.compare("hostname") == 0)
	{
		m_response = m_node.getNodeName();
		return true;
	}
	
	if (m_parameter.compare("uptime") == 0)
	{
		unsigned long uptimeSec = m_node.getUptimeSec();
		
		unsigned long uptimeDays = (uptimeSec - (uptimeSec % 86400)) / 86400;
		uptimeSec %= 86400; 
		unsigned long uptimeHours = (uptimeSec - (uptimeSec % 3600)) / 3600;
		uptimeSec %= 3600; 
		unsigned long uptimeMin = (uptimeSec - (uptimeSec % 60)) / 60;
		uptimeSec %= 60; 
		
		std::string tmp;
		
		tmp = San2::Utils::CStringUtils::ulongToString(uptimeDays) + "d " + San2::Utils::CStringUtils::ulongToString(uptimeHours) + "h " + San2::Utils::CStringUtils::ulongToString(uptimeMin) + "m " + San2::Utils::CStringUtils::ulongToString(uptimeSec) + "s";
		m_response = tmp;
		return true;
	}
	
	if (m_parameter.compare("version") == 0)
	{
		m_response = "SAN Node v1.0";
		return true;
	}
	
	if (m_parameter.compare("peers") == 0)
	{
	    std::set<std::shared_ptr<San2::Network::CNetInterface> > ifaces = m_node.getInterfaces();
       
        m_response = "";
       
        for(auto s: ifaces)
        {
            
            m_response += "IFACE status RX:";
            m_response += statusToString(s->getRXstate());
            m_response += "   TX:";
            m_response += statusToString(s->getTXstate());
            m_response += "\n>> iadr: ";
            m_response += San2::Utils::address2string(s->getInterfaceAddress()).c_str();
            m_response += "\n>> peer: ";
            m_response += San2::Utils::address2string(s->getPeerAddress()).c_str();
            m_response += "\n\n";            
         }

		return true;
	}
	
	
	m_response = "Unknown parameter " + m_parameter;
	
	return true;
}
コード例 #22
0
ファイル: Game.cpp プロジェクト: JesperMikkelsen/Big-Numbers
String MoveWithResult::toString() const {
  return format(_T("{%-5s}:%s"), setToString(*m_move).cstr(), statusToString(m_status).cstr());
}
コード例 #23
0
ファイル: app_ramcloud.c プロジェクト: ctbrowser/wheatserver
static void ramcloudIncr(struct ramcloudData *d, wstr key, uint64_t num, int positive)
{
    if (num > INT64_MAX) {
        wheatLog(WHEAT_WARNING, "%s num %ld can't larger than %ld", __func__, num, INT64_MAX);
        sliceTo(&d->storage_response, (uint8_t*)CLIENT_ERROR, sizeof(CLIENT_ERROR)-1);
        return ;
    }

    static int max_len = 100;
    char value[max_len];
    uint32_t actual_len;
    uint64_t version;
    uint16_t flag;

again:
    wheatLog(WHEAT_DEBUG, "%s incr key %s %ld", __func__, key, num);
    Status s = rc_read(global.client, d->table_id, key, wstrlen(key), NULL, &version, value, max_len, &actual_len);
    if (s != STATUS_OK) {
        if (s != STATUS_OBJECT_DOESNT_EXIST) {
            wheatLog(WHEAT_WARNING, " failed to read %s: %s", key, statusToString(s));
            sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
        } else {
            sliceTo(&d->storage_response, (uint8_t*)NOT_FOUND, sizeof(NOT_FOUND)-1);
        }
        return ;
    }

    if (actual_len > max_len) {
        sliceTo(&d->storage_response, (uint8_t*)CLIENT_ERROR, sizeof(CLIENT_ERROR)-1);
        return ;
    }

    flag = *(uint16_t*)&value[actual_len-FLAG_SIZE];
    value[actual_len-FLAG_SIZE] = '\0';
    long long n = atoll(value);
    if (n == 0) {
        if (value[0] != '0') {
            sliceTo(&d->storage_response, (uint8_t*)CLIENT_ERROR, sizeof(CLIENT_ERROR)-1);
            return ;
        }
    }
    if (positive) {
        n += num;
    } else {
        if (num > n)
            n = 0;
        else
            n -= num;
    }
    int l = sprintf(value, "%llu", n);
    memcpy(&value[l], &flag, FLAG_SIZE);
    struct RejectRules rule;
    memset(&rule, 0, sizeof(rule));
    rule.doesntExist = 1;
    rule.versionNeGiven = 1;
    rule.givenVersion = version;
    s = rc_write(global.client, d->table_id, key, wstrlen(key), value, l+FLAG_SIZE,
                 &rule, &version);
    if (s != STATUS_OK) {
        if (s == STATUS_WRONG_VERSION) {
            goto again;
        }

        if (s == STATUS_OBJECT_DOESNT_EXIST) {
            sliceTo(&d->storage_response, (uint8_t*)NOT_FOUND, sizeof(NOT_FOUND)-1);
            return ;
        }
        sliceTo(&d->storage_response, (uint8_t*)SERVER_ERROR, sizeof(SERVER_ERROR)-1);
        wheatLog(WHEAT_WARNING, "%s failed to incr %s: %s", __func__, key, statusToString(s));
        return ;
    } else {
        l = sprintf(value, "%llu\r\n", n);
        d->retrieval_response = wstrNewLen(value, l);
        sliceTo(&d->storage_response, (uint8_t*)d->retrieval_response, wstrlen(d->retrieval_response));
    }
}