From 64c4d61758e4bcdc34fd0cb0bcbf42525b74ef30 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Mon, 1 Oct 2018 22:12:28 +0200
Subject: [PATCH 1/9] Fledling work of cancelling a pipeline run.

---
 handlers/handler.go    |  1 +
 handlers/pipeline.go   | 41 +++++++++++++++++++++++++++++++++++++++++
 scheduler/scheduler.go | 32 ++++++++++++++++++++++++++++++++
 3 files changed, 74 insertions(+)

diff --git a/handlers/handler.go b/handlers/handler.go
index 00459034..1425aef4 100644
--- a/handlers/handler.go
+++ b/handlers/handler.go
@@ -65,6 +65,7 @@ func InitHandlers(e *echo.Echo) error {
 	e.GET(p+"pipeline/:pipelineid", PipelineGet)
 	e.PUT(p+"pipeline/:pipelineid", PipelineUpdate)
 	e.DELETE(p+"pipeline/:pipelineid", PipelineDelete)
+	e.POST(p+"pipeline/:pipelineid/:runid/stop", PipelineStop)
 	e.POST(p+"pipeline/:pipelineid/start", PipelineStart)
 	e.GET(p+"pipeline/latest", PipelineGetAllWithLatestRun)
 	e.POST(p+"pipeline/githook", GitWebHook)
diff --git a/handlers/pipeline.go b/handlers/pipeline.go
index 0ae962ee..aec9c09f 100644
--- a/handlers/pipeline.go
+++ b/handlers/pipeline.go
@@ -273,6 +273,47 @@ func PipelineStart(c echo.Context) error {
 	return c.String(http.StatusNotFound, errPipelineNotFound.Error())
 }
 
+// PipelineStop stops a running pipeline.
+func PipelineStop(c echo.Context) error {
+	schedulerService, _ := services.SchedulerService()
+	pipelineIDStr := c.Param("pipelineid")
+
+	// Look for arguments.
+	// We do not check for errors here cause arguments are optional.
+	args := []gaia.Argument{}
+	c.Bind(&args)
+
+	// Convert string to int because id is int
+	pipelineID, err := strconv.Atoi(pipelineIDStr)
+	if err != nil {
+		return c.String(http.StatusBadRequest, errInvalidPipelineID.Error())
+	}
+
+	// Convert string to int because id is int
+	runID, err := strconv.Atoi(c.Param("runid"))
+	if err != nil {
+		return c.String(http.StatusBadRequest, errPipelineRunNotFound.Error())
+	}
+
+	// Look up pipeline for the given id
+	var foundPipeline gaia.Pipeline
+	for pipeline := range pipeline.GlobalActivePipelines.Iter() {
+		if pipeline.ID == pipelineID {
+			foundPipeline = pipeline
+		}
+	}
+
+	if foundPipeline.Name != "" {
+		err = schedulerService.StopPipelineRun(&foundPipeline, runID)
+		if err != nil {
+			c.String(http.StatusBadRequest, err.Error())
+		}
+	}
+
+	// Pipeline not found
+	return c.String(http.StatusNotFound, errPipelineNotFound.Error())
+}
+
 type getAllWithLatestRun struct {
 	Pipeline    gaia.Pipeline    `json:"p"`
 	PipelineRun gaia.PipelineRun `json:"r"`
diff --git a/scheduler/scheduler.go b/scheduler/scheduler.go
index af84f616..ce0ba0cf 100644
--- a/scheduler/scheduler.go
+++ b/scheduler/scheduler.go
@@ -77,6 +77,7 @@ type GaiaScheduler interface {
 	Init() error
 	SchedulePipeline(p *gaia.Pipeline, args []gaia.Argument) (*gaia.PipelineRun, error)
 	SetPipelineJobs(p *gaia.Pipeline) error
+	StopPipelineRun(p *gaia.Pipeline, runID int) error
 }
 
 var _ GaiaScheduler = (*Scheduler)(nil)
@@ -260,6 +261,37 @@ func (s *Scheduler) schedule() {
 	}
 }
 
+// StopPipelineRun will prematurely cancel a pipeline run by killing all of its
+// jobs and running processes immediately.
+func (s *Scheduler) StopPipelineRun(p *gaia.Pipeline, runID int) error {
+
+	// 1. Get all running Jobs
+	// 2. Set state to failed and send a finish signal
+	// 3. Store the result
+
+	// Get jobs
+	// jobs, err := s.getPipelineJobs(p)
+	// if err != nil {
+	// 	gaia.Cfg.Logger.Error("cannot get pipeline jobs during schedule", "error", err.Error(), "pipeline", p)
+	// 	return err
+	// }
+
+	pr, err := s.storeService.PipelineGetRunByPipelineIDAndID(p.ID, runID)
+	if err != nil {
+		return err
+	}
+	if pr.Status != gaia.RunRunning {
+		return errors.New("pipeline is not in running state")
+	}
+	for _, job := range pr.Jobs {
+		if job.Status == gaia.JobRunning || job.Status == gaia.JobWaitingExec {
+			job.Status = gaia.JobFailed
+			job.FailPipeline = true
+		}
+	}
+	return nil
+}
+
 var schedulerLock = sync.RWMutex{}
 
 // SchedulePipeline schedules a pipeline. We create a new schedule object

From fb49037ad62a15848967967af05c2cdd629e7816 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Mon, 1 Oct 2018 23:11:57 +0200
Subject: [PATCH 2/9] Have the front-end work done.

---
 frontend/client/views/pipeline/detail.vue | 61 +++++++++++++++++++++++
 handlers/handler.go                       |  2 +-
 handlers/pipeline.go                      | 41 ---------------
 handlers/pipeline_run.go                  | 40 +++++++++++++++
 scheduler/scheduler.go                    |  9 +---
 5 files changed, 103 insertions(+), 50 deletions(-)

diff --git a/frontend/client/views/pipeline/detail.vue b/frontend/client/views/pipeline/detail.vue
index 5640c249..abde0428 100755
--- a/frontend/client/views/pipeline/detail.vue
+++ b/frontend/client/views/pipeline/detail.vue
@@ -47,13 +47,40 @@
                   <span v-else>{{ props.row.status }}</span>
                 </td>
                 <td>{{ calculateDuration(props.row.startdate, props.row.finishdate) }}</td>
+                <td>
+                  <a v-on:click="stopPipelineModal(pipelineID, props.row.id)"><i class="fa fa-trash" style="color: whitesmoke;"></i></a>
+                </td>
               </template>
               <div slot="emptystate" class="empty-table-text">
                 No pipeline runs found in database.
               </div>
             </vue-good-table>
         </article>
+
+        <!-- stop pipeline run modal -->
+        <modal :visible="showStopPipelineModal" class="modal-z-index" @close="close">
+          <div class="box secret-modal">
+            <article class="media">
+              <div class="media-content">
+                <div class="content">
+                  <p>
+                    <span style="color: black;">Do you really want to cancel this run?</span>
+                  </p>
+                </div>
+                <div class="modal-footer">
+                  <div style="float: left;">
+                    <button class="button is-primary" v-on:click="stopPipeline" style="width:150px;">Yes</button>
+                  </div>
+                  <div style="float: right;">
+                    <button class="button is-danger" v-on:click="close" style="width:130px;">No</button>
+                  </div>
+                </div>
+              </div>
+            </article>
+          </div>
+        </modal>
       </div>
+
     </div>
   </div>
 </template>
@@ -61,15 +88,20 @@
 <script>
 import Vue from 'vue'
 import Vis from 'vis'
+import { Modal } from 'vue-bulma-modal'
 import VueGoodTable from 'vue-good-table'
 import moment from 'moment'
 
 Vue.use(VueGoodTable)
 
 export default {
+  components: {
+    Modal
+  },
 
   data () {
     return {
+      showStopPipelineModal: false,
       pipelineID: null,
       runID: null,
       nodes: null,
@@ -87,6 +119,9 @@ export default {
         },
         {
           label: 'Duration'
+        },
+        {
+          label: 'Actions'
         }
       ],
       runsRows: [],
@@ -220,6 +255,32 @@ export default {
       return this.$http.get('/api/v1/pipelinerun/' + pipelineID + '/' + runID, { showProgressBar: false })
     },
 
+    stopPipeline () {
+      this.close()
+      this.$http
+        .post('/api/v1/pipelinerun/' + this.pipelineID + '/' + this.runID + '/stop', { showProgressBar: false })
+        .then(response => {
+          if (response.data) {
+            this.$router.push({path: '/pipeline/detail', query: { pipelineid: this.pipeline.id, runid: response.data.id }})
+          }
+        })
+        .catch((error) => {
+          this.$store.commit('clearIntervals')
+          this.$onError(error)
+        })
+    },
+
+    stopPipelineModal (pipelineID, runID) {
+      this.pipelineID = pipelineID
+      this.runID = runID
+      this.showStopPipelineModal = true
+    },
+
+    close () {
+      this.showStopPipelineModal = false
+      this.$emit('close')
+    },
+
     getPipelineRuns (pipelineID) {
       return this.$http.get('/api/v1/pipelinerun/' + pipelineID, { showProgressBar: false })
     },
diff --git a/handlers/handler.go b/handlers/handler.go
index 1425aef4..fcf971a9 100644
--- a/handlers/handler.go
+++ b/handlers/handler.go
@@ -65,12 +65,12 @@ func InitHandlers(e *echo.Echo) error {
 	e.GET(p+"pipeline/:pipelineid", PipelineGet)
 	e.PUT(p+"pipeline/:pipelineid", PipelineUpdate)
 	e.DELETE(p+"pipeline/:pipelineid", PipelineDelete)
-	e.POST(p+"pipeline/:pipelineid/:runid/stop", PipelineStop)
 	e.POST(p+"pipeline/:pipelineid/start", PipelineStart)
 	e.GET(p+"pipeline/latest", PipelineGetAllWithLatestRun)
 	e.POST(p+"pipeline/githook", GitWebHook)
 
 	// PipelineRun
+	e.POST(p+"pipelinerun/:pipelineid/:runid/stop", PipelineStop)
 	e.GET(p+"pipelinerun/:pipelineid/:runid", PipelineRunGet)
 	e.GET(p+"pipelinerun/:pipelineid", PipelineGetAllRuns)
 	e.GET(p+"pipelinerun/:pipelineid/latest", PipelineGetLatestRun)
diff --git a/handlers/pipeline.go b/handlers/pipeline.go
index aec9c09f..0ae962ee 100644
--- a/handlers/pipeline.go
+++ b/handlers/pipeline.go
@@ -273,47 +273,6 @@ func PipelineStart(c echo.Context) error {
 	return c.String(http.StatusNotFound, errPipelineNotFound.Error())
 }
 
-// PipelineStop stops a running pipeline.
-func PipelineStop(c echo.Context) error {
-	schedulerService, _ := services.SchedulerService()
-	pipelineIDStr := c.Param("pipelineid")
-
-	// Look for arguments.
-	// We do not check for errors here cause arguments are optional.
-	args := []gaia.Argument{}
-	c.Bind(&args)
-
-	// Convert string to int because id is int
-	pipelineID, err := strconv.Atoi(pipelineIDStr)
-	if err != nil {
-		return c.String(http.StatusBadRequest, errInvalidPipelineID.Error())
-	}
-
-	// Convert string to int because id is int
-	runID, err := strconv.Atoi(c.Param("runid"))
-	if err != nil {
-		return c.String(http.StatusBadRequest, errPipelineRunNotFound.Error())
-	}
-
-	// Look up pipeline for the given id
-	var foundPipeline gaia.Pipeline
-	for pipeline := range pipeline.GlobalActivePipelines.Iter() {
-		if pipeline.ID == pipelineID {
-			foundPipeline = pipeline
-		}
-	}
-
-	if foundPipeline.Name != "" {
-		err = schedulerService.StopPipelineRun(&foundPipeline, runID)
-		if err != nil {
-			c.String(http.StatusBadRequest, err.Error())
-		}
-	}
-
-	// Pipeline not found
-	return c.String(http.StatusNotFound, errPipelineNotFound.Error())
-}
-
 type getAllWithLatestRun struct {
 	Pipeline    gaia.Pipeline    `json:"p"`
 	PipelineRun gaia.PipelineRun `json:"r"`
diff --git a/handlers/pipeline_run.go b/handlers/pipeline_run.go
index 70180228..cfc0d224 100644
--- a/handlers/pipeline_run.go
+++ b/handlers/pipeline_run.go
@@ -8,6 +8,7 @@ import (
 	"strconv"
 
 	"github.com/gaia-pipeline/gaia"
+	"github.com/gaia-pipeline/gaia/pipeline"
 	"github.com/gaia-pipeline/gaia/services"
 	"github.com/labstack/echo"
 )
@@ -51,6 +52,45 @@ func PipelineRunGet(c echo.Context) error {
 	return c.JSON(http.StatusOK, pipelineRun)
 }
 
+// PipelineStop stops a running pipeline.
+func PipelineStop(c echo.Context) error {
+	schedulerService, _ := services.SchedulerService()
+	// Get parameters and validate
+	pipelineID := c.Param("pipelineid")
+	pipelineRunID := c.Param("runid")
+
+	// Transform pipelineid to int
+	p, err := strconv.Atoi(pipelineID)
+	if err != nil {
+		return c.String(http.StatusBadRequest, "invalid pipeline id given")
+	}
+
+	// Transform pipelinerunid to int
+	r, err := strconv.Atoi(pipelineRunID)
+	if err != nil {
+		return c.String(http.StatusBadRequest, "invalid pipeline run id given")
+	}
+
+	// Look up pipeline for the given id
+	var foundPipeline gaia.Pipeline
+	for pipeline := range pipeline.GlobalActivePipelines.Iter() {
+		if pipeline.ID == p {
+			foundPipeline = pipeline
+		}
+	}
+
+	if foundPipeline.Name != "" {
+		err = schedulerService.StopPipelineRun(&foundPipeline, r)
+		if err != nil {
+			return c.String(http.StatusBadRequest, err.Error())
+		}
+		return c.String(http.StatusOK, "pipeline successfully stopped")
+	}
+
+	// Pipeline not found
+	return c.String(http.StatusNotFound, errPipelineNotFound.Error())
+}
+
 // PipelineGetAllRuns returns all runs about the given pipeline.
 func PipelineGetAllRuns(c echo.Context) error {
 	// Convert string to int because id is int
diff --git a/scheduler/scheduler.go b/scheduler/scheduler.go
index ce0ba0cf..86a7ac5f 100644
--- a/scheduler/scheduler.go
+++ b/scheduler/scheduler.go
@@ -269,13 +269,6 @@ func (s *Scheduler) StopPipelineRun(p *gaia.Pipeline, runID int) error {
 	// 2. Set state to failed and send a finish signal
 	// 3. Store the result
 
-	// Get jobs
-	// jobs, err := s.getPipelineJobs(p)
-	// if err != nil {
-	// 	gaia.Cfg.Logger.Error("cannot get pipeline jobs during schedule", "error", err.Error(), "pipeline", p)
-	// 	return err
-	// }
-
 	pr, err := s.storeService.PipelineGetRunByPipelineIDAndID(p.ID, runID)
 	if err != nil {
 		return err
@@ -289,7 +282,7 @@ func (s *Scheduler) StopPipelineRun(p *gaia.Pipeline, runID int) error {
 			job.FailPipeline = true
 		}
 	}
-	return nil
+	return s.storeService.PipelinePutRun(pr)
 }
 
 var schedulerLock = sync.RWMutex{}

From d89e03074297678ccb86de776db70f63f6201543 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Tue, 2 Oct 2018 06:27:00 +0200
Subject: [PATCH 3/9] Fixed scheduler test and merge issue.

---
 handlers/pipeline_run.go                 | 2 +-
 workers/pipeline/create_pipeline_test.go | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/handlers/pipeline_run.go b/handlers/pipeline_run.go
index cfc0d224..e213fcfc 100644
--- a/handlers/pipeline_run.go
+++ b/handlers/pipeline_run.go
@@ -8,8 +8,8 @@ import (
 	"strconv"
 
 	"github.com/gaia-pipeline/gaia"
-	"github.com/gaia-pipeline/gaia/pipeline"
 	"github.com/gaia-pipeline/gaia/services"
+	"github.com/gaia-pipeline/gaia/workers/pipeline"
 	"github.com/labstack/echo"
 )
 
diff --git a/workers/pipeline/create_pipeline_test.go b/workers/pipeline/create_pipeline_test.go
index ffb14ef7..95cb354a 100644
--- a/workers/pipeline/create_pipeline_test.go
+++ b/workers/pipeline/create_pipeline_test.go
@@ -35,7 +35,8 @@ func (ms *mockScheduler) Init() error { return nil }
 func (ms *mockScheduler) SchedulePipeline(p *gaia.Pipeline, args []gaia.Argument) (*gaia.PipelineRun, error) {
 	return nil, nil
 }
-func (ms *mockScheduler) SetPipelineJobs(p *gaia.Pipeline) error { return ms.Error }
+func (ms *mockScheduler) SetPipelineJobs(p *gaia.Pipeline) error            { return ms.Error }
+func (ms *mockScheduler) StopPipelineRun(p *gaia.Pipeline, runid int) error { return ms.Error }
 
 func TestCreatePipelineUnknownType(t *testing.T) {
 	tmp, _ := ioutil.TempDir("", "TestCreatePipelineUnknownType")

From 25582ff1487b886706019baebe219eb7e89b3cc9 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Tue, 2 Oct 2018 22:50:13 +0200
Subject: [PATCH 4/9] This is now working, however, it is a bit wonkey.

---
 gaia.go                        |  3 +++
 workers/scheduler/scheduler.go | 39 +++++++++++++++++++++++-----------
 2 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/gaia.go b/gaia.go
index b69fe187..0e6b09ac 100644
--- a/gaia.go
+++ b/gaia.go
@@ -58,6 +58,9 @@ const (
 	// RunRunning status
 	RunRunning PipelineRunStatus = "running"
 
+	// RunCancelled status
+	RunCancelled PipelineRunStatus = "cancelled"
+
 	// JobWaitingExec status
 	JobWaitingExec JobStatus = "waiting for execution"
 
diff --git a/workers/scheduler/scheduler.go b/workers/scheduler/scheduler.go
index 86a7ac5f..346fb50a 100644
--- a/workers/scheduler/scheduler.go
+++ b/workers/scheduler/scheduler.go
@@ -261,14 +261,11 @@ func (s *Scheduler) schedule() {
 	}
 }
 
+var killedPipelineRun = make(chan *gaia.PipelineRun, 1)
+
 // StopPipelineRun will prematurely cancel a pipeline run by killing all of its
 // jobs and running processes immediately.
 func (s *Scheduler) StopPipelineRun(p *gaia.Pipeline, runID int) error {
-
-	// 1. Get all running Jobs
-	// 2. Set state to failed and send a finish signal
-	// 3. Store the result
-
 	pr, err := s.storeService.PipelineGetRunByPipelineIDAndID(p.ID, runID)
 	if err != nil {
 		return err
@@ -276,13 +273,11 @@ func (s *Scheduler) StopPipelineRun(p *gaia.Pipeline, runID int) error {
 	if pr.Status != gaia.RunRunning {
 		return errors.New("pipeline is not in running state")
 	}
-	for _, job := range pr.Jobs {
-		if job.Status == gaia.JobRunning || job.Status == gaia.JobWaitingExec {
-			job.Status = gaia.JobFailed
-			job.FailPipeline = true
-		}
-	}
-	return s.storeService.PipelinePutRun(pr)
+
+	pr.Status = gaia.RunCancelled
+	killedPipelineRun <- pr
+
+	return nil
 }
 
 var schedulerLock = sync.RWMutex{}
@@ -482,6 +477,8 @@ func (s *Scheduler) executeScheduledJobs(r gaia.PipelineRun, pS Plugin) {
 
 	if runFail {
 		s.finishPipelineRun(&r, gaia.RunFailed)
+	} else if r.Status == gaia.RunCancelled {
+		s.finishPipelineRun(&r, gaia.RunCancelled)
 	} else {
 		s.finishPipelineRun(&r, gaia.RunSuccess)
 	}
@@ -537,6 +534,24 @@ func (s *Scheduler) executeScheduler(r *gaia.PipelineRun, pS Plugin) {
 	finished := make(chan bool, 1)
 	for {
 		select {
+		case pr, ok := <-killedPipelineRun:
+			if ok {
+				if pr.ID == r.ID {
+					for _, job := range r.Jobs {
+						if job.Status == gaia.JobRunning || job.Status == gaia.JobWaitingExec {
+							job.Status = gaia.JobFailed
+							job.FailPipeline = true
+						}
+					}
+					r.Status = gaia.RunCancelled
+					s.storeService.PipelinePutRun(r)
+					close(done)
+					close(executeScheduler)
+					finished <- true
+					finalize = true
+					return
+				}
+			}
 		case <-finished:
 			close(pipelineFinished)
 			return

From 3faaea875a1fb0bb6cec36cb30d10b2c91db008a Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Thu, 4 Oct 2018 17:58:58 +0200
Subject: [PATCH 5/9] Updated channel size.

---
 workers/scheduler/scheduler.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/workers/scheduler/scheduler.go b/workers/scheduler/scheduler.go
index 346fb50a..9635b6e6 100644
--- a/workers/scheduler/scheduler.go
+++ b/workers/scheduler/scheduler.go
@@ -261,7 +261,9 @@ func (s *Scheduler) schedule() {
 	}
 }
 
-var killedPipelineRun = make(chan *gaia.PipelineRun, 1)
+// killedPipelineRun is used to signal the scheduler to abort a pipeline run.
+// to have guaranteed delivery this channel musn't be buffered.
+var killedPipelineRun = make(chan *gaia.PipelineRun, 0)
 
 // StopPipelineRun will prematurely cancel a pipeline run by killing all of its
 // jobs and running processes immediately.

From ceb752a09c9d7949844a6b73117c462418de8935 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Fri, 5 Oct 2018 21:46:57 +0200
Subject: [PATCH 6/9] Fixed log and views.

---
 frontend/client/views/pipeline/detail.vue | 18 +++++++++++-------
 handlers/pipeline_run.go                  |  2 +-
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/frontend/client/views/pipeline/detail.vue b/frontend/client/views/pipeline/detail.vue
index abde0428..2fb178a4 100755
--- a/frontend/client/views/pipeline/detail.vue
+++ b/frontend/client/views/pipeline/detail.vue
@@ -48,7 +48,7 @@
                 </td>
                 <td>{{ calculateDuration(props.row.startdate, props.row.finishdate) }}</td>
                 <td>
-                  <a v-on:click="stopPipelineModal(pipelineID, props.row.id)"><i class="fa fa-trash" style="color: whitesmoke;"></i></a>
+                  <a v-on:click="stopPipelineModal(pipelineID, props.row.id)"><i class="fa fa-ban" style="color: whitesmoke;"></i></a>
                 </td>
               </template>
               <div slot="emptystate" class="empty-table-text">
@@ -59,12 +59,12 @@
 
         <!-- stop pipeline run modal -->
         <modal :visible="showStopPipelineModal" class="modal-z-index" @close="close">
-          <div class="box secret-modal">
+          <div class="box stop-pipeline-modal">
             <article class="media">
               <div class="media-content">
                 <div class="content">
                   <p>
-                    <span style="color: black;">Do you really want to cancel this run?</span>
+                    <span style="color: white;">Do you really want to cancel this run?</span>
                   </p>
                 </div>
                 <div class="modal-footer">
@@ -460,9 +460,13 @@ export default {
 
 <style lang="scss">
 
-#pipeline-detail {
-  width: 100%;
-  height: 400px;
-}
+  #pipeline-detail {
+    width: 100%;
+    height: 400px;
+  }
+  .stop-pipeline-modal {
+    text-align: center;
+    background-color: #2a2735;
+  }
 
 </style>
diff --git a/handlers/pipeline_run.go b/handlers/pipeline_run.go
index e213fcfc..f1ab4980 100644
--- a/handlers/pipeline_run.go
+++ b/handlers/pipeline_run.go
@@ -159,7 +159,7 @@ func GetJobLogs(c echo.Context) error {
 	jL := jobLogs{}
 
 	// Determine if job has been finished
-	if run.Status == gaia.RunFailed || run.Status == gaia.RunSuccess {
+	if run.Status == gaia.RunFailed || run.Status == gaia.RunSuccess || run.Status == gaia.RunCancelled {
 		jL.Finished = true
 	}
 

From d975c9c01f1dc5a710940f85b5b2516ceabba711 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Fri, 5 Oct 2018 21:54:09 +0200
Subject: [PATCH 7/9] I do need the one size buffer.

---
 workers/scheduler/scheduler.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/workers/scheduler/scheduler.go b/workers/scheduler/scheduler.go
index 9635b6e6..e42e5906 100644
--- a/workers/scheduler/scheduler.go
+++ b/workers/scheduler/scheduler.go
@@ -262,8 +262,8 @@ func (s *Scheduler) schedule() {
 }
 
 // killedPipelineRun is used to signal the scheduler to abort a pipeline run.
-// to have guaranteed delivery this channel musn't be buffered.
-var killedPipelineRun = make(chan *gaia.PipelineRun, 0)
+// This has the size one for delayed guarantee of signal delivery.
+var killedPipelineRun = make(chan *gaia.PipelineRun, 1)
 
 // StopPipelineRun will prematurely cancel a pipeline run by killing all of its
 // jobs and running processes immediately.

From 73a49582ccd16a91e82f7dcad2adf82904810305 Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Fri, 5 Oct 2018 22:03:38 +0200
Subject: [PATCH 8/9] First test.

---
 workers/scheduler/scheduler_test.go | 40 +++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/workers/scheduler/scheduler_test.go b/workers/scheduler/scheduler_test.go
index 3870b193..c0928183 100644
--- a/workers/scheduler/scheduler_test.go
+++ b/workers/scheduler/scheduler_test.go
@@ -385,6 +385,46 @@ func TestSetPipelineJobs(t *testing.T) {
 	}
 }
 
+func TestStopPipelineRunFailIfPipelineNotInRunningState(t *testing.T) {
+	gaia.Cfg = &gaia.Config{}
+	storeInstance := store.NewBoltStore()
+	tmp, _ := ioutil.TempDir("", "TestStopPipelineRun")
+	gaia.Cfg.DataPath = tmp
+	gaia.Cfg.WorkspacePath = filepath.Join(tmp, "tmp")
+	gaia.Cfg.Bolt.Mode = 0600
+	gaia.Cfg.Logger = hclog.New(&hclog.LoggerOptions{
+		Level:  hclog.Trace,
+		Output: hclog.DefaultOutput,
+		Name:   "Gaia",
+	})
+	gaia.Cfg.Worker = "2"
+	if err := storeInstance.Init(); err != nil {
+		t.Fatal(err)
+	}
+	p, _ := prepareTestData()
+	storeInstance.PipelinePut(&p)
+	s := NewScheduler(storeInstance, &PluginFakeFailed{}, &CAFake{}, &VaultFake{})
+	_, err := s.SchedulePipeline(&p, prepareArgs())
+	if err != nil {
+		t.Fatal(err)
+	}
+	s.schedule()
+	r, err := storeInstance.PipelineGetRunByPipelineIDAndID(p.ID, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if r.Status != gaia.RunScheduled {
+		t.Fatalf("run has status %s but should be %s\n", r.Status, string(gaia.RunScheduled))
+	}
+	err = s.StopPipelineRun(&p, 1)
+	if err == nil {
+		t.Fatal("error was nil. should have failed")
+	}
+	if err.Error() != "pipeline is not in running state" {
+		t.Fatal("error was not what was expected 'pipeline is not in running state'. got: ", err.Error())
+	}
+}
+
 func prepareArgs() []gaia.Argument {
 	arg1 := gaia.Argument{
 		Description: "First Arg",

From ebe95e8697b7e5fa1410355f185bb3459bf7833d Mon Sep 17 00:00:00 2001
From: Gergely Brautigam <skarlso777@gmail.com>
Date: Sat, 6 Oct 2018 14:10:44 +0200
Subject: [PATCH 9/9] This does not yet exercise the channel logic.

---
 workers/scheduler/scheduler.go      |  4 ++++
 workers/scheduler/scheduler_test.go | 36 ++++++++++++++++++++++++++++-
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/workers/scheduler/scheduler.go b/workers/scheduler/scheduler.go
index e42e5906..dda5108b 100644
--- a/workers/scheduler/scheduler.go
+++ b/workers/scheduler/scheduler.go
@@ -277,6 +277,10 @@ func (s *Scheduler) StopPipelineRun(p *gaia.Pipeline, runID int) error {
 	}
 
 	pr.Status = gaia.RunCancelled
+	err = s.storeService.PipelinePutRun(pr)
+	if err != nil {
+		return err
+	}
 	killedPipelineRun <- pr
 
 	return nil
diff --git a/workers/scheduler/scheduler_test.go b/workers/scheduler/scheduler_test.go
index c0928183..2e4bfad5 100644
--- a/workers/scheduler/scheduler_test.go
+++ b/workers/scheduler/scheduler_test.go
@@ -388,7 +388,7 @@ func TestSetPipelineJobs(t *testing.T) {
 func TestStopPipelineRunFailIfPipelineNotInRunningState(t *testing.T) {
 	gaia.Cfg = &gaia.Config{}
 	storeInstance := store.NewBoltStore()
-	tmp, _ := ioutil.TempDir("", "TestStopPipelineRun")
+	tmp, _ := ioutil.TempDir("", "TestStopPipelineRunFailIfPipelineNotInRunningState")
 	gaia.Cfg.DataPath = tmp
 	gaia.Cfg.WorkspacePath = filepath.Join(tmp, "tmp")
 	gaia.Cfg.Bolt.Mode = 0600
@@ -425,6 +425,40 @@ func TestStopPipelineRunFailIfPipelineNotInRunningState(t *testing.T) {
 	}
 }
 
+func TestStopPipelineRun(t *testing.T) {
+	gaia.Cfg = &gaia.Config{}
+	storeInstance := store.NewBoltStore()
+	tmp, _ := ioutil.TempDir("", "TestStopPipelineRun")
+	gaia.Cfg.DataPath = tmp
+	gaia.Cfg.WorkspacePath = filepath.Join(tmp, "tmp")
+	gaia.Cfg.Bolt.Mode = 0600
+	gaia.Cfg.Logger = hclog.New(&hclog.LoggerOptions{
+		Level:  hclog.Trace,
+		Output: hclog.DefaultOutput,
+		Name:   "Gaia",
+	})
+	gaia.Cfg.Worker = "2"
+	if err := storeInstance.Init(); err != nil {
+		t.Fatal(err)
+	}
+	p, r := prepareTestData()
+	storeInstance.PipelinePut(&p)
+	s := NewScheduler(storeInstance, &PluginFake{}, &CAFake{}, &VaultFake{})
+
+	r.Status = gaia.RunRunning
+	storeInstance.PipelinePutRun(&r)
+
+	run, _ := storeInstance.PipelineGetRunByPipelineIDAndID(p.ID, r.ID)
+	err := s.StopPipelineRun(&p, run.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	run, _ = storeInstance.PipelineGetRunByPipelineIDAndID(p.ID, r.ID)
+	if run.Status != gaia.RunCancelled {
+		t.Fatal("expected pipeline state to be cancelled. got: ", r.Status)
+	}
+}
+
 func prepareArgs() []gaia.Argument {
 	arg1 := gaia.Argument{
 		Description: "First Arg",