path: root/src/helsinki.at/rhimport/session.go

//
//  rhimportd
//
//  The Radio Helsinki Rivendell Import Daemon
//
//
//  Copyright (C) 2015 Christian Pointner <equinox@helsinki.at>
//
//  This file is part of rhimportd.
//
//  rhimportd is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  any later version.
//
//  rhimportd is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with rhimportd. If not, see <http://www.gnu.org/licenses/>.
//

package rhimport

import (
	"fmt"
	"net/http"
	"time"
)

const (
	SESSION_NEW = iota
	SESSION_RUNNING
	SESSION_CANCELED
	SESSION_DONE
	SESSION_TIMEOUT
)

type SessionChan struct {
	runChan         chan<- time.Duration
	cancelChan      chan<- bool
	addProgressChan chan<- sessionAddProgressHandlerRequest
	addDoneChan     chan<- sessionAddDoneHandlerRequest
}

type Session struct {
	ctx             ImportContext
	state           int
	removeFunc      func()
	done            chan bool
	quit            chan bool
	timer           *time.Timer
	cancelIntChan   chan bool
	progressIntChan chan ProgressData
	doneIntChan     chan ImportResult
	runChan         chan time.Duration
	cancelChan      chan bool
	addProgressChan chan sessionAddProgressHandlerRequest
	addDoneChan     chan sessionAddDoneHandlerRequest
	progressCBs     []*SessionProgressCB
	doneCBs         []*SessionDoneCB
}

type SessionProgressCB struct {
	cb       ImportProgressCB
	userdata interface{}
}

type SessionDoneCB struct {
	cb       func(ImportResult, interface{}) bool
	userdata interface{}
}

type ProgressData struct {
	step      int
	step_name string
	progress  float64
}

type sessionAddProgressHandlerResponse struct {
	err error
}

type sessionAddProgressHandlerRequest struct {
	userdata interface{}
	callback ImportProgressCB
	response chan<- sessionAddProgressHandlerResponse
}

type sessionAddDoneHandlerResponse struct {
	err error
}

type sessionAddDoneHandlerRequest struct {
	userdata interface{}
	callback func(ImportResult, interface{}) bool
	response chan<- sessionAddDoneHandlerResponse
}

func session_progress_callback(step int, step_name string, progress float64, userdata interface{}) bool {
	out := userdata.(chan<- ProgressData)
	out <- ProgressData{step, step_name, progress}
	return true
}

func session_import_run(ctx ImportContext, done chan<- ImportResult) {
	if err := ctx.SanityCheck(); err != nil {
		done <- ImportResult{http.StatusBadRequest, err.Error(), 0, 0}
		return
	}

	if res, err := FetchFile(&ctx); err != nil {
		done <- ImportResult{http.StatusInternalServerError, err.Error(), 0, 0}
		return
	} else if res.ResponseCode != http.StatusOK {
		done <- ImportResult{res.ResponseCode, res.ErrorString, 0, 0}
		return
	}

	if res, err := ImportFile(&ctx); err != nil {
		done <- ImportResult{http.StatusInternalServerError, err.Error(), 0, 0}
		return
	} else {
		done <- *res
		return
	}
}

func (self *Session) run(timeout time.Duration) {
	self.ctx.ProgressCallBack = session_progress_callback
	self.ctx.ProgressCallBackData = (chan<- ProgressData)(self.progressIntChan)
	self.ctx.Cancel = self.cancelIntChan
	go session_import_run(self.ctx, self.doneIntChan)
	self.state = SESSION_RUNNING
	self.timer.Reset(timeout)
	return
}

func (self *SessionChan) Run(timeout time.Duration) {
	select {
	case self.runChan <- timeout:
	default: // command is already pending or session is about to be closed/removed
	}
}

func (self *Session) cancel() {
	rhdl.Println("Session: canceling running import")
	select {
	case self.cancelIntChan <- true:
	default: // session got canceled already??
	}
	self.state = SESSION_CANCELED
}

func (self *SessionChan) Cancel() {
	select {
	case self.cancelChan <- true:
	default: // cancel is already pending or session is about to be closed/removed
	}
}

func (self *Session) addProgressHandler(userdata interface{}, cb ImportProgressCB) (resp sessionAddProgressHandlerResponse) {
	if self.state != SESSION_NEW && self.state != SESSION_RUNNING {
		resp.err = fmt.Errorf("session is already done/canceled")
	}
	self.progressCBs = append(self.progressCBs, &SessionProgressCB{cb, userdata})
	return
}

func (self *SessionChan) AddProgressHandler(userdata interface{}, cb ImportProgressCB) error {
	res_ch := make(chan sessionAddProgressHandlerResponse)
	req := sessionAddProgressHandlerRequest{}
	req.userdata = userdata
	req.callback = cb
	req.response = res_ch
	select {
	case self.addProgressChan <- req:
	default:
		return fmt.Errorf("session is about to be closed/removed")
	}

	res := <-res_ch
	return res.err
}

func (self *Session) addDoneHandler(userdata interface{}, cb func(ImportResult, interface{}) bool) (resp sessionAddDoneHandlerResponse) {
	if self.state != SESSION_NEW && self.state != SESSION_RUNNING {
		resp.err = fmt.Errorf("session is already done/canceled")
	}
	self.doneCBs = append(self.doneCBs, &SessionDoneCB{cb, userdata})
	return
}

func (self *Session) callProgressHandler(p *ProgressData) {
	for _, cb := range self.progressCBs {
		if cb.cb != nil {
			if keep := cb.cb(p.step, p.step_name, p.progress, cb.userdata); !keep {
				cb.cb = nil
			}
		}
	}
}

func (self *SessionChan) AddDoneHandler(userdata interface{}, cb func(ImportResult, interface{}) bool) error {
	res_ch := make(chan sessionAddDoneHandlerResponse)
	req := sessionAddDoneHandlerRequest{}
	req.userdata = userdata
	req.callback = cb
	req.response = res_ch
	select {
	case self.addDoneChan <- req:
	default:
		return fmt.Errorf("session is about to be closed/removed")
	}

	res := <-res_ch
	return res.err
}

func (self *Session) callDoneHandler(r *ImportResult) {
	for _, cb := range self.doneCBs {
		if cb.cb != nil {
			if keep := cb.cb(*r, cb.userdata); !keep {
				cb.cb = nil
			}
		}
	}
}

func (self *Session) dispatchRequests() {
	defer func() { self.done <- true }()
	for {
		select {
		case <-self.quit:
			if self.state == SESSION_RUNNING {
				self.cancel()
			}
			return
		case <-self.timer.C:
			if self.state == SESSION_RUNNING {
				self.cancel()
			}
			self.state = SESSION_TIMEOUT
			r := &ImportResult{500, "timeout", 0, 0}
			self.callDoneHandler(r)
			if self.removeFunc != nil {
				self.removeFunc()
			}
		case t := <-self.runChan:
			if self.state == SESSION_NEW {
				self.run(t)
			}
		case <-self.cancelChan:
			if self.state == SESSION_RUNNING {
				self.cancel()
			}
		case req := <-self.addProgressChan:
			req.response <- self.addProgressHandler(req.userdata, req.callback)
		case req := <-self.addDoneChan:
			req.response <- self.addDoneHandler(req.userdata, req.callback)
		case p := <-self.progressIntChan:
			self.callProgressHandler(&p)
		case r := <-self.doneIntChan:
			if self.state != SESSION_TIMEOUT {
				self.timer.Stop()
				self.state = SESSION_DONE
				self.callDoneHandler(&r)
				if self.removeFunc != nil {
					self.removeFunc()
				}
			}
		}
	}
}

func (self *Session) getInterface() *SessionChan {
	ch := &SessionChan{}
	ch.runChan = self.runChan
	ch.cancelChan = self.cancelChan
	ch.addProgressChan = self.addProgressChan
	ch.addDoneChan = self.addDoneChan
	return ch
}

func (self *Session) Cleanup() {
	self.quit <- true
	rhdl.Printf("waiting for session to close")
	<-self.done
	close(self.quit)
	close(self.done)
	self.timer.Stop()
	//   don't close the channels we give out because this might lead to a panic if
	//   somebody wites to an already removed session
	// close(self.cancelIntChan)
	// close(self.progressIntChan)
	// close(self.doneIntChan)
	// close(self.runChan)
	// close(self.cancelChan)
	// close(self.addProgressChan)
	// close(self.addDoneChan)
	rhdl.Printf("session is now cleaned up")
}

func NewSession(ctx *ImportContext, removeFunc func()) (session *Session) {
	session = new(Session)
	session.state = SESSION_NEW
	session.removeFunc = removeFunc
	session.ctx = *ctx
	session.done = make(chan bool)
	session.timer = time.NewTimer(10 * time.Second)
	session.cancelIntChan = make(chan bool, 1)
	session.progressIntChan = make(chan ProgressData, 10)
	session.doneIntChan = make(chan ImportResult, 1)
	session.runChan = make(chan time.Duration, 1)
	session.cancelChan = make(chan bool, 1)
	session.addProgressChan = make(chan sessionAddProgressHandlerRequest, 10)
	session.addDoneChan = make(chan sessionAddDoneHandlerRequest, 10)
	go session.dispatchRequests()
	return
}