birkeh
/
o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
development
monroegm-disable-blank-issue-2
main
2111.2
2111.1
2107.1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c492d644da'
${ noResults }
o3de/Code/Tools/GridHub/GridHub/gridhub.cpp

737 lines
25 KiB
C++
Raw Blame History

/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/PlatformIncl.h>
AZ_PUSH_DISABLE_WARNING(4244 4251, "-Wunknown-warning-option")
#include <QtGui>
#include <QtWidgets/QMenu>
#include <QtNetwork/QHostInfo>
AZ_POP_DISABLE_WARNING
#ifdef AZ_PLATFORM_WINDOWS
#include <AzCore/PlatformIncl.h>
#else
#include <signal.h>
#endif
#include "gridhub.hxx"
#include <GridHub/moc_gridhub.cpp>
#include <AzCore/Component/ComponentApplication.h>
#include <AzCore/PlatformId/PlatformId.h>
#include <AzCore/std/parallel/lock.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <GridMate/Carrier/Utils.h>
#include <GridMate/Session/LANSession.h>
#include <time.h> // for output timestamp
//////////////////////////////////////////////////////////////////////////
GridHub::GridHub(AZ::ComponentApplication* componentApp, GridHubComponent* hubComponent, QWidget *parent, Qt::WindowFlags flags)
: QWidget(parent, flags)
, m_componentApp(componentApp)
, m_hubComponent(hubComponent)
{
// create actions
//m_minimizeAction = new QAction(tr("Mi&nimize"), this);
//connect(m_minimizeAction, SIGNAL(triggered()), this, SLOT(hide()));
//m_maximizeAction = new QAction(tr("Ma&ximize"), this);
//connect(m_maximizeAction, SIGNAL(triggered()), this, SLOT(showMaximized()));
m_restoreAction = new QAction(tr("&Show"), this);
connect(m_restoreAction, SIGNAL(triggered()), this, SLOT(showNormal()));
m_quitAction = new QAction(tr("&Quit"), this);
connect(m_quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
// create menu
m_trayIconMenu = new QMenu(this);
//m_trayIconMenu->addAction(m_minimizeAction);
//m_trayIconMenu->addAction(m_maximizeAction);
m_trayIconMenu->addAction(m_restoreAction);
m_trayIconMenu->addSeparator();
m_trayIconMenu->addAction(m_quitAction);
// create tray icon
m_trayIcon = new QSystemTrayIcon(this);
m_trayIcon->setContextMenu(m_trayIconMenu);
m_trayIcon->setToolTip(QString("Amazon Debug Connection Hub - GridHub"));
m_trayIcon->setIcon(QIcon(":/GridHub/Resources/Disconnected.png"));
connect(m_trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(iconActivated(QSystemTrayIcon::ActivationReason)));
m_trayIcon->show();
setWindowFlags(Qt::Dialog);
ui.setupUi(this);
QObject::connect(ui.startStopService,SIGNAL(clicked()),this,SLOT(OnStartStopSession()));
ui.sessionPort->setValue(m_hubComponent->GetSessionPort());
QObject::connect(ui.sessionPort, SIGNAL(valueChanged(int)),this, SLOT(SetSessionPort(int)));
ui.numSlots->setValue(m_hubComponent->GetSessionSlots());
QObject::connect(ui.numSlots, SIGNAL(valueChanged(int)),this, SLOT(SetSessionSlots(int)));
ui.hubName->setText(QString(m_hubComponent->GetHubName().c_str()));
QObject::connect(ui.hubName, SIGNAL(textChanged(QString)),this, SLOT(SetHubName(QString)));
ui.isDisconnectDetect->setChecked(m_hubComponent->IsEnableDisconnectDetection());
QObject::connect(ui.isDisconnectDetect, SIGNAL(stateChanged(int)),this,SLOT(EnableDisconnectDetection(int)));
ui.isAddToStartup->setChecked(m_hubComponent->IsAddToStartupFolder());
QObject::connect(ui.isAddToStartup, SIGNAL(stateChanged(int)),this,SLOT(AddToStartupFolder(int)));
ui.isLogToFile->setChecked(m_hubComponent->IsLogToFile());
QObject::connect(ui.isLogToFile, SIGNAL(stateChanged(int)),this,SLOT(LogToFile(int)));
ui.disconnectionTimeout->setValue(m_hubComponent->GetDisconnectionTimeout());
QObject::connect(ui.disconnectionTimeout, SIGNAL(valueChanged(int)),this,SLOT(OnDisconnectTimeOutChange(int)));
SanityCheckDetectionTimeout();
// start at XX ms update interval
startTimer(30);
AZ::Debug::TraceMessageBus::Handler::BusConnect();
AZ::AllocatorInstance<GridMate::GridMateAllocatorMP>::Create();
// start the session
OnStartStopSession();
// Kicks off the tool's tick event
SystemTick();
}
GridHub::~GridHub()
{
AZ::Debug::TraceMessageBus::Handler::BusDisconnect();
if (m_hubComponent)
{
m_hubComponent->StopSession();
}
AZ::AllocatorInstance<GridMate::GridMateAllocatorMP>::Destroy();
delete m_trayIcon;
delete m_trayIconMenu;
delete m_quitAction;
delete m_restoreAction;
//delete m_maximizeAction;
//delete m_minimizeAction;
}
void GridHub::SystemTick()
{
AZ::SystemTickBus::ExecuteQueuedEvents();
AZ::SystemTickBus::Broadcast(&AZ::SystemTickEvents::OnSystemTick);
QTimer::singleShot(10, Qt::PreciseTimer, this, &GridHub::SystemTick);
}
//=========================================================================
// closeEvent
// [7/6/2012]
//=========================================================================
void GridHub::closeEvent(QCloseEvent *event)
{
if (m_trayIcon->isVisible()) {
/* QMessageBox::information(this, tr("GridHub - Amazon Debug Connection Hub"),
tr("The program will keep running in the "
"system tray. To terminate the program, "
"choose <b>Quit</b> in the context menu "
"that pops up when clicking this program's "
"entry in the system tray."));*/
hide();
event->ignore();
}
}
void GridHub::SanityCheckDetectionTimeout()
{
ui.disconnectionTimeout->setEnabled(m_hubComponent->IsEnableDisconnectDetection());
}
//=========================================================================
// timerEvent
// [7/6/2012]
//=========================================================================
void GridHub::timerEvent([[maybe_unused]] QTimerEvent *event)
{
m_componentApp->Tick();
if( !m_hubComponent->IsInSession() )
{
// if we get an address 169.X.X.X (AZCP is NOT ready) or 127.0.0.1 when network is not ready
AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
static AZStd::chrono::system_clock::time_point lastUpdate = now;
if( AZStd::chrono::seconds(now - lastUpdate).count() >= 10 )
{
// Try to start it again...
OnStartStopSession();
lastUpdate = now;
}
}
UpdateOutput();
UpdateMembers();
}
//=========================================================================
// UpdateOutput
// [5/24/2011]
//=========================================================================
void GridHub::UpdateOutput()
{
if( m_output.empty() ) return;
m_outputMutex.lock();
QString msg(m_output.c_str());
m_output.clear();
m_outputMutex.unlock();
if(msg.endsWith('\n')) // append already inserts '\n' at the end
msg.chop(1);
ui.output->append(msg);
}
//=========================================================================
// UpdateMembers
// [7/11/2012]
//=========================================================================
void GridHub::UpdateMembers()
{
// update ~1 time a sec
AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
static AZStd::chrono::system_clock::time_point lastUpdate = now;
if( AZStd::chrono::milliseconds(now - lastUpdate).count() < 1000 )
return;
lastUpdate = now;
const GridMate::GridSession* session = m_hubComponent->GetSession();
if( m_hubComponent == nullptr || session == nullptr || !session->IsReady() )
{
ui.members->setRowCount(0);
}
else
{
ui.members->setRowCount(session->GetNumberOfMembers());
for(unsigned int i = 0; i < session->GetNumberOfMembers(); ++i)
{
GridMate::GridMember* member = session->GetMemberByIndex(i);
ui.members->setItem(i,0,new QTableWidgetItem(member->GetId().ToString().c_str()));
ui.members->setItem(i,1,new QTableWidgetItem(member->GetName().c_str()));
ui.members->setItem(i,2,new QTableWidgetItem(member->GetConnectionId()==GridMate::InvalidConnectionID ? "--" : QString::number((size_t)member->GetConnectionId())));
ui.members->setItem(i,3,new QTableWidgetItem(member->IsHost()?"Yes":"No"));
ui.members->setItem(i,4,new QTableWidgetItem(member->IsLocal()?"Yes":"No"));
ui.members->setItem(i,5,new QTableWidgetItem(member->IsReady()?"Yes":"No"));
}
}
}
//=========================================================================
// TraceOutput
// [5/20/2011]
//=========================================================================
bool GridHub::OnOutput(const char* window, const char* message)
{
const QString time = QDateTime::currentDateTime().toString("HH:mm:ss|");
{
// This function will be called from multiple threads
const AZStd::lock_guard<AZStd::mutex> l(m_outputMutex);
m_output += time.toUtf8().data();
m_output += window;
m_output += " : ";
m_output += message;
}
return false;
}
//=========================================================================
// OnStartStopSession
// [7/6/2012]
//=========================================================================
void GridHub::OnStartStopSession()
{
if( m_hubComponent->IsInSession() )
{
m_hubComponent->StopSession();
ui.startStopService->setText("Start");
m_trayIcon->setIcon(QIcon(":/GridHub/Resources/Disconnected.png"));
}
else
{
if( m_hubComponent->StartSession() )
{
ui.startStopService->setText("Stop");
m_trayIcon->setIcon(QIcon(":/GridHub/Resources/Connected.png"));
}
}
}
//=========================================================================
// SetSessionPort
// [7/11/2012]
//=========================================================================
void GridHub::SetSessionPort(int port)
{
m_hubComponent->SetSessionPort(static_cast<unsigned short>(port));
}
//=========================================================================
// SetSessionSlots
// [7/11/2012]
//=========================================================================
void GridHub::SetSessionSlots(int numberOfSlots)
{
m_hubComponent->SetSessionSlots(static_cast<unsigned char>(numberOfSlots));
}
//=========================================================================
// EnableDisconnectDetection
// [9/14/2012]
//=========================================================================
void GridHub::EnableDisconnectDetection(int state)
{
m_hubComponent->EnableDisconnectDetection(state != 0);
SanityCheckDetectionTimeout();
}
//=========================================================================
// EnableDisconnectDetection
// [10/2/2012]
//=========================================================================
void GridHub::AddToStartupFolder(int state)
{
m_hubComponent->AddToStartupFolder(state != 0);
}
//=========================================================================
// LogToFile
// [7/2/2013]
//=========================================================================
void GridHub::LogToFile(int state)
{
m_hubComponent->LogToFile(state != 0);
}
void GridHub::OnDisconnectTimeOutChange(int value)
{
m_hubComponent->SetDisconnectionTimeOut(value);
}
//=========================================================================
// SetHubName
// [9/6/2012]
//=========================================================================
void GridHub::SetHubName(const QString & name)
{
m_hubComponent->SetHubName(AZStd::string(name.toUtf8().constData()));
}
//////////////////////////////////////////////////////////////////////////
//
//=========================================================================
// GridHubComponent
// [7/6/2012]
//=========================================================================
GridHubComponent::GridHubComponent()
: m_ui(nullptr)
, m_gridMate(nullptr)
, m_session(nullptr)
{
m_sessionPort = 5172;
m_numberOfSlots = 10;
m_isDisconnectDetection = true;
m_disconnectionTimeout = 5000;
m_isAddToStartupFolder = false;
m_isLogToFile = false;
#ifdef AZ_PLATFORM_WINDOWS
wchar_t name[MAX_COMPUTERNAME_LENGTH + 1];
DWORD dwCompNameLen = AZ_ARRAY_SIZE(name);
if (GetComputerName(name, &dwCompNameLen) != 0)
{
AZStd::to_string(m_hubName, name);
}
else
#endif
m_hubName = QHostInfo::localHostName().toUtf8().data();
}
//=========================================================================
// ~GridHubComponent
// [7/6/2012]
//=========================================================================
GridHubComponent::~GridHubComponent()
{
}
//=========================================================================
// Init
// [7/6/2012]
//=========================================================================
void GridHubComponent::Init()
{
}
//=========================================================================
// Activate
// [7/6/2012]
//=========================================================================
void GridHubComponent::Activate()
{
AZ::Debug::TraceMessageBus::Handler::BusConnect();
}
//=========================================================================
// Deactivate
// [7/6/2012]
//=========================================================================
void GridHubComponent::Deactivate()
{
if( IsInSession() )
StopSession();
AZ_Assert(m_monitored.empty(),"We should have removed all monitored members already!");
AZ::Debug::TraceMessageBus::Handler::BusDisconnect();
}
//=========================================================================
// OnSystemTick
//=========================================================================
void GridHubComponent::OnSystemTick()
{
if( m_gridMate )
{
m_gridMate->Update();
if( m_session == nullptr )
{
// It does have in certain condition that the PC was locked and we did not receive OnTick for a long time
// GridMate will detect that and delete the session in the update. If that happens we should just restart the entire gridmate.
RestartSession();
}
else
{
if (m_session->GetReplicaMgr())
{
m_session->GetReplicaMgr()->Unmarshal();
m_session->GetReplicaMgr()->UpdateFromReplicas();
m_session->GetReplicaMgr()->UpdateReplicas();
m_session->GetReplicaMgr()->Marshal();
}
if( !m_session->DebugIsEnableDisconnectDetection() )
{
AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
static AZStd::chrono::system_clock::time_point lastUpdate = now;
if( AZStd::chrono::milliseconds(now - lastUpdate).count() >= 1000)
{
lastUpdate = now;
// when we have disconnect detection off, check if the process terminated
ExternalProcessMonitor* memberToKick = nullptr;
for(size_t i = 0; i < m_monitored.size(); ++i)
{
ExternalProcessMonitor& mi = m_monitored[i];
#ifdef AZ_PLATFORM_WINDOWS
if( mi.m_localProcess != INVALID_HANDLE_VALUE )
{
DWORD exitCode = 0;
GetExitCodeProcess(mi.m_localProcess,&exitCode);
if( exitCode != STILL_ACTIVE )
{
memberToKick = &mi;
break;
}
}
#else
if (mi.m_localProcess != 0)
{
if (kill(mi.m_localProcess, 0) != 0)
{
memberToKick = &mi;
break;
}
}
#endif
}
if( memberToKick )
{
GridMate::GridMember* member = m_session->GetMemberById(memberToKick->m_memberId);
if( member )
{
AZ_Printf("GridHub","Kicking member %s due to process inactivity!\n",member->GetId().ToString().c_str());
m_session->KickMember(member);
}
}
}
}
}
}
}
//=========================================================================
// LogToFile
// [7/2/2013]
//=========================================================================
void GridHubComponent::LogToFile(bool enable)
{
if( m_isLogToFile && !enable )
{
AZ_Printf("GridHub","Logging stopped!"); // indicate in the log that the user stopped logging.
}
m_isLogToFile = enable;
}
//=========================================================================
// OnOutput
// [7/2/2013]
//=========================================================================
bool GridHubComponent::OnOutput(const char* window, const char* message)
{
if( m_isLogToFile )
{
if( !m_logFile.IsOpen() )
{
const char* logFileName = "GridHubEvents.log"; // we can make this user configurable
if( !m_logFile.Open(logFileName,AZ::IO::SystemFile::SF_OPEN_APPEND) )
{
m_logFile.Open(logFileName,AZ::IO::SystemFile::SF_OPEN_CREATE);
}
}
if( m_logFile.IsOpen() )
{
const QByteArray time = QDateTime::currentDateTime().toString("MM:dd:yy-HH:mm:ss|").toUtf8();
m_logFile.Write(time.data(),time.size());
m_logFile.Write(window,strlen(window));
m_logFile.Write(" : ", 3);
m_logFile.Write(message,strlen(message));
}
}
return false;
}
//=========================================================================
// OnMemberJoined
// [5/25/2011]
//=========================================================================
void
GridHubComponent::OnMemberJoined([[maybe_unused]] GridMate::GridSession* session, GridMate::GridMember* member)
{
if( member->IsLocal() ) return;
// add non local member for process monitoring.
GridMate::MemberIDCompact id = member->GetId().Compact();
switch( member->GetPlatformId() )
{
case AZ::PlatformID::PLATFORM_WINDOWS_64:
case AZ::PlatformID::PLATFORM_APPLE_MAC:
{
AZStd::string localMachineName = GridMate::Utils::GetMachineAddress();
if( member->GetMachineName() == localMachineName )
{
ExternalProcessMonitor mi;
mi.m_memberId = id;
#ifdef AZ_PLATFORM_WINDOWS
mi.m_localProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION,TRUE,member->GetProcessId());
if( mi.m_localProcess != INVALID_HANDLE_VALUE )
m_monitored.push_back(mi);
#else
mi.m_localProcess = member->GetProcessId();
m_monitored.push_back(mi);
#endif
}
}break;
}
}
//=========================================================================
// OnMemberLeaving
// [5/25/2011]
//=========================================================================
void
GridHubComponent::OnMemberLeaving([[maybe_unused]] GridMate::GridSession* session, GridMate::GridMember* member)
{
GridMate::MemberIDCompact id = member->GetId().Compact();
for(size_t i = 0; i < m_monitored.size(); ++i )
{
ExternalProcessMonitor& mi = m_monitored[i];
if( mi.m_memberId == id )
{
#ifdef AZ_PLATFORM_WINDOWS
if( mi.m_localProcess != INVALID_HANDLE_VALUE )
CloseHandle(mi.m_localProcess);
#endif
m_monitored.erase(m_monitored.begin()+i);
break;
}
}
}
//=========================================================================
// OnSessionCreated
// [5/24/2011]
//=========================================================================
void
GridHubComponent::OnSessionCreated(GridMate::GridSession* session)
{
AZ_Assert(m_session==session,"Session missmatch!");
m_session = session;
}
//=========================================================================
// OnSessionDelete
// [5/24/2011]
//=========================================================================
void
GridHubComponent::OnSessionDelete([[maybe_unused]] GridMate::GridSession* session)
{
AZ_Assert(m_session==session,"Session missmatch!");
m_session = nullptr;
}
//=========================================================================
// StartSession
// [7/6/2012]
//=========================================================================
bool GridHubComponent::StartSession(bool isRestarting)
{
AZ_Assert(m_gridMate==nullptr,"Session was ALREADY started!");
m_gridMate = GridMate::GridMateCreate(GridMate::GridMateDesc());
AZ_Assert(m_gridMate,"Failed to create a gridmate instance!");
// Connect for session events
GridMate::SessionEventBus::Handler::BusConnect(m_gridMate);
if (!isRestarting)
{
AZ::SystemTickBus::Handler::BusConnect();
}
// start the multiplayer service (session mgr, extra allocator, etc.)
GridMate::StartGridMateService<GridMate::LANSessionService>(m_gridMate, GridMate::SessionServiceDesc());
AZ_Assert(GridMate::HasGridMateService<GridMate::LANSessionService>(m_gridMate), "Failed to start multiplayer service for LAN!");
// if we get an address 169.X.X.X (AZCP is NOT ready) or 127.0.0.1 when network is not ready
AZStd::string machineIP = GridMate::Utils::GetMachineAddress();
if( machineIP == "127.0.0.1" || machineIP.compare(0,4,"169.") == 0 )
{
AZ_Warning("GridHub", false, "\nCurrent IP %s might be invalid.\n",machineIP.c_str());
}
GridMate::CarrierDesc carrierDesc;
//carrierDesc.m_port = 0;
carrierDesc.m_enableDisconnectDetection = m_isDisconnectDetection;
carrierDesc.m_driverIsCrossPlatform = true;
carrierDesc.m_connectionTimeoutMS = m_disconnectionTimeout;
//carrierDesc.m_driverIsFullPackets = true;
// host session
GridMate::LANSessionParams sp;
sp.m_topology = GridMate::ST_PEER_TO_PEER;
// Until an authentication connection can be established between peers only supporting
// local connections (i.e. binding to localhost).
sp.m_address = "127.0.0.1";
carrierDesc.m_address = "127.0.0.1";
sp.m_numPublicSlots = m_numberOfSlots;
sp.m_numPrivateSlots = 1;
sp.m_port = m_sessionPort;
sp.m_flags = 0; // no host migration support
sp.m_numParams = 2;
sp.m_params[0].m_id = "GridHubVersion";
sp.m_params[0].SetValue(2);
sp.m_params[1].m_id = "HubName";
sp.m_params[1].SetValue(m_hubName);
EBUS_EVENT_ID_RESULT(m_session,m_gridMate,GridMate::LANSessionServiceBus,HostSession,sp,carrierDesc);
AZ_Assert(m_session,"Failed to host a session!");
return true;
}
//=========================================================================
// StopSession
// [7/6/2012]
//=========================================================================
void GridHubComponent::StopSession(bool isRestarting)
{
AZ_Assert(m_gridMate!=nullptr,"Session was NOT started!");
// disconnect from events
if (!isRestarting)
{
AZ::SystemTickBus::Handler::BusDisconnect();
}
GridMate::SessionEventBus::Handler::BusDisconnect();
m_monitored.clear();
m_session = nullptr;
// destroy gridmate instance
GridMate::GridMateDestroy(m_gridMate);
m_gridMate = nullptr;
}
//=========================================================================
// RestartSession
// [5/3/2013]
//=========================================================================
void GridHubComponent::RestartSession()
{
AZ_TracePrintf("GridHub","GridMate restarting...");
StopSession(true);
StartSession(true);
}
//=========================================================================
// EnableDisconnectDetection
// [9/17/2012]
//=========================================================================
void GridHubComponent::EnableDisconnectDetection(bool en)
{
m_isDisconnectDetection = en;
if (m_session)
m_session->DebugEnableDisconnectDetection(m_isDisconnectDetection);
}
//=========================================================================
// Reflect
// [7/6/2012]
//=========================================================================
void GridHubComponent::Reflect(AZ::ReflectContext* reflection)
{
AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection);
if( serializeContext )
{
serializeContext->Class<GridHubComponent>()->
Version(3)->
Field("SessionPort", &GridHubComponent::m_sessionPort)->
Field("NumberOfSlots", &GridHubComponent::m_numberOfSlots)->
Field("HubName", &GridHubComponent::m_hubName)->
Field("IsDisconnectDetection", &GridHubComponent::m_isDisconnectDetection)->
Field("IsAddToStartupFolder", &GridHubComponent::m_isAddToStartupFolder)->
Field("IsLogToFile", &GridHubComponent::m_isLogToFile)->
Field("DisconnectionTimeOut", &GridHubComponent::m_disconnectionTimeout)
;
}
}
Reference in New Issue View Git Blame Copy Permalink