C++ NetworkOutMessagePtr类代码示例

XSessionImplPtr SessionServer::CreateNewSession(const std::string& sessionName, SessionType type)
{
    XSessionImplPtr xsession;
	uint16 sessionPort;

    // Better way to check for error?
    if (m_portPool->GetPort(sessionPort))
    {
        uint32 id = GetNewSessionId();

        xsession = new XSessionImpl(sessionName, sessionPort, type, id);

		// Check that the session was able to set itself up, open a socket to listen on, etc
		for (int creationCount = 0; !xsession->IsInitialized() && creationCount < 10; ++creationCount)
		{
			m_portPool->ReleasePort(sessionPort);

			if (m_portPool->GetPort(sessionPort))
			{
				xsession = new XSessionImpl(sessionName, sessionPort, type, id);
			}
			else
			{
				break;
			}
		}

		if (xsession->IsInitialized())
		{
			m_sessionChangeListener[xsession] = xsession->RegisterCallback(this);
			m_sessions.push_back(xsession);
			LogInfo("Created Session \"%s\" with ID %u on port %i", sessionName.c_str(), id, sessionPort);

			// Notify the listeners about the new session
			for (size_t i = 0; i < m_clients.size(); ++i)
			{
				SessionAddedMsg sessionAddedMsg;
				sessionAddedMsg.SetSessionDescriptor(xsession->GetSessionDescription(m_clients[i].m_connection->GetSocket()));

				NetworkOutMessagePtr msg = m_clients[i].m_connection->CreateMessage((byte)MessageID::SessionControl);
				msg->Write(sessionAddedMsg.ToJSONString());

				m_clients[i].m_connection->Send(msg, MessagePriority::Medium, MessageReliability::ReliableOrdered, MessageChannel::Default, true);
			}
		}
		else
		{
			LogError("Failed to create new session %s", sessionName.c_str());
			xsession = NULL;
		}
    }

    return xsession;
}

void UserPresenceManagerLeaderImpl::PushPresenceUpdate()
{
    // Tell any connected baraboo about the new mute state.
    if (m_barabooConnection->IsConnected())
    {
        NetworkOutMessagePtr message = m_barabooConnection->CreateMessage(MessageID::UserPresenceChange);
        message->Write(m_localUser ? m_localUser->GetName() : NULL);
        message->Write(int32((m_localUser && m_localUser->GetMuteState()) ? 1 : 0));
        m_barabooConnection->Send(message);
    }

    UpdateListeners();
}

void SessionServer::SendSessionMessageToAllClients(const std::string& message)
{
	NetworkOutMessagePtr msg = m_messagePool->AcquireMessage();
	msg->Write((byte)MessageID::SessionControl);
	msg->Write(message);

	for (size_t i = 0; i < m_clients.size(); ++i)
	{
		m_clients[i].m_connection->Send(msg, MessagePriority::Medium, MessageReliability::ReliableOrdered, MessageChannel::Default, false);
	}

	m_messagePool->ReturnMessage(msg);
}

void SessionImpl::UpdateUser(const UserPtr& updatedUser)
{
    // Expect this only to be called on sessions we are joined to.
    XTASSERT(IsJoined());

    UserPtr user = FindUser(updatedUser->GetID());

    // Assert that we aren't updating for a user who's not present.
    if (XTVERIFY(user))
    {
        UserChangedSessionMsg userUpdateMsg(m_id, user->GetName()->GetString(), user->GetID(), user->GetMuteState());
        NetworkOutMessagePtr msg = m_sessionConnection->CreateMessage(MessageID::SessionControl);
        
        msg->Write(new XString(userUpdateMsg.ToJSONString()));
        m_sessionConnection->Send(msg);
    }
}

void SessionServer::OnListSessionsRequest(const ListSessionsRequest&, const NetworkConnectionPtr& connection)
{
	// Fill in a message with a list of all the sessions and send it

	ListSessionsReply reply;

	reply.SetSessionCount(static_cast<int32>(m_sessions.size()));

	for (size_t i = 0; i < m_sessions.size(); ++i)
	{
		XSessionImplPtr currentSession = m_sessions[i];

		reply.SetSessionDescriptor((int32)i, currentSession->GetSessionDescription(connection->GetSocket()));
	}

	NetworkOutMessagePtr msg = connection->CreateMessage(MessageID::SessionControl);
	msg->Write(reply.ToJSONString());

	connection->Send(msg);
}

void SendToForwarder::OnMessageReceived(const NetworkConnectionPtr& connection, NetworkInMessage& message)
{
	const byte* inMsg = message.GetData();
	const uint32 inMsgSize = message.GetSize();

	// Get the sendto header
	const SendToNetworkHeader* sendToHeader = reinterpret_cast<const SendToNetworkHeader*>(inMsg);

	// Extract the payload from the sendto message and put in a new outgoing message
	const byte* payload = inMsg + sizeof(SendToNetworkHeader);
	const uint32 payloadSize = inMsgSize - sizeof(SendToNetworkHeader);

	if (payloadSize > 0)
	{
		NetworkOutMessagePtr outMsg = connection->CreateMessage(*payload);
		outMsg->WriteArray(payload + 1, payloadSize - 1);

		// Send the payload to the correct remote peer
		auto userConnectionItr = m_connections.find(sendToHeader->m_userID);
		if (userConnectionItr != m_connections.end())
		{
			ClientRole role = sendToHeader->m_deviceRole;

			if (role == ClientRole::Primary ||
				role == ClientRole::Unspecified)
			{
				// Forward the message on with the same settings that it was sent here with
				userConnectionItr->second.m_primaryConnection ->Send(outMsg, sendToHeader->m_priority, sendToHeader->m_reliability, sendToHeader->m_channel, false);
			}

			if (role == ClientRole::Secondary ||
				role == ClientRole::Unspecified)
			{
				// Forward the message on with the same settings that it was sent here with
				userConnectionItr->second.m_secondaryConnection->Send(outMsg, sendToHeader->m_priority, sendToHeader->m_reliability, sendToHeader->m_channel, false);
			}
		}

		connection->ReturnMessage(outMsg);
	}
}

void SyncManagerImpl::SendSyncMessage(RemoteSyncPeer& remotePeer)
{
	if (remotePeer.m_bHandshakeComplete)
	{
		// If our list of ops to send is empty, and we have more than 2 ops that we have not acknowledged,
		// send a noop so the remote machine can release its outgoing queue and save some memory
		if (remotePeer.m_sendList.empty() && 
			remotePeer.m_lastAcknowledgedVersion < remotePeer.m_localState.m_opsReceived)
		{
			VersionedOp op;
			op.m_op = new AckOperation(AuthorityLevel::Unknown);
			op.m_state = remotePeer.m_localState;
			remotePeer.m_sendList.push_back(op);
		}

		if (!remotePeer.m_sendList.empty()) // We have ops to send
		{
#if defined(SYNC_DEBUG)
			LogInfo("Sending messages to %s", remotePeer.m_userName.c_str());
#endif

			NetworkOutMessagePtr msg = remotePeer.m_connection->CreateMessage(m_messageID);

			// Add the sub-type of the message
			msg->Write((byte)SyncChanges);

			// Write out the number of ops sent in this message
			msg->Write((int32)remotePeer.m_sendList.size());

			// Write out each of the ops
			for (VersionedOpList::iterator it = remotePeer.m_sendList.begin(); it != remotePeer.m_sendList.end(); ++it)
			{
				VersionedOp& currentOp = *it;

#if defined(SYNC_DEBUG)
				LogInfo(" - %s, version %i %i", currentOp.m_op->GetOpDescription().c_str(), currentOp.m_state.m_opsSent, currentOp.m_state.m_opsReceived);
#endif

				// Add our view of the messages sent and received
				msg->Write(currentOp.m_state.m_opsSent);
				msg->Write(currentOp.m_state.m_opsReceived);

				// Write the type of the op
				msg->Write((byte)currentOp.m_op->GetType());

				// Write the op data
				currentOp.m_op->Serialize(msg);

				// Record that we have acknowledged all the messages received
				remotePeer.m_lastAcknowledgedVersion = currentOp.m_state.m_opsReceived;
			}

			// Send the message
			remotePeer.m_connection->Send(msg);

			remotePeer.m_sendList.clear();
		}
	}
}

void CreateOperation::Serialize(const NetworkOutMessagePtr& msg) const
{
	msg->Write((byte)m_elementType);
	msg->Write(m_name);
	msg->Write(m_elementGuid);
	msg->Write(m_parentGuid);
	m_startingValue.Serialize(msg);

	// Write the number of ancestors
	msg->Write(static_cast<uint32>(m_hierarchy.size()));

	// Write the GUIDs of the ancestors
	for (size_t i = 0; i < m_hierarchy.size(); ++i)
	{
		msg->Write(m_hierarchy[i]);
	}

	// NOTE: authority level is NOT included in the op when serialized; it changes as the op is sent around the network
}

void SyncManagerImpl::SendHandshakeMessage(RemoteSyncPeer& remotePeer)
{
#if defined(SYNC_DEBUG)
	LogInfo("%s Sending Handshake", m_syncContext->GetLocalUser()->GetName().GetString().c_str());
#endif

	// We should not be sending a handshake message if its already complete
	XTASSERT(remotePeer.m_bHandshakeComplete == false);

	// Ask the remote machine to send over its systemID and its sync auth level
	NetworkOutMessagePtr identityMsg = remotePeer.m_connection->CreateMessage(m_messageID);
	identityMsg->Write((byte)IdentityInfo);
	identityMsg->Write((byte)m_syncContext->GetAuthorityLevel());
	identityMsg->Write(m_syncContext->GetLocalSystemID());

	identityMsg->Write(m_syncContext->GetLocalUser()->GetName());
	identityMsg->Write(m_syncContext->GetLocalUser()->GetID());

	remotePeer.m_connection->Send(identityMsg);
}

void ProfileManagerImpl::Update()
{
	// If we're connected to the profiling tool...
	if (m_isConnected)
	{
		// Send the accumulated profiling entries to the profiler tool
		NetworkOutMessagePtr msg = m_connection->CreateMessage(MessageID::Profiling);

		EndRange();

		// Record the time it takes to pack up and send the data
		ProfileEntry sendInfoEntry("Send Profiling Data", 0);
		sendInfoEntry.Start();

		// Add the profiling entries to the outgoing packet
		{
			ScopedLock threadMapLock(m_threadStackMutex);

			// Write the number of threads
			int32 numThreads = (int32)m_threadEntries.size();
			msg->Write(numThreads);

			for (auto mapIt = m_threadEntries.begin(); mapIt != m_threadEntries.end(); ++mapIt)
			{
				ThreadInfoPtr threadInfo = mapIt->second;
				ScopedLock entryListLock(threadInfo->m_mutex);

				// Write the threadID
				msg->Write(threadInfo->m_threadID);

				std::vector<ProfileEntry>& entries = threadInfo->m_entries;

				// Write the number of entries in this thread
				uint32 numEntries = (uint32)threadInfo->m_entries.size();
				msg->Write(numEntries);

				// Write each entry
				for (size_t i = 0; i < numEntries; ++i)
				{
					msg->Write(entries[i].GetName());	// Write the name
					msg->Write(entries[i].GetStartTime());
					msg->Write(entries[i].GetDuration());
					msg->Write(entries[i].GetParent());
				}

				// Clear out the list and get ready for the next frame
				threadInfo->m_currentIndex = -1;
			}

			m_threadEntries.clear();
		}

		// Add the log messages to the packet
		{
			ScopedLock lock(m_logMutex);

			// Write the number of log messages
			uint32 numMessages = (uint32)m_logMessages.size();
			msg->Write(numMessages);

			for (uint32 i = 0; i < numMessages; ++i)
			{
				msg->Write((byte)m_logMessages[i].m_severity);
				msg->Write(m_logMessages[i].m_message);
			}

			m_logMessages.clear();
		}


		BeginRange("Profile Frame");

		m_connection->Send(msg, MessagePriority::Low, MessageReliability::ReliableOrdered, MessageChannel::ProfileChannel);

		// Add the time it took to pack up and send the data to the start of the next frame
		sendInfoEntry.End();
		ThreadInfoPtr threadInfo = GetLocalThreadInfo();
		if (threadInfo)
		{
			ScopedLock lock(threadInfo->m_mutex);
			threadInfo->m_entries.push_back(sendInfoEntry);
		}
	}
}

void SessionServer::OnNewSessionRequest(const NewSessionRequest& request, const NetworkConnectionPtr& connection)
{
	std::string name = request.GetSessionName();

	XSessionImplPtr session;
	std::string failureReason;

	// Cannot create a session with a name that is too short
	if (name.length() < kMinSessionNameLength)
	{
		failureReason = "Session name must have at least " + std::to_string(kMinSessionNameLength) + " letters";
	}

	// Cannot create a session with a name that is too long
	else if (name.length() > kMaxSessionNameLength)
	{
		failureReason = "Session name cannot be more than " + std::to_string(kMaxSessionNameLength) + " letters";
	}
	else
	{
		// Check to make sure that the requested session name is not already taken
		for (size_t i = 0; i < m_sessions.size(); ++i)
		{
			if (m_sessions[i]->GetName() == name)
			{
				failureReason = "A session with that name already exists";
				break;
			}
		}
	}

	if (failureReason.empty())
	{
		session = CreateNewSession(name, request.GetSessionType());
	}
	
	// If the session was successfully created...
	if (session)
	{
		// Report success.
		std::string address = m_socketMgr->GetLocalAddressForRemoteClient(connection->GetSocket());
		uint16 port = session->GetPort();

		NewSessionReply reply(
			session->GetId(), 
			session->GetType(),
			name, 
			address, 
			port);

		NetworkOutMessagePtr response = connection->CreateMessage(MessageID::SessionControl);

		response->Write(reply.ToJSONString());

		connection->Send(response);
	}
	else
	{
		// Report failure
		NewSessionReply reply(failureReason);

		NetworkOutMessagePtr response = connection->CreateMessage(MessageID::SessionControl);

		response->Write(reply.ToJSONString());

		connection->Send(response);
	}
}

void SessionHandshakeLogic::CreateMessageFromDesktop(const NetworkOutMessagePtr& msg) const
{
	// Schema version
	msg->Write(kXToolsSchemaVersion);
}

void XSessionImpl::OnJoinSessionRequest(const JoinSessionRequest& request, const NetworkConnectionPtr& connection)
{
	// Note: this call will remove the remote client from the list of pending connections
	RemoteClientPtr remoteClient = GetPendingClientForConnection(connection);

	if (remoteClient)
	{
		// Fill in the rest of the info about the user
		remoteClient->m_userName = request.GetUserName();
		remoteClient->m_userID = request.GetUserID();
		remoteClient->m_userMuteState = request.GetMuteState();

		// Check to see if this userID is already in use by someone in the session
		bool bDuplicateUserID = false;
		for (size_t clientIndex = 0; clientIndex < m_clients.size(); ++clientIndex)
		{
			if (m_clients[clientIndex]->m_userID == remoteClient->m_userID)
			{
				bDuplicateUserID = true;
				LogError("UserID %i in session join request is a duplicate of a user already in this session.  ", remoteClient->m_userID);
				break;
			}
		}

		// Check to see if the userID is valid
		bool bIsInvalidUserID = false;
		if (remoteClient->m_userID == User::kInvalidUserID)
		{
			LogError("Received invalid userID");
			bIsInvalidUserID = true;
		}

		// If the connecting user is invalid, then send a failure response and shut down the connection
		if (bIsInvalidUserID || bDuplicateUserID)
		{
			// Reply to the user that they have failed to join the session
			{
				JoinSessionReply reply(false);

				NetworkOutMessagePtr msg = connection->CreateMessage(MessageID::SessionControl);
				msg->Write(reply.ToJSONString());
				connection->Send(msg);
			}

			// Disconnect
			connection->Disconnect();
		}
		else
		{
			LogInfo("User %s at address %s joined session %s", remoteClient->m_userName.c_str(), remoteClient->m_primaryConnection->GetRemoteAddress()->GetString().c_str(), GetName().c_str());

			// Add the user to the real list of clients in the session
			m_clients.push_back(remoteClient);

			// Reply to the user that they have now joined the session successfully
			{
				JoinSessionReply reply(true);

				NetworkOutMessagePtr msg = connection->CreateMessage(MessageID::SessionControl);
				msg->Write(reply.ToJSONString());
				connection->Send(msg);
			}

			// Add the remoteClient to the list that can send and receive broadcasts
			m_broadcaster->AddConnection(remoteClient->m_primaryConnection);
			m_broadcaster->AddConnection(remoteClient->m_secondaryConnection);

			// Add the remoteClient to the sendto forwarder
			m_sendToForwarder->AddConnection(remoteClient->m_userID, remoteClient->m_primaryConnection, remoteClient->m_secondaryConnection);

			// Add the remoteClient to the audio packet processor
			m_audioSessionProcessor->AddConnection(remoteClient->m_primaryConnection);
			m_audioSessionProcessor->AddConnection(remoteClient->m_secondaryConnection);

			// Add the connections to the room manager
			m_roomMgr->AddConnection(remoteClient->m_primaryConnection);
			m_roomMgr->AddConnection(remoteClient->m_secondaryConnection);

			// Add the remoteClient to the list that can share the session's sync data
			m_syncMgr->AddConnection(remoteClient->m_primaryConnection);
			m_internalSyncMgr->AddConnection(remoteClient->m_primaryConnection);

			// Notify the session server to tell all the clients that the new user has joined this session
			m_callback->OnUserJoinedSession(m_id, remoteClient->m_userName, remoteClient->m_userID, remoteClient->m_userMuteState);
		}
	}
}