Пример #1
0
void Gate::OnBindLogicAck(IKernel * kernel, s32 nodeType, s32 nodeId, const OArgs & args) {
	s64 actorId = args.GetDataInt64(0);
	s64 accountId = args.GetDataInt64(1);
	s32 errorCode = args.GetDataInt32(2);

	if (_actors.find(actorId) != _actors.end()) {
		OASSERT(_players.find(_actors[actorId]) != _players.end(), "wtf");
		Player& player = _players[_actors[actorId]];
		OASSERT(player.state == ST_BINDING && actorId == player.selectActorId, "wtf");

		if (errorCode) {
			player.state = ST_ONLINE;
			player.lastActorId = actorId;

			ICacheDBContext * writer = _cacheDB->PrepareWrite("account", player.accountId);
			writer->WriteInt64("id", player.accountId);
			writer->WriteInt64("lastActor", actorId);
			writer->Update();

			const s32 tokenCount = args.GetDataInt32(3);
		}
		else {
			Reset(kernel, _actors[actorId], ST_ROLELOADED, node_type::USER);

			olib::Buffer<128> buf;
			buf << _errorBindLogicFailed;
			SendToClient(kernel, _actors[actorId], _selectRoleAckId, buf.Out());
		}
	}
}
Пример #2
0
bool Redis::Initialize(IKernel * kernel) {
    s_self = this;
    s_kernel = kernel;

	olib::XmlReader reader;
	std::string coreConfigPath = std::string(tools::GetAppPath()) + "/config/server_conf.xml";
	if (!reader.LoadXml(coreConfigPath.c_str())) {
		OASSERT(false, "can't find core file : %s", coreConfigPath.c_str());
		return false;
	}

	s_sendBufferSize = reader.Root()["redis"][0].GetAttributeInt32("send");
	s_recvBufferSize = reader.Root()["redis"][0].GetAttributeInt32("recv");
	s_reconnectTick = reader.Root()["redis"][0].GetAttributeInt32("reconnect");

	const olib::IXmlObject& units = reader.Root()["redis"][0]["unit"];
	for (s32 i = 0; i < units.Count(); ++i) {
		const char * ip = units[i].GetAttributeString("ip");
		s32 port = units[i].GetAttributeInt32("port");

		RedisSession * session = NEW RedisSession;
		session->SetConnect(i, ip, port);
		s_kernel->Connect(ip, port, s_sendBufferSize, s_recvBufferSize, session);
		s_sessions.push_back(session);
	}

	s_scriptEngine = (IScriptEngine*)kernel->FindModule("ScriptEngine");
	OASSERT(s_scriptEngine, "where is scriptEngine");

    return true;
}
Пример #3
0
void Gate::Reset(IKernel * kernel, s64 id, s8 state, s32 from) {
	OASSERT(state == ST_NONE || state == ST_ROLELOADED, "wtf");
	Player& player = _players[id];
	s8 old = player.state;
	if (old > ST_DISTRIBUTE) {
		OASSERT(player.logic > 0 && player.selectActorId != 0, "wtf");

		IArgs<1, 32> args;
		args << player.selectActorId;
		args.Fix();
		_harbor->Send(user_node_type::LOGIC, player.logic, framework_proto::UNBIND_PLAYER, args.Out());

		_actors.erase(player.selectActorId);
		_logicPlayers[player.logic].erase(id);

		player.selectActorId = 0;
		player.logic = 0;
	}

	if (old > ST_NONE && state == ST_NONE) {
		IArgs<1, 32> args;
		args << player.agentId << player.accountId;
		args.Fix();
		_harbor->Send(user_node_type::ACCOUNT, 1, framework_proto::UNBIND_ACCOUNT, args.Out());

		player.accountId = 0;
		for (const auto& role : player.roles) {
			_roleMgr->Recover(role.role);
		}
	}
	player.state = state;
}
Пример #4
0
ObjectDescriptor * ObjectMgr::CreateTemplate(IKernel * kernel, const char * name) {
    auto itr = _namePathMap.find(name);
    if (itr == _namePathMap.cend()) {
        OASSERT(false, "wtf");
        return nullptr;
    }

	olib::XmlReader conf;
    if (!conf.LoadXml(itr->second.GetString())) {
        OASSERT(false, "prop xml file %s load file", itr->second.GetString());
        return nullptr;
    }

	ObjectDescriptor * descriptor = nullptr;
	if (conf.Root().HasAttribute("parent")) {
		ObjectDescriptor * parent = QueryTemplate(kernel, conf.Root().GetAttributeString("parent"));
        OASSERT(parent, "where is parent %s xml", conf.Root().GetAttributeString("parent"));
        if (nullptr == parent)
            return nullptr;
    
		descriptor = NEW ObjectDescriptor(_nextTypeId++, name, parent);
    } else {
		descriptor = NEW ObjectDescriptor(_nextTypeId++, name, nullptr);
    }

	if (!descriptor->LoadFrom(conf.Root(), _defines)) {
		DEL descriptor;
		return nullptr;
	}

	_models[name] = descriptor;
    return _models[name];
}
Пример #5
0
s32 BindLooper(struct NetLooper * looper, struct NetBase * base) {
    OASSERT(base->looper == NULL, "already has a looper");
    struct epoll_event ev;
    ev.data.ptr = base;
    switch (base->type) {
    case BNEV_ACCEPT:
        ev.events = EPOLLIN;
        break;
    case BNEV_CONNECT:
        ev.events = EPOLLOUT | EPOLLET;
        break;
    case BNEV_IO:
        ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
        break;
    default:
        OASSERT(0, "wtf");
        return -1;
    }

    ev.events |= EPOLLERR | EPOLLHUP;

    if (epoll_ctl(looper->fd, EPOLL_CTL_ADD, base->fd, &ev) != 0) {
        printf("epoll add fd error %d\n", errno);
        return -1;
    }
    base->looper = looper;
    return 0;
}
Пример #6
0
void Gate::OnRecvKickFromLogic(IKernel * kernel, s32 nodeType, s32 nodeId, const OArgs & args) {
	s64 actorId = args.GetDataInt64(0);
	if (_actors.find(actorId) != _actors.end()) {
		OASSERT(_players.find(_actors[actorId]) != _players.end(), "wtf");
		Player& player = _players[_actors[actorId]];
		OASSERT(player.state == ST_ONLINE && player.logic == nodeId, "wtf");

		Reset(kernel, _actors[actorId], ST_NONE, user_node_type::LOGIC);
	}
}
Пример #7
0
const void *  MMObject::Get(const IProp * prop, const s8 type, s32& size) const {
    const ObjectLayout * layout = ((ObjectProp*)prop)->GetLayout(_descriptor->GetTypeId());
    OASSERT(layout, "wtf");
    if (layout != nullptr) {
        OASSERT(layout->type == type && layout->size >= size, "wtf");

        if (layout->type == type && layout->size >= size) {
            size = layout->size;
            return _memory->Get(layout);
        }
    }
    return nullptr;
}
Пример #8
0
void Slave::StartNode(IKernel * kernel, const char * cmd) {
	char process[MAX_CMD_LEN];
#ifdef WIN32
	SafeSprintf(process, sizeof(process), "%s/%s.exe", tools::GetAppPath(), EXECUTE_NAME);

	STARTUPINFO si = { sizeof(si) };
	si.dwFlags = STARTF_USESHOWWINDOW;
	si.wShowWindow = TRUE;
	si.lpTitle = (char*)cmd;

	PROCESS_INFORMATION pi;
	BOOL ret = CreateProcess(process, (char*)cmd, nullptr, nullptr, false, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi);
	OASSERT(ret, "create process failed");
	::CloseHandle(pi.hThread);
	::CloseHandle(pi.hProcess);
#else
	SafeSprintf(process, sizeof(process), "%s/%s", tools::GetAppPath(), EXECUTE_NAME);

	char args[MAX_CMD_LEN];
	SafeSprintf(args, sizeof(args), cmd);

	char * p[MAX_CMD_ARGS_COUNT];
	SafeMemset(p, sizeof(p), 0, sizeof(p));
	p[0] = EXECUTE_NAME;
	s32 idx = 1;
	char * checkPtr = args;
	char * innderPtr = nullptr;
	while ((p[idx] = strtok_r(checkPtr, " ", &innderPtr)) != nullptr) {
		++idx;
		checkPtr = nullptr;
	}

	pid_t pid;
	pid = fork();
	if (pid < 0) {
		OASSERT(false, "start process failed");
	}
	else if (pid == 0) {
		pid = fork();
		if (pid == 0)
			execv(process, p);
		else
			exit(0);
	}
	else {
		s32 status;
		waitpid(pid, &status, 0);
	}
#endif
}
Пример #9
0
bool MMObject::Set(const IProp * prop, const s8 type, const void * data, const s32 size, const bool sync) {
    const ObjectLayout * layout = ((ObjectProp*)prop)->GetLayout(_descriptor->GetTypeId());
    OASSERT(layout, "wtf");
    if (layout != nullptr) {
        OASSERT(layout->type == type && layout->size >= size, "wtf");

        if (layout->type == type && layout->size >= size) {
            _memory->Set(layout, data, size);
            return true;
        }
        PropCall(prop, sync);
    }
    return false;
}
Пример #10
0
void Cluster::NewNodeComming(IKernel * kernel, s32 nodeType, s32 nodeId, const void * context, const s32 size) {
    OASSERT(size == sizeof(node_proto::NewNode), "invalid node size");
    node_proto::NewNode& info = *((node_proto::NewNode*)context);
    OASSERT(info.port > 0, "where is harbor port");

	s64 check = ((s64)info.nodeType << 32) | ((s64)info.nodeId);
    if (s_openNode.find(check) != s_openNode.end())
        return;

    if (info.nodeType == s_harbor->GetNodeType() && info.nodeId <= s_harbor->GetNodeId())
        return;

    s_openNode.insert(check);
    s_harbor->Connect(info.ip, info.port);
}
Пример #11
0
void ObjectMgr::Recove(IObject * object) {
    OASSERT(object, "wtf");
    if (nullptr == object)
        return;

    auto itr = _objects.find(object->GetID());
    if (itr == _objects.end()) {
        OASSERT(false, "where is this object %lld", object->GetID());
        return;
    }
	OASSERT(itr->second.object == object, "wtf");

	DEL object;
    _objects.erase(itr);
}
Пример #12
0
void Harbor::Brocast(s32 nodeType, const s32 messageId, const OArgs& args) {
	for (auto itr = _nodes[nodeType].begin(); itr != _nodes[nodeType].end(); ++itr) {
		if (!itr->second->PrepareSendNodeMessage(args.GetSize() + sizeof(s32))) {
			OASSERT(false, "send failed");
		}

		if (!itr->second->SendNodeMessage(&messageId, sizeof(s32))) {
			OASSERT(false, "send failed");
			return;
		}

		if (!itr->second->SendNodeMessage(args.GetContext(), args.GetSize())) {
			OASSERT(false, "send failed");
		}
	}
}
Пример #13
0
void Connection::OnRecv() {
	if (_closing)
		return;

	char temp[SINGLE_RECV_SIZE];
	u32 size = 0;
	char * buf = RingBufferReadTemp(_recvBuf, (char*)temp, sizeof(temp), &size);
	if (buf && size > 0) {
		s32 used = 0;
		s32 totalUsed = 0;
		do {
			used = _session->OnRecv(Kernel::Instance(), buf + totalUsed, size - totalUsed);
			if (used > 0) {
				OASSERT(totalUsed + used <= (s32)size, "wtf");
				totalUsed += used;
			}
		} while (used > 0 && totalUsed < (s32)size);

		if (totalUsed > 0)
			RingBufferOut(_recvBuf, totalUsed);

		if (used < 0)
			Close();
	}
}
Пример #14
0
IObject * ObjectMgr::CreateObjectByID(const char * file, const s32 line, const char * name, const s64 id, bool shadow) {
	if (_objects.find(id) != _objects.end()) {
		OASSERT(false, "object id is exists");
		return nullptr;
	}
	
	auto itr = _models.find(name);
	if (itr == _models.end()) {
		OASSERT(false, "what's this, %s", name);
		return nullptr;
	}

	MMObject * object = NEW MMObject(name, itr->second);
	_objects.insert(std::make_pair(id, ObjectCreateInfo({ object, file, line })));
	return object;
}
Пример #15
0
void Gate::OnRecvCreateRoleReq(IKernel * kernel, const s64 id, const OBuffer& buf) {
	OASSERT(_players.find(id) != _players.end(), "where is agent???");
	Player& player = _players[id];
	if (player.state == ST_ROLELOADED) {
		if (player.roles.size() >= _maxRole) {
			olib::Buffer<128> buf;
			buf << _errorTooMuchRole;
			SendToClient(kernel, id, _createRoleAckId, buf.Out());
			return;
		}

		s64 actorId = _idMgr->AllocId();
		IRole * role = _roleMgr->CreateRole(actorId, buf);
		if (role) {
			player.roles.push_back({ actorId, role });

			olib::Buffer<128> buf;
			buf << _noError;
			role->Pack(buf);
			SendToClient(kernel, id, _createRoleAckId, buf.Out());
		}
		else {
			olib::Buffer<128> buf;
			buf << _errorCreateRoleFailed;
			SendToClient(kernel, id, _createRoleAckId, buf.Out());
		}
	}
}
Пример #16
0
void Gate::OnUpdateRole(IKernel * kernel, s32 nodeType, s32 nodeId, const OArgs & args) {
	s64 actorId = args.GetDataInt64(0);
	if (_actors.find(actorId) != _actors.end()) {
		OASSERT(_players.find(_actors[actorId]) != _players.end(), "wtf");
		Player& player = _players[_actors[actorId]];
		OASSERT(player.state == ST_ONLINE && actorId == player.selectActorId && nodeId == player.logic, "wtf");

		auto itr = std::find_if(player.roles.begin(), player.roles.end(), [actorId](const Role& role) {
			return role.actorId == actorId;
		});

		OASSERT(itr != player.roles.end(), "wtf");
		if (itr != player.roles.end())
			itr->role->Update(args);
	}
}
Пример #17
0
void Gate::OnRecvDistributeAck(IKernel * kernel, s32 nodeType, s32 nodeId, const OArgs & args) {
	s64 agentId = args.GetDataInt64(0);
	s64 actorId = args.GetDataInt64(1);
	s32 logic = args.GetDataInt32(2);

	if (_players.find(agentId) != _players.end()) {
		if (logic > 0) {
			Player& player = _players[agentId];
			OASSERT(player.state == ST_DISTRIBUTE, "wtf");

			player.selectActorId = actorId;
			player.logic = logic;
			player.state = ST_BINDING;

			_actors[actorId] = agentId;
			_logicPlayers[logic].insert(agentId);

			IArgs<2, 32> args;
			args << actorId << player.accountId;
			args.Fix();

			_harbor->Send(user_node_type::LOGIC, logic, framework_proto::BIND_PLAYER, args.Out());
		}
		else {
			Reset(kernel, agentId, ST_ROLELOADED, node_type::USER);

			olib::Buffer<128> buf;
			buf << _errorDistributeLogicFailed;
			SendToClient(kernel, agentId, _selectRoleAckId, buf.Out());
		}
	}
}
Пример #18
0
const IProp * ObjectMgr::CalcProp(const char * name) {
	auto itr = _props.find(name);
	OASSERT(itr != _props.end(), "wtf");
	if (itr != _props.end())
		return itr->second;
	return nullptr;
}
Пример #19
0
bool Connection::CheckPipeBroke() {
	OASSERT(!_broken, "wtf");
	_broken = true;
	if (!_closeing)
		_closeing = true;
	return _pushing;
}
Пример #20
0
ITableControl * ObjectMgr::CreateStaticTable(const char * name, const char * model, const char * file, const s32 line) {
	if (_tableMap.find(tools::CalcStringUniqueId(name)) != _tableMap.end()) {
		OASSERT(false, "already hsa table %s", name);
		return nullptr;
	}

	auto itr = _tableModels.find(tools::CalcStringUniqueId(model));
	OASSERT(itr != _tableModels.end(), "wtf");
	if (itr == _tableModels.end())
		return nullptr;

	TableControl * table = NEW TableControl(tools::CalcStringUniqueId(name), itr->second);
	TableCreateInfo info({ table, file, line });
	_tableMap.insert(std::make_pair(tools::CalcStringUniqueId(name), info));
    return table;
}
Пример #21
0
void Gate::OnRecvDeleteRoleReq(IKernel * kernel, const s64 id, const OBuffer& buf) {
	s64 actorId = 0;
	if (!buf.Read(actorId))
		return;

	OASSERT(_players.find(id) != _players.end(), "where is agent???");
	Player& player = _players[id];
	if (player.state == ST_ROLELOADED) {
		auto itr = std::find_if(player.roles.begin(), player.roles.end(), [actorId](const Role& role) {
			return role.actorId == actorId;
		});

		if (itr != player.roles.end()) {
			if (_roleMgr->DeleteRole(itr->actorId, itr->role)) {
				player.roles.erase(itr);
				
				olib::Buffer<128> buf;
				buf << _noError << actorId;
				SendToClient(kernel, id, _deleteRoleAckId, buf.Out());
			}
			else {
				olib::Buffer<128> buf;
				buf << _errorDeleteRoleFailed;
				SendToClient(kernel, id, _deleteRoleAckId, buf.Out());
			}
		}
	}
}
Пример #22
0
s32 ProtocolMgr::GetId(const char * group, const char * name) {
	auto itr = _protos[group].find(name);
	OASSERT(itr != _protos[group].end(), "wtf");
	if (itr != _protos[group].end())
		return itr->second;
	return 0;
}
Пример #23
0
const char * ProtocolMgr::GetDesc(const char * group, const s32 id) {
	auto itr = _descs[group].find(id);
	OASSERT(itr != _descs[group].end(), "wtf");
	if (itr != _descs[group].end())
		return itr->second.GetString();
	return "";
}
Пример #24
0
	virtual bool Read(const char * format, ...) const  {
		s32 count = lua_gettop(_state);
		s32 index = 1;
		const char * c = format;
		va_list ap;
		va_start(ap, format);
		while (*c != '\0') {
			if (index > count) {
				OASSERT(false, "param is not enough");
				luaL_error(_state, "param is not enough %s", format);
				return false;
			}
			
			switch (*c) {
			case 'c': { s8 * val = va_arg(ap, s8*); *val = (s8)lua_tointeger(_state, index++); } break;
			case 'd': { s16 * val = va_arg(ap, s16*); *val = (s16)lua_tointeger(_state, index++); } break;
			case 'i': { s32 * val = va_arg(ap, s32*); *val = (s32)lua_tointeger(_state, index++); } break;
			case 'l': { s64 * val = va_arg(ap, s64*); *val = lua_tointeger(_state, index++); } break;
			case 'f': { float * val = va_arg(ap, float*); *val = lua_tonumber(_state, index++); } break;
			case 'b': { bool * val = va_arg(ap, bool*); *val = lua_toboolean(_state, index++); } break;
			case 's': { const char ** val = va_arg(ap, const char **); *val = lua_tostring(_state, index++); } break;
			case 'S': {
					const char ** val = va_arg(ap, const char **);
					s32* len = va_arg(ap, s32*);
					size_t size;
					*val = lua_tolstring(_state, index++, &size);
					*len = size;
				}
				break;
			}
			c++;
		}
		va_end(ap);
		return true;
	}
Пример #25
0
void Connection::Close() {
	OASSERT(!_closeing, "wtf");
	if (!_closeing) {
		if (!_pushing)
			shutdown(_fd, SHUT_RDWR);
		_closeing = true;
	}
}
Пример #26
0
void Harbor::Connect(const char * ip, const s32 port) {
    core::ISession * session = Create();
    OASSERT(session != nullptr, "create session failed");

    ((NodeSession*)session)->SetConnect(ip, port);

    s_kernel->Connect(ip, port, _sendBuffSize, _recvBuffSize, session);
}
Пример #27
0
void Agent::Kick(const s64 id) {
	auto itr = s_sessions.find(id);
	if (itr == s_sessions.end()) {
		OASSERT(false, "where is agent %lld", id);
		return;
	}

	itr->second->Close();
}
Пример #28
0
void Agent::Send(const s64 id, const void * context, const s32 size) {
	auto itr = s_sessions.find(id);
	if (itr == s_sessions.end()) {
		OASSERT(false, "where is agent %lld", id);
		return;
	}

	itr->second->Send(context, size);
}
Пример #29
0
bool Cluster::Launched(IKernel * kernel) {
    s_harbor = (IHarbor*)kernel->FindModule("Harbor");
    OASSERT(s_harbor, "where is harbor");

    s_harbor->Connect(_ip.c_str(), _port);
    REGPROTOCOL(node_proto::NEW_NODE, Cluster::NewNodeComming);

    return true;
}
Пример #30
0
bool CapacitySubscriber::Launched(IKernel * kernel) {
	s_harbor = (IHarbor*)kernel->FindModule("Harbor");
	OASSERT(s_harbor, "where is harbor");
	s_harbor->AddNodeListener(this, "CapacitySubscriber");

	REGPROTOCOL(core_proto::OVER_LOAD, CapacitySubscriber::ReadLoad);

    return true;
}