← Back to branch summary

~bzoltan/kubuntu-packaging/decouple_cmake_plugin

« back to all changes in this revision

Viewing changes to src/shared/qbs/src/app/qbs/commandlinefrontend.cpp

  • Committer: Timo Jyrinki
  • Date: 2013-12-02 09:16:15 UTC
  • mfrom: (1.1.29)
  • Revision ID: timo.jyrinki@canonical.com-20131202091615-xbj1os1f604ber1m
New upstream release candidate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/shared/qbs/src/app/qbs/commandlinefrontend.cpp
36
36
#include <qbs.h>
37
37
#include <api/runenvironment.h>
38
38
#include <logging/translator.h>
 
39
#include <tools/qbsassert.h>
39
40
 
40
41
#include <QDir>
41
42
#include <QMetaObject>
42
43
#include <QProcessEnvironment>
 
44
#include <QTimer>
43
45
#include <cstdlib>
44
46
 
45
47
namespace qbs {
47
49
 
48
50
CommandLineFrontend::CommandLineFrontend(const CommandLineParser &parser, Settings *settings,
49
51
                                         QObject *parent)
50
 
    : QObject(parent), m_parser(parser), m_settings(settings), m_observer(0), m_canceled(false)
51
 
{
52
 
}
53
 
 
 
52
    : QObject(parent)
 
53
    , m_parser(parser)
 
54
    , m_settings(settings)
 
55
    , m_observer(0)
 
56
    , m_cancelStatus(CancelStatusNone)
 
57
    , m_cancelTimer(new QTimer(this))
 
58
{
 
59
}
 
60
 
 
61
CommandLineFrontend::~CommandLineFrontend()
 
62
{
 
63
    m_cancelTimer->stop();
 
64
}
 
65
 
 
66
// Called from interrupt handler. Don't do anything non-trivial here.
54
67
void CommandLineFrontend::cancel()
55
68
{
56
 
    m_canceled = true;
57
 
    QMetaObject::invokeMethod(this, "doCancel", Qt::QueuedConnection);
 
69
    m_cancelStatus = CancelStatusRequested;
58
70
}
59
71
 
60
 
void CommandLineFrontend::doCancel()
 
72
void CommandLineFrontend::checkCancelStatus()
61
73
{
62
 
    if (m_resolveJobs.isEmpty() && m_buildJobs.isEmpty())
63
 
        std::exit(EXIT_FAILURE);
64
 
    foreach (AbstractJob * const job, m_resolveJobs)
65
 
        job->cancel();
66
 
    foreach (AbstractJob * const job, m_buildJobs)
67
 
        job->cancel();
 
74
    switch (m_cancelStatus) {
 
75
    case CancelStatusNone:
 
76
        break;
 
77
    case CancelStatusRequested:
 
78
        m_cancelStatus = CancelStatusCanceling;
 
79
        m_cancelTimer->stop();
 
80
        if (m_resolveJobs.isEmpty() && m_buildJobs.isEmpty())
 
81
            std::exit(EXIT_FAILURE);
 
82
        foreach (AbstractJob * const job, m_resolveJobs)
 
83
            job->cancel();
 
84
        foreach (AbstractJob * const job, m_buildJobs)
 
85
            job->cancel();
 
86
        break;
 
87
    case CancelStatusCanceling:
 
88
        QBS_ASSERT(false, return);
 
89
        break;
 
90
    }
68
91
}
69
92
 
70
93
void CommandLineFrontend::start()
107
130
        if (!m_parser.buildBeforeInstalling())
108
131
            params.setRestoreBehavior(SetupProjectParameters::RestoreOnly);
109
132
        foreach (const QVariantMap &buildConfig, m_parser.buildConfigurations()) {
110
 
            params.setOverriddenValues(buildConfig);
111
 
            params.setBuildConfiguration(buildConfig);
 
133
            QVariantMap baseConfig;
 
134
            QVariantMap userConfig = buildConfig;
 
135
            QString buildVariantKey = QLatin1String("qbs.buildVariant");
 
136
            baseConfig.insert(buildVariantKey, userConfig.take(buildVariantKey));
 
137
            const QVariantMap::Iterator it = userConfig.find(QLatin1String("qbs.profile"));
 
138
            if (it != userConfig.end()) {
 
139
                baseConfig.insert(it.key(), it.value());
 
140
                userConfig.erase(it);
 
141
            }
 
142
            params.setBuildConfiguration(baseConfig);
 
143
            params.setOverriddenValues(userConfig);
112
144
            const ErrorInfo err = params.expandBuildConfiguration(m_settings);
113
145
            if (err.hasError())
114
146
                throw err;
129
161
         */
130
162
        if (m_parser.showProgress() && resolvingMultipleProjects())
131
163
            m_observer->initialize(tr("Setting up projects"), m_resolveJobs.count());
 
164
 
 
165
        // Check every two seconds whether we received a cancel request. This value has been
 
166
        // experimentally found to be acceptable.
 
167
        // Note that this polling approach is not problematic here, since we are doing work anyway,
 
168
        // so there's no danger of waking up the processor for no reason.
 
169
        connect(m_cancelTimer, SIGNAL(timeout()), SLOT(checkCancelStatus()));
 
170
        m_cancelTimer->start(2000);
132
171
    } catch (const ErrorInfo &error) {
133
172
        qbsError() << error.toString();
134
 
        if (m_buildJobs.isEmpty() && m_resolveJobs.isEmpty())
 
173
        if (m_buildJobs.isEmpty() && m_resolveJobs.isEmpty()) {
135
174
            qApp->exit(EXIT_FAILURE);
136
 
        else
 
175
        } else {
137
176
            cancel();
 
177
            checkCancelStatus();
 
178
        }
138
179
    }
139
180
}
140
181
 
283
324
void CommandLineFrontend::handleProjectsResolved()
284
325
{
285
326
    try {
286
 
        if (m_canceled)
 
327
        if (m_cancelStatus != CancelStatusNone)
287
328
            throw ErrorInfo(Tr::tr("Execution canceled."));
288
329
        switch (m_parser.command()) {
289
330
        case ResolveCommandType: