Differential D5584 Diff 14675 plugins/docker/dockerruntime.cpp

Changeset View

Standalone View

View Options

plugins/docker/dockerruntime.cpp

  • This file was added.
1​/*
2​ Copyright 2017 Aleix Pol Gonzalez <aleixpol@kde.org>
3​
4​ This library is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU Library General Public
6​ License version 2 as published by the Free Software Foundation.
7​
8​ This library is distributed in the hope that it will be useful,
9​ but WITHOUT ANY WARRANTY; without even the implied warranty of
10​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11​ Library General Public License for more details.
12​
13​ You should have received a copy of the GNU Library General Public License
14​ along with this library; see the file COPYING.LIB. If not, write to
15​ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16​ Boston, MA 02110-1301, USA.
17​*/
18​
19​#include "dockerruntime.h"
20​#include "dockerpreferencessettings.h"
21​#include "debug_docker.h"
22​
23​#include <interfaces/icore.h>
24​#include <interfaces/iprojectcontroller.h>
25​#include <interfaces/iproject.h>
26​#include <project/projectmodel.h>
27​#include <project/interfaces/ibuildsystemmanager.h>
28​
29​#include <KLocalizedString>
30​#include <KProcess>
31​#include <KActionCollection>
32​#include <KShell>
33​#include <KUser>
34​#include <QProcess>
35​#include <QDir>
36​#include <QDebug>
37​#include <outputview/outputexecutejob.h>
38​
39​using namespace KDevelop;
40​
41​DockerPreferencesSettings* DockerRuntime::s_settings = nullptr;
42​
43​DockerRuntime::DockerRuntime(const QString &tag)
44​ : KDevelop::IRuntime()
45​ , m_tag(tag)
46​{
47​ setObjectName(tag);
48​ inspectImage();
49​}
50​
51​void DockerRuntime::inspectImage()
52​{
53​ QProcess* process = new QProcess(this);
54​ connect(process, static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished), this, [process, this](int code, QProcess::ExitStatus status){
mwolffUnsubmitted
Done

categorized logging, and output a warning when something goes wrong?

mwolff: categorized logging, and output a warning when something goes wrong?
55​ process->deleteLater();
56​ qCDebug(DOCKER) << "inspect upper dir" << code << status;
57​ if (code || status) {
58​ qCWarning(DOCKER) << "Could not figure out the upperDir of" << m_tag;
59​ return;
60​ }
61​ m_upperDir = Path(QFile::decodeName(process->readAll().trimmed()));
62​ qCDebug(DOCKER) << "upper dir:" << m_tag << m_upperDir;
63​ });
64​ process->start("docker", {"image", "inspect", m_tag, "--format", "{{.GraphDriver.Data.UpperDir}}"});
65​
66​ QProcess* processEnvs = new QProcess(this);
67​ connect(processEnvs, static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished), this, [processEnvs, this](int code, QProcess::ExitStatus status){
68​ processEnvs->deleteLater();
69​ qCDebug(DOCKER) << "inspect envs" << code << status;
70​ if (code || status) {
mwolffUnsubmitted
Done

can you add some comments that outline what this is doing?

mwolff: can you add some comments that outline what this is doing?
71​ qCWarning(DOCKER) << "Could not figure out the environment variables of" << m_tag;
72​ return;
73​ }
mwolffUnsubmitted
Done

qgetenv(USER)? Don't we have KDE api for this? I doubt this would work on windows, but then again - most of the commands here don't work on windows. make sure this whole plugin isn't compiled on windows?

mwolff: qgetenv(USER)? Don't we have KDE api for this? I doubt this would work on windows, but then…
apolAuthorUnsubmitted
Done

I looked into KUser, I don't see how to create a user for the current user. Something to look into.

apol: I looked into KUser, I don't see how to create a user for the current user. Something to look…
apolAuthorUnsubmitted
Not Done

Fixed ^^'

apol: Fixed ^^'
74​
75​ const auto list = processEnvs->readAll();
76​ const auto data = list.mid(1, list.size()-3);
77​ const auto entries = data.split(' ');
mwolffUnsubmitted
Done

braces please

mwolff: braces please
78​
79​ for (auto entry : entries) {
80​ const auto content = entry.split('=');
81​ if (content.count() != 2)
82​ continue;
83​ m_envs.insert(content[0], content[1]);
84​ }
85​
86​ qCDebug(DOCKER) << "envs:" << m_tag << m_envs;
87​ });
88​ processEnvs->start("docker", {"image", "inspect", m_tag, "--format", "{{.Config.Env}}"});
89​}
90​
91​DockerRuntime::~DockerRuntime()
92​{
93​}
94​
95​QByteArray DockerRuntime::getenv(const QByteArray& varname) const
96​{
mwolffUnsubmitted
Done

space

mwolff: space
97​ return m_envs.value(varname);
98​}
99​
100​void DockerRuntime::setEnabled(bool enable)
101​{
102​ if (enable) {
103​ m_userUpperDir = KDevelop::Path(QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/docker-" + QString(m_tag).replace('/', '_'));
mwolffUnsubmitted
Done

braces

mwolff: braces
104​ QDir().mkpath(m_userUpperDir.toLocalFile());
mwolffUnsubmitted
Done

concat manually instead of using %1:%2?

mwolff: concat manually instead of using %1:%2?
105​
106​ const QStringList cmd = {"pkexec", "bindfs", "--map=root/"+KUser().loginName(), m_upperDir.toLocalFile(), m_userUpperDir.toLocalFile() };
107​ QProcess p;
108​ p.start(cmd.first(), cmd.mid(1));
109​ p.waitForFinished();
110​ if (p.exitCode()) {
111​ qCDebug(DOCKER) << "bindfs returned" << m_upperDir << m_userUpperDir << cmd << p.exitCode() << p.readAll();
112​ }
113​ } else {
114​ int code = QProcess::execute(QStringLiteral("pkexec"), {"umount", m_userUpperDir.toLocalFile()});
115​ qCDebug(DOCKER) << "umount returned" << code;
116​ }
117​}
118​
119​static QString ensureEndsSlash(const QString &string)
120​{
121​ return string.endsWith('/') ? string : (string + QLatin1Char('/'));
122​}
123​
124​static QStringList projectVolumes()
125​{
126​ QStringList ret;
127​ const QString dir = ensureEndsSlash(DockerRuntime::s_settings->projectsVolume());
128​ const QString buildDir = ensureEndsSlash(DockerRuntime::s_settings->buildDirsVolume());
129​
130​ for (IProject* project: ICore::self()->projectController()->projects()) {
131​ const Path path = project->path();
132​ if (path.isLocalFile()) {
133​ ret << "--volume" << QStringLiteral("%1:%2").arg(path.toLocalFile(), dir + path.lastPathSegment());
134​ }
135​
136​ const auto ibsm = project->buildSystemManager();
137​ if (ibsm) {
138​ ret << "--volume" << ibsm->buildDirectory(project->projectItem()).toLocalFile() + QLatin1Char(':') + buildDir + path.lastPathSegment();
139​ }
140​ }
141​ return ret;
142​}
143​
144​QStringList DockerRuntime::workingDirArgs(QProcess* process) const
145​{
146​ const auto wd = process->workingDirectory();
147​ return wd.isEmpty() ? QStringList{} : QStringList{"-w", pathInRuntime(KDevelop::Path(wd)).toLocalFile()};
148​}
149​
150​void DockerRuntime::startProcess(QProcess* process) const
151​{
152​ const QStringList args = QStringList{"run", "--rm"} << workingDirArgs(process) << KShell::splitArgs(s_settings->extraArguments()) << projectVolumes() << m_tag << process->program() << process->arguments();
153​ process->setProgram("docker");
154​ process->setArguments(args);
155​
156​ qCDebug(DOCKER) << "starting qprocess" << process->program() << process->arguments();
157​ process->start();
158​}
159​
160​void DockerRuntime::startProcess(KProcess* process) const
161​{
162​ process->setProgram(QStringList{ "docker", "run", "--rm" } << workingDirArgs(process) << KShell::splitArgs(s_settings->extraArguments()) << projectVolumes() << m_tag << process->program());
163​
164​ qCDebug(DOCKER) << "starting kprocess" << process->program().join(' ');
165​ process->start();
166​}
167​
168​static Path projectRelPath(const KDevelop::Path & projectsDir, const KDevelop::Path& runtimePath, bool sourceDir)
169​{
170​ const auto relPath = projectsDir.relativePath(runtimePath);
171​ const int index = relPath.indexOf(QLatin1Char('/'));
172​ auto project = ICore::self()->projectController()->findProjectByName(relPath.left(index));
173​
174​ if (!project) {
175​ qCWarning(DOCKER) << "No project for" << relPath;
176​ } else {
177​ const auto repPathProject = index < 0 ? QString() : relPath.mid(index+1);
178​ const auto rootPath = sourceDir ? project->path() : project->buildSystemManager()->buildDirectory(project->projectItem());
179​ return Path(rootPath, repPathProject);
180​ }
181​ return {};
182​}
183​
184​KDevelop::Path DockerRuntime::pathInHost(const KDevelop::Path& runtimePath) const
185​{
186​ Path ret;
187​ const Path projectsDir(DockerRuntime::s_settings->projectsVolume());
188​ if (runtimePath==projectsDir || projectsDir.isParentOf(runtimePath)) {
189​ ret = projectRelPath(projectsDir, runtimePath, true);
190​ } else {
191​ const Path buildDirs(DockerRuntime::s_settings->buildDirsVolume());
192​ if (runtimePath==buildDirs || buildDirs.isParentOf(runtimePath)) {
193​ ret = projectRelPath(buildDirs, runtimePath, false);
194​ } else
195​ ret = KDevelop::Path(m_userUpperDir, KDevelop::Path(QStringLiteral("/")).relativePath(runtimePath));
196​ }
197​ qCDebug(DOCKER) << "pathInHost" << ret << runtimePath;
198​ return ret;
199​}
200​
201​KDevelop::Path DockerRuntime::pathInRuntime(const KDevelop::Path& localPath) const
202​{
203​ if (m_userUpperDir==localPath || m_userUpperDir.isParentOf(localPath)) {
204​ KDevelop::Path ret(KDevelop::Path("/"), m_userUpperDir.relativePath(localPath));
205​ qCDebug(DOCKER) << "docker runtime pathInRuntime..." << ret << localPath;
206​ return ret;
207​ } else if (auto project = ICore::self()->projectController()->findProjectForUrl(localPath.toUrl())) {
208​ const Path projectsDir(DockerRuntime::s_settings->projectsVolume());
209​ const QString relpath = project->path().relativePath(localPath);
210​ const KDevelop::Path ret(projectsDir, project->name() + QLatin1Char('/') + relpath);
211​ qCDebug(DOCKER) << "docker user pathInRuntime..." << ret << localPath;
212​ return ret;
213​ } else {
214​ const auto projects = ICore::self()->projectController()->projects();
215​ for (auto project : projects) {
216​ auto ibsm = project->buildSystemManager();
217​ if (ibsm) {
218​ const auto builddir = ibsm->buildDirectory(project->projectItem());
219​ if (builddir != localPath && !builddir.isParentOf(localPath))
220​ continue;
221​
222​ const Path builddirs(DockerRuntime::s_settings->buildDirsVolume());
223​ const QString relpath = builddir.relativePath(localPath);
224​ const KDevelop::Path ret(builddirs, project->name() + QLatin1Char('/') + relpath);
225​ qCDebug(DOCKER) << "docker build pathInRuntime..." << ret << localPath;
226​ return ret;
227​ }
228​ }
229​ qCWarning(DOCKER) << "only project files are available on the docker runtime" << localPath;
230​ }
231​ qCDebug(DOCKER) << "bypass..." << localPath;
232​ return localPath;
233​}
234​