kubernetes
/
minikube
mirror of https://github.com/kubernetes/minikube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
minikube/gui/window.cpp

829 lines
27 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright 2022 The Kubernetes Authors All rights reserved.
**
** Copyright (C) 2021 Anders F Björklund
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of The Qt Company Ltd nor the names of its
** contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "window.h"
#ifndef QT_NO_SYSTEMTRAYICON
#include <QAction>
#include <QCheckBox>
#include <QComboBox>
#include <QCoreApplication>
#include <QCloseEvent>
#include <QGroupBox>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QPushButton>
#include <QSpinBox>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QMessageBox>
#include <QProcess>
#include <QDebug>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QTableView>
#include <QHeaderView>
#include <QFormLayout>
#include <QDialogButtonBox>
#include <QStandardPaths>
#include <QDir>
#include <QFontDialog>
#include <QStackedWidget>
#include <QProcessEnvironment>
#ifndef QT_NO_TERMWIDGET
#include <QApplication>
#include <QMainWindow>
#include "qtermwidget.h"
#endif
Window::Window()
{
trayIconIcon = new QIcon(":/images/minikube.png");
checkForMinikube();
isBasicView = true;
stackedWidget = new QStackedWidget;
QVBoxLayout *layout = new QVBoxLayout;
dashboardProcess = 0;
createClusterGroupBox();
createActions();
createTrayIcon();
createBasicView();
createAdvancedView();
trayIcon->show();
updateButtons();
layout->addWidget(stackedWidget);
setLayout(layout);
resize(200, 250);
setWindowTitle(tr("minikube"));
setWindowIcon(*trayIconIcon);
}
QProcessEnvironment Window::setMacEnv()
{
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString path = env.value("PATH");
env.insert("PATH", path + ":/usr/local/bin");
return env;
}
void Window::createBasicView()
{
basicStartButton = new QPushButton(tr("Start"));
basicStopButton = new QPushButton(tr("Stop"));
basicDeleteButton = new QPushButton(tr("Delete"));
basicRefreshButton = new QPushButton(tr("Refresh"));
basicSSHButton = new QPushButton(tr("SSH"));
basicDashboardButton = new QPushButton(tr("Dashboard"));
QPushButton *advancedViewButton = new QPushButton(tr("Advanced View"));
QVBoxLayout *buttonLayout = new QVBoxLayout;
QGroupBox *catBox = new QGroupBox();
catBox->setLayout(buttonLayout);
buttonLayout->addWidget(basicStartButton);
buttonLayout->addWidget(basicStopButton);
buttonLayout->addWidget(basicDeleteButton);
buttonLayout->addWidget(basicRefreshButton);
buttonLayout->addWidget(basicSSHButton);
buttonLayout->addWidget(basicDashboardButton);
buttonLayout->addWidget(advancedViewButton);
catBox->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
stackedWidget->addWidget(catBox);
connect(basicSSHButton, &QAbstractButton::clicked, this, &Window::sshConsole);
connect(basicDashboardButton, &QAbstractButton::clicked, this, &Window::dashboardBrowser);
connect(basicStartButton, &QAbstractButton::clicked, this, &Window::startSelectedMinikube);
connect(basicStopButton, &QAbstractButton::clicked, this, &Window::stopMinikube);
connect(basicDeleteButton, &QAbstractButton::clicked, this, &Window::deleteMinikube);
connect(basicRefreshButton, &QAbstractButton::clicked, this, &Window::updateClusters);
connect(advancedViewButton, &QAbstractButton::clicked, this, &Window::toAdvancedView);
}
void Window::toAdvancedView()
{
isBasicView = false;
stackedWidget->setCurrentIndex(1);
resize(600, 400);
}
void Window::toBasicView()
{
isBasicView = true;
stackedWidget->setCurrentIndex(0);
resize(200, 250);
}
void Window::createAdvancedView()
{
connect(sshButton, &QAbstractButton::clicked, this, &Window::sshConsole);
connect(dashboardButton, &QAbstractButton::clicked, this, &Window::dashboardBrowser);
connect(startButton, &QAbstractButton::clicked, this, &Window::startSelectedMinikube);
connect(stopButton, &QAbstractButton::clicked, this, &Window::stopMinikube);
connect(deleteButton, &QAbstractButton::clicked, this, &Window::deleteMinikube);
connect(refreshButton, &QAbstractButton::clicked, this, &Window::updateClusters);
connect(createButton, &QAbstractButton::clicked, this, &Window::initMachine);
connect(trayIcon, &QSystemTrayIcon::messageClicked, this, &Window::messageClicked);
clusterGroupBox->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
stackedWidget->addWidget(clusterGroupBox);
}
void Window::setVisible(bool visible)
{
minimizeAction->setEnabled(visible);
restoreAction->setEnabled(!visible);
QDialog::setVisible(visible);
}
void Window::closeEvent(QCloseEvent *event)
{
#ifdef Q_OS_OSX
if (!event->spontaneous() || !isVisible()) {
return;
}
#endif
if (trayIcon->isVisible()) {
QMessageBox::information(this, tr("Systray"),
tr("The program will keep running in the "
"system tray. To terminate the program, "
"choose <b>Quit</b> in the context menu "
"of the system tray entry."));
hide();
event->ignore();
}
}
void Window::messageClicked()
{
QMessageBox::information(0, tr("Systray"),
tr("Sorry, I already gave what help I could.\n"
"Maybe you should try asking a human?"));
}
void Window::createActions()
{
minimizeAction = new QAction(tr("Mi&nimize"), this);
connect(minimizeAction, &QAction::triggered, this, &QWidget::hide);
restoreAction = new QAction(tr("&Restore"), this);
connect(restoreAction, &QAction::triggered, this, &Window::restoreWindow);
quitAction = new QAction(tr("&Quit"), this);
connect(quitAction, &QAction::triggered, qApp, &QCoreApplication::quit);
}
void Window::restoreWindow()
{
QWidget::showNormal();
updateClusters();
}
static QString minikubePath()
{
QString program = QStandardPaths::findExecutable("minikube");
if (program.isEmpty()) {
QStringList paths = { "/usr/local/bin" };
program = QStandardPaths::findExecutable("minikube", paths);
}
return program;
}
void Window::createTrayIcon()
{
trayIconMenu = new QMenu(this);
trayIconMenu->addAction(minimizeAction);
trayIconMenu->addAction(restoreAction);
trayIconMenu->addSeparator();
trayIconMenu->addAction(quitAction);
trayIcon = new QSystemTrayIcon(this);
trayIcon->setContextMenu(trayIconMenu);
trayIcon->setIcon(*trayIconIcon);
}
void Window::startMinikube(QStringList moreArgs)
{
QString text;
QStringList args = { "start", "-o", "json" };
args << moreArgs;
bool success = sendMinikubeCommand(args, text);
updateClusters();
if (success) {
return;
}
outputFailedStart(text);
}
void Window::startSelectedMinikube()
{
QStringList args = { "-p", selectedCluster() };
return startMinikube(args);
}
void Window::stopMinikube()
{
QStringList args = { "stop", "-p", selectedCluster() };
sendMinikubeCommand(args);
updateClusters();
}
void Window::deleteMinikube()
{
QStringList args = { "delete", "-p", selectedCluster() };
sendMinikubeCommand(args);
updateClusters();
}
void Window::updateClusters()
{
QString cluster = selectedCluster();
clusterModel->setClusters(getClusters());
setSelectedCluster(cluster);
updateButtons();
}
ClusterList Window::getClusters()
{
ClusterList clusters;
QStringList args = { "profile", "list", "-o", "json" };
QString text;
sendMinikubeCommand(args, text);
QStringList lines;
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
lines = text.split("\n", Qt::SkipEmptyParts);
#else
lines = text.split("\n", QString::SkipEmptyParts);
#endif
for (int i = 0; i < lines.size(); i++) {
QString line = lines.at(i);
QJsonParseError error;
QJsonDocument json = QJsonDocument::fromJson(line.toUtf8(), &error);
if (json.isNull()) {
qDebug() << error.errorString();
continue;
}
if (!json.isObject()) {
continue;
}
QJsonObject par = json.object();
QJsonArray a = par["valid"].toArray();
QJsonArray b = par["invalid"].toArray();
for (int i = 0; i < b.size(); i++) {
a.append(b[i]);
}
for (int i = 0; i < a.size(); i++) {
QJsonObject obj = a[i].toObject();
Cluster cluster = createClusterObject(obj);
clusters << cluster;
}
}
return clusters;
}
Cluster Window::createClusterObject(QJsonObject obj)
{
QString name;
if (obj.contains("Name")) {
name = obj["Name"].toString();
}
Cluster cluster(name);
if (obj.contains("Status")) {
QString status = obj["Status"].toString();
cluster.setStatus(status);
}
if (!obj.contains("Config")) {
return cluster;
}
QJsonObject config = obj["Config"].toObject();
if (config.contains("CPUs")) {
int cpus = config["CPUs"].toInt();
cluster.setCpus(cpus);
}
if (config.contains("Memory")) {
int memory = config["Memory"].toInt();
cluster.setMemory(memory);
}
if (config.contains("Driver")) {
QString driver = config["Driver"].toString();
cluster.setDriver(driver);
}
if (!config.contains("KubernetesConfig")) {
return cluster;
}
QJsonObject k8sConfig = config["KubernetesConfig"].toObject();
if (k8sConfig.contains("ContainerRuntime")) {
QString containerRuntime = k8sConfig["ContainerRuntime"].toString();
cluster.setContainerRuntime(containerRuntime);
}
return cluster;
}
QString Window::selectedCluster()
{
if (isBasicView) {
return "minikube";
}
QModelIndex index = clusterListView->currentIndex();
QVariant variant = index.data(Qt::DisplayRole);
if (variant.isNull()) {
return QString();
}
return variant.toString();
}
void Window::setSelectedCluster(QString cluster)
{
QAbstractItemModel *model = clusterListView->model();
QModelIndex start = model->index(0, 0);
QModelIndexList index = model->match(start, Qt::DisplayRole, cluster);
if (index.size() == 0) {
return;
}
clusterListView->setCurrentIndex(index[0]);
}
void Window::createClusterGroupBox()
{
clusterGroupBox = new QGroupBox(tr("Clusters"));
ClusterList clusters = getClusters();
clusterModel = new ClusterModel(clusters);
clusterListView = new QTableView();
clusterListView->setModel(clusterModel);
clusterListView->setSelectionMode(QAbstractItemView::SingleSelection);
clusterListView->setSelectionBehavior(QAbstractItemView::SelectRows);
clusterListView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
clusterListView->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
clusterListView->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
clusterListView->horizontalHeader()->setSectionResizeMode(3, QHeaderView::ResizeToContents);
clusterListView->horizontalHeader()->setSectionResizeMode(4, QHeaderView::ResizeToContents);
clusterListView->horizontalHeader()->setSectionResizeMode(5, QHeaderView::ResizeToContents);
setSelectedCluster("default");
connect(clusterListView, SIGNAL(clicked(QModelIndex)), this, SLOT(updateButtons()));
startButton = new QPushButton(tr("Start"));
stopButton = new QPushButton(tr("Stop"));
deleteButton = new QPushButton(tr("Delete"));
refreshButton = new QPushButton(tr("Refresh"));
createButton = new QPushButton(tr("Create"));
sshButton = new QPushButton(tr("SSH"));
dashboardButton = new QPushButton(tr("Dashboard"));
QPushButton *basicViewButton = new QPushButton(tr("Basic View"));
connect(basicViewButton, &QAbstractButton::clicked, this, &Window::toBasicView);
QHBoxLayout *topButtonLayout = new QHBoxLayout;
topButtonLayout->addWidget(createButton);
topButtonLayout->addWidget(refreshButton);
topButtonLayout->addWidget(basicViewButton);
topButtonLayout->addSpacing(340);
QHBoxLayout *bottomButtonLayout = new QHBoxLayout;
bottomButtonLayout->addWidget(startButton);
bottomButtonLayout->addWidget(stopButton);
bottomButtonLayout->addWidget(deleteButton);
bottomButtonLayout->addWidget(sshButton);
bottomButtonLayout->addWidget(dashboardButton);
QVBoxLayout *clusterLayout = new QVBoxLayout;
clusterLayout->addLayout(topButtonLayout);
clusterLayout->addWidget(clusterListView);
clusterLayout->addLayout(bottomButtonLayout);
clusterGroupBox->setLayout(clusterLayout);
}
void Window::updateButtons()
{
if (isBasicView) {
updateBasicButtons();
} else {
updateAdvancedButtons();
}
}
void Window::updateBasicButtons()
{
Cluster *cluster = new Cluster();
ClusterList list = getClusters();
for (int i = 0; i < list.length(); i++) {
Cluster curr = list[i];
if (curr.name() != "minikube") {
continue;
}
cluster = &curr;
break;
}
bool exists = cluster->name() == "minikube";
bool isRunning = exists && cluster->status() == "Running";
basicStartButton->setEnabled(isRunning == false);
basicStopButton->setEnabled(isRunning == true);
basicDeleteButton->setEnabled(exists == true);
basicDashboardButton->setEnabled(isRunning == true);
#if __linux__
basicSSHButton->setEnabled(isRunning == true);
#else
basicSSHButton->setEnabled(false);
#endif
}
void Window::updateAdvancedButtons()
{
QString cluster = selectedCluster();
if (cluster.isEmpty()) {
startButton->setEnabled(false);
stopButton->setEnabled(false);
deleteButton->setEnabled(false);
sshButton->setEnabled(false);
dashboardButton->setEnabled(false);
return;
}
deleteButton->setEnabled(true);
Cluster clusterHash = getClusterHash()[cluster];
if (clusterHash.status() == "Running") {
startButton->setEnabled(false);
stopButton->setEnabled(true);
#if __linux__
sshButton->setEnabled(true);
#endif
dashboardButton->setEnabled(true);
} else {
startButton->setEnabled(true);
stopButton->setEnabled(false);
}
}
ClusterHash Window::getClusterHash()
{
ClusterList clusters = getClusters();
ClusterHash clusterHash;
for (int i = 0; i < clusters.size(); i++) {
Cluster cluster = clusters.at(i);
clusterHash[cluster.name()] = cluster;
}
return clusterHash;
}
bool Window::sendMinikubeCommand(QStringList cmds)
{
QString text;
return sendMinikubeCommand(cmds, text);
}
bool Window::sendMinikubeCommand(QStringList cmds, QString &text)
{
QString program = minikubePath();
if (program.isEmpty()) {
return false;
}
QStringList arguments = { "--user", "minikube-gui" };
arguments << cmds;
QProcess *process = new QProcess(this);
#if __APPLE__
if (env.isEmpty()) {
env = setMacEnv();
}
process->setProcessEnvironment(env);
#endif
process->start(program, arguments);
this->setCursor(Qt::WaitCursor);
bool timedOut = process->waitForFinished(300 * 1000);
int exitCode = process->exitCode();
bool success = !timedOut && exitCode == 0;
this->unsetCursor();
text = process->readAllStandardOutput();
if (success) {
} else {
qDebug() << text;
qDebug() << process->readAllStandardError();
}
delete process;
return success;
}
static QString profile = "minikube";
static int cpus = 2;
static int memory = 2400;
static QString driver = "";
static QString containerRuntime = "";
static QString k8sVersion = "";
void Window::askName()
{
QDialog dialog;
dialog.setWindowTitle(tr("Create minikube Cluster"));
dialog.setWindowIcon(*trayIconIcon);
dialog.setModal(true);
QFormLayout form(&dialog);
QDialogButtonBox buttonBox(Qt::Horizontal, &dialog);
QLineEdit profileField(profile, &dialog);
form.addRow(new QLabel(tr("Profile")), &profileField);
buttonBox.addButton(QString(tr("Use Default Values")), QDialogButtonBox::AcceptRole);
connect(&buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
buttonBox.addButton(QString(tr("Set Custom Values")), QDialogButtonBox::RejectRole);
connect(&buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
form.addRow(&buttonBox);
int code = dialog.exec();
profile = profileField.text();
if (code == QDialog::Accepted) {
QStringList args = { "-p", profile };
startMinikube(args);
} else if (code == QDialog::Rejected) {
askCustom();
}
}
void Window::askCustom()
{
QDialog dialog;
dialog.setWindowTitle(tr("Set Cluster Values"));
dialog.setWindowIcon(*trayIconIcon);
dialog.setModal(true);
QFormLayout form(&dialog);
driverComboBox = new QComboBox;
driverComboBox->addItems({ "docker", "virtualbox", "vmware", "podman" });
#if __linux__
driverComboBox->addItem("kvm2");
#elif __APPLE__
driverComboBox->addItems({ "hyperkit", "parallels" });
#else
driverComboBox->addItem("hyperv");
#endif
form.addRow(new QLabel(tr("Driver")), driverComboBox);
containerRuntimeComboBox = new QComboBox;
containerRuntimeComboBox->addItems({ "docker", "containerd", "crio" });
form.addRow(new QLabel(tr("Container Runtime")), containerRuntimeComboBox);
k8sVersionComboBox = new QComboBox;
k8sVersionComboBox->addItems({ "stable", "latest", "none" });
form.addRow(new QLabel(tr("Kubernetes Version")), k8sVersionComboBox);
QLineEdit cpuField(QString::number(cpus), &dialog);
form.addRow(new QLabel(tr("CPUs")), &cpuField);
QLineEdit memoryField(QString::number(memory), &dialog);
form.addRow(new QLabel(tr("Memory")), &memoryField);
QDialogButtonBox buttonBox(Qt::Horizontal, &dialog);
buttonBox.addButton(QString(tr("Create")), QDialogButtonBox::AcceptRole);
connect(&buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
buttonBox.addButton(QString(tr("Cancel")), QDialogButtonBox::RejectRole);
connect(&buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
form.addRow(&buttonBox);
int code = dialog.exec();
if (code == QDialog::Accepted) {
driver = driverComboBox->itemText(driverComboBox->currentIndex());
containerRuntime =
containerRuntimeComboBox->itemText(containerRuntimeComboBox->currentIndex());
k8sVersion = k8sVersionComboBox->itemText(k8sVersionComboBox->currentIndex());
if (k8sVersion == "none") {
k8sVersion = "v0.0.0";
}
cpus = cpuField.text().toInt();
memory = memoryField.text().toInt();
QStringList args = { "-p",
profile,
"--driver",
driver,
"--container-runtime",
containerRuntime,
"--kubernetes-version",
k8sVersion,
"--cpus",
QString::number(cpus),
"--memory",
QString::number(memory) };
startMinikube(args);
}
}
void Window::outputFailedStart(QString text)
{
QStringList lines;
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
lines = text.split("\n", Qt::SkipEmptyParts);
#else
lines = text.split("\n", QString::SkipEmptyParts);
#endif
for (int i = 0; i < lines.size(); i++) {
QString line = lines.at(i);
QJsonParseError error;
QJsonDocument json = QJsonDocument::fromJson(line.toUtf8(), &error);
if (json.isNull() || !json.isObject()) {
continue;
}
QJsonObject par = json.object();
QJsonObject data = par["data"].toObject();
if (!data.contains("exitcode")) {
continue;
}
QString advice = data["advice"].toString();
QString message = data["message"].toString();
QString name = data["name"].toString();
QString url = data["url"].toString();
QString issues = data["issues"].toString();
QDialog dialog;
dialog.setWindowTitle(tr("minikube start failed"));
dialog.setWindowIcon(*trayIconIcon);
dialog.setFixedWidth(600);
dialog.setModal(true);
QFormLayout form(&dialog);
createLabel("Error Code", name, &form, false);
createLabel("Advice", advice, &form, false);
QLabel *errorMessage = createLabel("Error Message", message, &form, false);
errorMessage->setFont(QFont("Courier", 10));
errorMessage->setStyleSheet("background-color:white;");
createLabel("Link to documentation", url, &form, true);
createLabel("Link to related issue", issues, &form, true);
// Enabling once https://github.com/kubernetes/minikube/issues/13925 is fixed
// QLabel *fileLabel = new QLabel(this);
// fileLabel->setOpenExternalLinks(true);
// fileLabel->setWordWrap(true);
// QString logFile = QDir::homePath() + "/.minikube/logs/lastStart.txt";
// fileLabel->setText("<a href='file:///" + logFile + "'>View log file</a>");
// form.addRow(fileLabel);
QDialogButtonBox buttonBox(Qt::Horizontal, &dialog);
buttonBox.addButton(QString(tr("OK")), QDialogButtonBox::AcceptRole);
connect(&buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
form.addRow(&buttonBox);
dialog.exec();
}
}
QLabel *Window::createLabel(QString title, QString text, QFormLayout *form, bool isLink)
{
QLabel *label = new QLabel(this);
if (!text.isEmpty()) {
form->addRow(label);
}
if (isLink) {
label->setOpenExternalLinks(true);
text = "<a href='" + text + "'>" + text + "</a>";
}
label->setWordWrap(true);
label->setText(title + ": " + text);
return label;
}
void Window::initMachine()
{
askName();
updateClusters();
}
void Window::sshConsole()
{
QString program = minikubePath();
#ifndef QT_NO_TERMWIDGET
QMainWindow *mainWindow = new QMainWindow();
int startnow = 0; // set shell program first
QTermWidget *console = new QTermWidget(startnow);
QFont font = QApplication::font();
font.setFamily("Monospace");
font.setPointSize(10);
console->setTerminalFont(font);
console->setColorScheme("Tango");
console->setShellProgram(program);
QStringList args = { "ssh", "-p", selectedCluster() };
console->setArgs(args);
console->startShellProgram();
QObject::connect(console, SIGNAL(finished()), mainWindow, SLOT(close()));
mainWindow->setWindowTitle(nameLabel->text());
mainWindow->resize(800, 400);
mainWindow->setCentralWidget(console);
mainWindow->show();
#else
QString terminal = qEnvironmentVariable("TERMINAL");
if (terminal.isEmpty()) {
terminal = "x-terminal-emulator";
if (QStandardPaths::findExecutable(terminal).isEmpty()) {
terminal = "xterm";
}
}
QStringList arguments = { "-e", QString("%1 ssh -p %2").arg(program, selectedCluster()) };
QProcess *process = new QProcess(this);
process->start(QStandardPaths::findExecutable(terminal), arguments);
#endif
}
void Window::dashboardBrowser()
{
dashboardClose();
QString program = minikubePath();
QProcess *process = new QProcess(this);
QStringList arguments = { "dashboard", "-p", selectedCluster() };
process->start(program, arguments);
dashboardProcess = process;
dashboardProcess->waitForStarted();
}
void Window::dashboardClose()
{
if (dashboardProcess) {
dashboardProcess->terminate();
dashboardProcess->waitForFinished();
}
}
void Window::checkForMinikube()
{
QString program = minikubePath();
if (!program.isEmpty()) {
return;
}
QDialog dialog;
dialog.setWindowTitle(tr("minikube"));
dialog.setWindowIcon(*trayIconIcon);
dialog.setModal(true);
QFormLayout form(&dialog);
QLabel *message = new QLabel(this);
message->setText("minikube was not found on the path.\nPlease follow the install instructions "
"below to install minikube first.\n");
form.addWidget(message);
QLabel *link = new QLabel(this);
link->setOpenExternalLinks(true);
link->setText("<a "
"href='https://minikube.sigs.k8s.io/docs/start/'>https://minikube.sigs.k8s.io/"
"docs/start/</a>");
form.addWidget(link);
QDialogButtonBox buttonBox(Qt::Horizontal, &dialog);
buttonBox.addButton(QString(tr("OK")), QDialogButtonBox::AcceptRole);
connect(&buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
form.addRow(&buttonBox);
dialog.exec();
exit(EXIT_FAILURE);
}
#endif
Reference in New Issue View Git Blame Copy Permalink