summaryrefslogtreecommitdiffstats
path: root/logic/launch/LoggedProcess.cpp
blob: 88ca40aa869b6c910f98fd0e1923906e1cccfa19 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#include "LoggedProcess.h"
#include "MessageLevel.h"
#include <QDebug>

LoggedProcess::LoggedProcess(QObject *parent) : QProcess(parent)
{
	// QProcess has a strange interface... let's map a lot of those into a few.
	connect(this, &QProcess::readyReadStandardOutput, this, &LoggedProcess::on_stdOut);
	connect(this, &QProcess::readyReadStandardError, this, &LoggedProcess::on_stdErr);
	connect(this, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(on_exit(int,QProcess::ExitStatus)));
	connect(this, SIGNAL(error(QProcess::ProcessError)), this, SLOT(on_error(QProcess::ProcessError)));
	connect(this, &QProcess::stateChanged, this, &LoggedProcess::on_stateChange);
}

QStringList reprocess(const QByteArray & data, QString & leftover)
{
	QString str = leftover + QString::fromLocal8Bit(data);

	str.remove('\r');
	QStringList lines = str.split("\n");
	leftover = lines.takeLast();
	return lines;
}

void LoggedProcess::on_stdErr()
{
	auto lines = reprocess(readAllStandardError(), m_err_leftover);
	emit log(lines, MessageLevel::StdErr);
}

void LoggedProcess::on_stdOut()
{
	auto lines = reprocess(readAllStandardOutput(), m_out_leftover);
	emit log(lines, MessageLevel::StdOut);
}

void LoggedProcess::on_exit(int exit_code, QProcess::ExitStatus status)
{
	// save the exit code
	m_exit_code = exit_code;

	// Flush console window
	if (!m_err_leftover.isEmpty())
	{
		emit log({m_err_leftover}, MessageLevel::StdErr);
		m_err_leftover.clear();
	}
	if (!m_out_leftover.isEmpty())
	{
		emit log({m_err_leftover}, MessageLevel::StdOut);
		m_out_leftover.clear();
	}

	// based on state, send signals
	if (!m_is_aborting)
	{
		if (status == QProcess::NormalExit)
		{
			//: Message displayed on instance exit
			emit log({tr("Process exited with code %1.").arg(exit_code)}, MessageLevel::MultiMC);
			changeState(LoggedProcess::Finished);
		}
		else
		{
			//: Message displayed on instance crashed
			if(exit_code == -1)
				emit log({tr("Process crashed.")}, MessageLevel::MultiMC);
			else
				emit log({tr("Process crashed with exitcode %1.").arg(exit_code)}, MessageLevel::MultiMC);
			changeState(LoggedProcess::Crashed);
		}
	}
	else
	{
		//: Message displayed after the instance exits due to kill request
		emit log({tr("Process was killed by user.")}, MessageLevel::Error);
		changeState(LoggedProcess::Aborted);
	}
}

void LoggedProcess::on_error(QProcess::ProcessError error)
{
	switch(error)
	{
		case QProcess::FailedToStart:
		{
			emit log({tr("The process failed to start.")}, MessageLevel::Fatal);
			changeState(LoggedProcess::FailedToStart);
			break;
		}
		// we'll just ignore those... never needed them
		case QProcess::Crashed:
		case QProcess::ReadError:
		case QProcess::Timedout:
		case QProcess::UnknownError:
		case QProcess::WriteError:
			break;
	}
}

void LoggedProcess::kill()
{
	m_is_aborting = true;
	QProcess::kill();
}

int LoggedProcess::exitCode() const
{
	return m_exit_code;
}

void LoggedProcess::changeState(LoggedProcess::State state)
{
	if(state == m_state)
		return;
	m_state = state;
	emit stateChanged(m_state);
}

LoggedProcess::State LoggedProcess::state() const
{
	return m_state;
}

void LoggedProcess::on_stateChange(QProcess::ProcessState state)
{
	switch(state)
	{
		case QProcess::NotRunning:
			break; // let's not - there are too many that handle this already.
		case QProcess::Starting:
		{
			if(m_state != LoggedProcess::NotRunning)
			{
				qWarning() << "Wrong state change for process from state" << m_state << "to" << (int) LoggedProcess::Starting;
			}
			changeState(LoggedProcess::Starting);
			return;
		}
		case QProcess::Running:
		{
			if(m_state != LoggedProcess::Starting)
			{
				qWarning() << "Wrong state change for process from state" << m_state << "to" << (int) LoggedProcess::Running;
			}
			changeState(LoggedProcess::Running);
			return;
		}
	}
}

#if defined Q_OS_WIN32
#include <windows.h>
#endif

qint64 LoggedProcess::processId() const
{
#ifdef Q_OS_WIN
    return pid() ? pid()->dwProcessId : 0;
#else
    return pid();
#endif
}