Docker/portainer
Docker/portainer
1
0
Fork 0
mirror of https://github.com/portainer/portainer.git synced 2025-08-02 20:35:25 +02:00
Code Issues Releases Activity

feat(edge-compute): move host jobs to edge (#3840)

Browse source 
* feat(endpoints): create an associated endpoints selector

* feat(schedules): remove edge specific explanations

* refactor(schedule): replace multi-endpoint-selector

* refactor(schedule): move controller to single file

* refactor(endpoints): remove multi-endpoint-selector

* feat(edge): rename host jobs to edge jobs

* feat(edge-jobs): remove edge warning

* refactor(edge-jobs): move schedule pages to edge

* refactor(edge-jobs): mv views to edgeJobs

* refactor(edge-jobs): rename edge jobs

* refactor(edge-jobs): move services to edge

* refactor(edge-jobs): move tasks datatable

* fix(edge-jobs): fix import

* fix(edge-jobs): use right services

* feat(settings): adjust host management description

* feat(edge-jobs): introduce interfaces and types

* feat(edge-jobs): implement bolt service

* refactor(edge-jobs): replace schedule routes

* refactor(edge-job): replace Schedule service

* refactor(edge-jobs): remove job_script_exec

* refactor(host): remove jobs table

* feat(edge-jobs): replace schedule

* feat(edge-jobs): load file on inspect

* fix(edge-job): parse cron correctly

* feat(edge-jobs): show tasks

* feat(host): rename tooltip

* refactor(host): remove old components

* refactor(main): remove schedule types

* refactor(snapshot): replace job service with snapshot service

* refactor(jobs): remove jobs form and datatable

* feat(edge-jobs): create db migration

* fix(main): start snapshot service with correct interval

* feat(settings): change host tooltip

* feat(edge-jobs): load endpoints

* fix(edge-job): disable form submit when form is invalid

* refactor(edge-compute): use const

* refactor(edge-jobs): use generic controller

* refactor(edge-jobs): replace $scope with controllerAs

* refactor(edge-jobs): replace routes with components

* refactor(edge-jobs): replace functions with classes

* refactor(edge-jobs): use async/await

* refactor(edge-jobs): rename functions

* feat(edge-jobs): introduce beta panel

* feat(edge-jobs): allow single character names

* fix(snapshot): run snapshot in coroutine

* feat(edge-jobs): add logs status

* feat(filesystem): add edge job logs methods

* feat(edge-jobs): intoduce edge jobs tasks api

* feat(edge-jobs): remove schedule task model

* fix(fs): build edge job task file path

* fix(edge-jobs): update task meta

* fix(edge-jobs): return a list of endpoints

* feat(edge-jobs): update logs from agent

* feat(edge-jobs): collect logs

* feat(edge-jobs): rename url

* feat(edge-jobs): refresh to same tab

* feat(edge-jobs): remove old info

* refactor(edge-jobs): rename script path json

* fix(edge-job): save file before adding job

* feat(edge-job): show retrieving logs label

* feat(edge-job): replace cron with 5 places

* refactor(edge-jobs): replace tasks with results

* feat(edge-jobs): add auto refresh until logs are collected

* feat(edge-jobs): fix column size

* feat(edge-job): display editor

* feat(edge-job): add name validation

* feat(edge-job): set default time for 1 hour from now

* feat(edge-job): add validation for cron format

* feat(edge-job): add a note about timezone

* fix(edge-job): replace regex

* fix(edge-job): check for every minute cron

* style(edge-jobs): add reference for cron regex

* refactor(edge-jobs): rename migration name

* refactor(edge-job): rename edge job response

* refactor(snapshot): rename snapshot endpoint method

* refactor(edge-jobs): move tasks handler to edgejobs

* feat(security): introduce a middleware for edge compute operations

* feat(edge-job): use edge compute middleware

* feat(edge-groups): filter http actions based on edge setting

* fix(security): return from edge bouncer if failed

* feat(edge-stacks): filter http actions based on edge setting

* feat(edge-groups): show error when failed to load groups

* refactor(db): remove edge-jobs migration

* refactor(migrator): remove unused dependency

Co-authored-by: Anthony Lapenna <lapenna.anthony@gmail.com>
This commit is contained in:
Chaim Lev-Ari 2020-06-25 06:25:51 +03:00 • committed by GitHub
parent b6f5d8f90e
commit 24528ecea8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
120 changed files with 2624 additions and 3484 deletions
Download patch file Download diff file Expand all files Collapse all files

21
app/edge/views/edge-jobs/create/createEdgeJobView.html Normal file
View file

@ -0,0 +1,21 @@
<rd-header>
<rd-header-title title-text="Create Edge job"></rd-header-title>
<rd-header-content> <a ui-sref="edge.jobs">Edge Jobs</a> &gt; Create Edge job </rd-header-content>
</rd-header>
<div class="row">
<div class="col-sm-12">
<rd-widget>
<rd-widget-body>
<edge-job-form
model="$ctrl.model"
groups="$ctrl.groups"
tags="$ctrl.tags"
form-action="$ctrl.create"
form-action-label="Create edge job"
action-in-progress="$ctrl.state.actionInProgress"
></edge-job-form>
</rd-widget-body>
</rd-widget>
</div>
</div>

7
app/edge/views/edge-jobs/create/createEdgeJobView.js Normal file
View file

@ -0,0 +1,7 @@
import angular from 'angular';
import CreateEdgeJobViewController from './createEdgeJobViewController';
angular.module('portainer.edge').component('createEdgeJobView', {
templateUrl: './createEdgeJobView.html',
controller: CreateEdgeJobViewController,
});

68
app/edge/views/edge-jobs/create/createEdgeJobViewController.js Normal file
View file

@ -0,0 +1,68 @@
import angular from 'angular';
class CreateEdgeJobController {
constructor($async, $q, $state, EdgeJobService, GroupService, Notifications, TagService) {
this.state = {
actionInProgress: false,
};
this.$async = $async;
this.$q = $q;
this.$state = $state;
this.Notifications = Notifications;
this.GroupService = GroupService;
this.EdgeJobService = EdgeJobService;
this.TagService = TagService;
this.create = this.create.bind(this);
this.createEdgeJob = this.createEdgeJob.bind(this);
this.createAsync = this.createAsync.bind(this);
}
create(method) {
return this.$async(this.createAsync, method);
}
async createAsync(method) {
this.state.actionInProgress = true;
try {
await this.createEdgeJob(method, this.model);
this.Notifications.success('Edge job successfully created');
this.$state.go('edge.jobs', {}, { reload: true });
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to create Edge job');
}
this.state.actionInProgress = false;
}
createEdgeJob(method, model) {
if (method === 'editor') {
return this.EdgeJobService.createEdgeJobFromFileContent(model);
}
return this.EdgeJobService.createEdgeJobFromFileUpload(model);
}
async $onInit() {
this.model = {
Name: '',
Recurring: false,
CronExpression: '',
Endpoints: [],
FileContent: '',
File: null,
};
try {
const [groups, tags] = await Promise.all([this.GroupService.groups(), this.TagService.tags()]);
this.groups = groups;
this.tags = tags;
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to retrieve page data');
}
}
}
angular.module('portainer.edge').controller('CreateEdgeJobController', CreateEdgeJobController);
export default CreateEdgeJobController;

23
app/edge/views/edge-jobs/edgeJobsView.html Normal file
View file

@ -0,0 +1,23 @@
<rd-header>
<rd-header-title title-text="Edge Jobs">
<a data-toggle="tooltip" title="Refresh" ui-sref="edge.jobs" ui-sref-opts="{reload: true}">
<i class="fa fa-sync" aria-hidden="true"></i>
</a>
</rd-header-title>
<rd-header-content>Edge Jobs</rd-header-content>
</rd-header>
<beta-panel></beta-panel>
<div class="row">
<div class="col-sm-12">
<edge-jobs-datatable
title-text="Edge jobs"
title-icon="fa-clock"
dataset="$ctrl.edgeJobs"
table-key="edgeJobs"
order-by="Name"
remove-action="$ctrl.removeAction"
></edge-jobs-datatable>
</div>
</div>

7
app/edge/views/edge-jobs/edgeJobsView.js Normal file
View file

@ -0,0 +1,7 @@
import angular from 'angular';
import EdgeJobsViewController from './edgeJobsViewController';
angular.module('portainer.edge').component('edgeJobsView', {
templateUrl: './edgeJobsView.html',
controller: EdgeJobsViewController,
});

56
app/edge/views/edge-jobs/edgeJobsViewController.js Normal file
View file

@ -0,0 +1,56 @@
import angular from 'angular';
import _ from 'lodash-es';
class EdgeJobsController {
constructor($async, $state, EdgeJobService, ModalService, Notifications) {
this.$async = $async;
this.$state = $state;
this.EdgeJobService = EdgeJobService;
this.ModalService = ModalService;
this.Notifications = Notifications;
this.removeAction = this.removeAction.bind(this);
this.deleteJobsAsync = this.deleteJobsAsync.bind(this);
this.deleteJobs = this.deleteJobs.bind(this);
}
removeAction(selectedItems) {
this.ModalService.confirmDeletion('Do you want to remove the selected edge job(s) ?', (confirmed) => {
if (!confirmed) {
return;
}
this.deleteJobs(selectedItems);
});
}
deleteJobs(edgeJobs) {
return this.$async(this.deleteJobsAsync, edgeJobs);
}
async deleteJobsAsync(edgeJobs) {
for (let edgeJob of edgeJobs) {
try {
await this.EdgeJobService.remove(edgeJob.Id);
this.Notifications.success('Stack successfully removed', edgeJob.Name);
_.remove(this.edgeJobs, edgeJob);
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to remove Edge job ' + edgeJob.Name);
}
}
this.$state.reload();
}
async $onInit() {
try {
const edgeJobs = await this.EdgeJobService.edgeJobs();
this.edgeJobs = edgeJobs;
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to retrieve Edge jobs');
this.edgeJobs = [];
}
}
}
angular.module('portainer.edge').controller('EdgeJobsController', EdgeJobsController);
export default EdgeJobsController;

52
app/edge/views/edge-jobs/edit/edgeJob.html Normal file
View file

@ -0,0 +1,52 @@
<rd-header>
<rd-header-title title-text="Edge job details">
<a data-toggle="tooltip" title-text="Refresh" ui-sref="edge.jobs.job({id: $ctrl.edgeJob.Id, tab: $ctrl.state.activeTab})" ui-sref-opts="{reload: true}">
<i class="fa fa-sync" aria-hidden="true"></i>
</a>
</rd-header-title>
<rd-header-content> <a ui-sref="edge.jobs">Edge jobs</a> &gt; {{ ::$ctrl.edgeJob.Name }} </rd-header-content>
</rd-header>
<div class="row">
<div class="col-sm-12">
<rd-widget>
<rd-widget-body>
<uib-tabset active="$ctrl.state.activeTab">
<uib-tab index="0" select="$ctrl.showEditor()">
<uib-tab-heading> <i class="fa fa-wrench" aria-hidden="true"></i> Configuration </uib-tab-heading>
<edge-job-form
ng-if="$ctrl.edgeJob && $ctrl.state.showEditorTab"
model="$ctrl.edgeJob"
endpoints="endpoints"
groups="$ctrl.groups"
tags="$ctrl.tags"
form-action="$ctrl.update"
form-action-label="Update Edge job"
action-in-progress="$ctrl.state.actionInProgress"
></edge-job-form>
</uib-tab>
<uib-tab index="1">
<uib-tab-heading> <i class="fa fa-tasks" aria-hidden="true"></i> Results </uib-tab-heading>
<edge-job-results-datatable
style="display: block; margin-top: 10px;"
ng-if="$ctrl.results"
title-text="Results"
title-icon="fa-tasks"
dataset="$ctrl.results"
table-key="edge-job-results"
order-by="Status"
reverse-order="true"
refresh-callback="$ctrl.refresh"
on-download-logs-click="($ctrl.downloadLogs)"
on-collect-logs-click="($ctrl.collectLogs)"
on-clear-logs-click="($ctrl.clearLogs)"
></edge-job-results-datatable>
</uib-tab>
</uib-tabset>
</rd-widget-body>
</rd-widget>
</div>
</div>

7
app/edge/views/edge-jobs/edit/edgeJob.js Normal file
View file

@ -0,0 +1,7 @@
import angular from 'angular';
import EdgeJobController from './edgeJobController';
angular.module('portainer.edge').component('edgeJobView', {
templateUrl: './edgeJob.html',
controller: EdgeJobController,
});

159
app/edge/views/edge-jobs/edit/edgeJobController.js Normal file
View file

@ -0,0 +1,159 @@
import angular from 'angular';
import _ from 'lodash-es';
class EdgeJobController {
constructor($async, $q, $state, EdgeJobService, EndpointService, FileSaver, GroupService, HostBrowserService, Notifications, TagService) {
this.state = {
actionInProgress: false,
showEditorTab: false,
};
this.$async = $async;
this.$q = $q;
this.$state = $state;
this.EdgeJobService = EdgeJobService;
this.EndpointService = EndpointService;
this.FileSaver = FileSaver;
this.GroupService = GroupService;
this.HostBrowserService = HostBrowserService;
this.Notifications = Notifications;
this.TagService = TagService;
this.update = this.update.bind(this);
this.updateAsync = this.updateAsync.bind(this);
this.downloadLogs = this.downloadLogs.bind(this);
this.downloadLogsAsync = this.downloadLogsAsync.bind(this);
this.collectLogs = this.collectLogs.bind(this);
this.collectLogsAsync = this.collectLogsAsync.bind(this);
this.clearLogs = this.clearLogs.bind(this);
this.clearLogsAsync = this.clearLogsAsync.bind(this);
this.refresh = this.refresh.bind(this);
this.refreshAsync = this.refreshAsync.bind(this);
this.showEditor = this.showEditor.bind(this);
}
update() {
return this.$async(this.updateAsync);
}
async updateAsync() {
const model = this.edgeJob;
this.state.actionInProgress = true;
try {
await this.EdgeJobService.updateEdgeJob(model);
this.Notifications.success('Edge job successfully updated');
this.$state.go('edge.jobs', {}, { reload: true });
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to update Edge job');
}
this.state.actionInProgress = false;
}
downloadLogs(endpointId) {
return this.$async(this.downloadLogsAsync, endpointId);
}
async downloadLogsAsync(endpointId) {
try {
const data = await this.EdgeJobService.logFile(this.edgeJob.Id, endpointId);
const downloadData = new Blob([data.FileContent], {
type: 'text/plain;charset=utf-8',
});
const logFileName = `job_${this.edgeJob.Id}_task_${endpointId}.log`;
this.FileSaver.saveAs(downloadData, logFileName);
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to download file');
}
}
associateEndpointsToResults(results, endpoints) {
return _.map(results, (result) => {
const endpoint = _.find(endpoints, (endpoint) => endpoint.Id === result.EndpointId);
result.Endpoint = endpoint;
return result;
});
}
collectLogs(endpointId) {
return this.$async(this.collectLogsAsync, endpointId);
}
async collectLogsAsync(endpointId) {
try {
await this.EdgeJobService.collectLogs(this.edgeJob.Id, endpointId);
const result = _.find(this.results, (result) => result.EndpointId === endpointId);
result.LogsStatus = 2;
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to collect logs');
}
}
clearLogs(endpointId) {
return this.$async(this.clearLogsAsync, endpointId);
}
async clearLogsAsync(endpointId) {
try {
await this.EdgeJobService.clearLogs(this.edgeJob.Id, endpointId);
const result = _.find(this.results, (result) => result.EndpointId === endpointId);
result.LogsStatus = 1;
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to clear logs');
}
}
refresh() {
return this.$async(this.refreshAsync);
}
async refreshAsync() {
const { id } = this.$state.params;
const results = await this.EdgeJobService.jobResults(id);
if (results.length > 0) {
const endpointIds = _.map(results, (result) => result.EndpointId);
const endpoints = await this.EndpointService.endpoints(undefined, undefined, { endpointIds });
this.results = this.associateEndpointsToResults(results, endpoints.value);
} else {
this.results = results;
}
}
showEditor() {
this.state.showEditorTab = true;
}
async $onInit() {
const { id, tab } = this.$state.params;
this.state.activeTab = tab;
if (!tab || tab === 0) {
this.state.showEditorTab = true;
}
try {
const [edgeJob, file, results, groups, tags] = await Promise.all([
this.EdgeJobService.edgeJob(id),
this.EdgeJobService.getScriptFile(id),
this.EdgeJobService.jobResults(id),
this.GroupService.groups(),
this.TagService.tags(),
]);
edgeJob.FileContent = file.FileContent;
this.edgeJob = edgeJob;
this.groups = groups;
this.tags = tags;
if (results.length > 0) {
const endpointIds = _.map(results, (result) => result.EndpointId);
const endpoints = await this.EndpointService.endpoints(undefined, undefined, { endpointIds });
this.results = this.associateEndpointsToResults(results, endpoints.value);
} else {
this.results = results;
}
} catch (err) {
this.Notifications.error('Failure', err, 'Unable to retrieve endpoint list');
}
}
}
angular.module('portainer.edge').controller('EdgeJobController', EdgeJobController);
export default EdgeJobController;

7
app/edge/views/groups/edgeGroupsViewController.js
View file

@ -14,7 +14,12 @@ class EdgeGroupsController {
}
async $onInit() {
this.items = await this.EdgeGroupService.groups();
try {
this.items = await this.EdgeGroupService.groups();
} catch (err) {
this.items = [];
this.Notifications.error('Failure', err, 'Unable to retrieve Edge groups');
}
}
removeAction(selectedItems) {