go vendor

vendor/github.com/revel/modules/jobs/app/controllers/status.go

@@ -0,0 +1,35 @@
+package controllers
+
+import (
+	"strings"
+
+	"github.com/revel/cron"
+	"github.com/revel/modules/jobs/app/jobs"
+	"github.com/revel/revel"
+)
+
+type Jobs struct {
+	*revel.Controller
+}
+
+func (c Jobs) Status() revel.Result {
+	remoteAddress := c.Request.RemoteAddr
+	if revel.Config.BoolDefault("jobs.acceptproxyaddress", false) {
+		if proxiedAddress := c.Request.GetHttpHeader("X-Forwarded-For"); proxiedAddress!="" {
+			remoteAddress = proxiedAddress
+		}
+	}
+	if !strings.HasPrefix(remoteAddress, "127.0.0.1") &&
+		!strings.HasPrefix(remoteAddress, "::1") &&
+		!strings.HasPrefix(remoteAddress, "[::1]") {
+		return c.Forbidden("%s is not local", remoteAddress)
+	}
+	entries := jobs.MainCron.Entries()
+	return c.Render(entries)
+}
+
+func init() {
+	revel.TemplateFuncs["castjob"] = func(job cron.Job) *jobs.Job {
+		return job.(*jobs.Job)
+	}
+}

vendor/github.com/revel/modules/jobs/app/jobs/init.go

@@ -0,0 +1,13 @@
+package jobs
+
+import (
+	"github.com/revel/revel"
+)
+
+var jobLog = revel.AppLog
+
+func init() {
+	revel.RegisterModuleInit(func(m *revel.Module){
+		jobLog = m.Log
+	})
+}

vendor/github.com/revel/modules/jobs/app/jobs/job.go

@@ -0,0 +1,67 @@
+package jobs
+
+import (
+	"reflect"
+	"runtime/debug"
+	"sync"
+	"sync/atomic"
+
+	"github.com/revel/cron"
+	"github.com/revel/revel"
+)
+
+type Job struct {
+	Name    string
+	inner   cron.Job
+	status  uint32
+	running sync.Mutex
+}
+
+const UnNamed = "(unnamed)"
+
+func New(job cron.Job) *Job {
+	name := reflect.TypeOf(job).Name()
+	if name == "Func" {
+		name = UnNamed
+	}
+	return &Job{
+		Name:  name,
+		inner: job,
+	}
+}
+
+func (j *Job) Status() string {
+	if atomic.LoadUint32(&j.status) > 0 {
+		return "RUNNING"
+	}
+	return "IDLE"
+}
+
+func (j *Job) Run() {
+	// If the job panics, just print a stack trace.
+	// Don't let the whole process die.
+	defer func() {
+		if err := recover(); err != nil {
+			if revelError := revel.NewErrorFromPanic(err); revelError != nil {
+				jobLog.Error("Job Recovery ", "error", err, "stack", revelError.Stack)
+			} else {
+				jobLog.Error("Job Recovery ", "error", err, "stack", string(debug.Stack()))
+			}
+		}
+	}()
+
+	if !selfConcurrent {
+		j.running.Lock()
+		defer j.running.Unlock()
+	}
+
+	if workPermits != nil {
+		workPermits <- struct{}{}
+		defer func() { <-workPermits }()
+	}
+
+	atomic.StoreUint32(&j.status, 1)
+	defer atomic.StoreUint32(&j.status, 0)
+
+	j.inner.Run()
+}

vendor/github.com/revel/modules/jobs/app/jobs/jobrunner.go

@@ -0,0 +1,70 @@
+// A job runner for executing scheduled or ad-hoc tasks asynchronously from HTTP requests.
+//
+// It adds a couple of features on top of the cron package to make it play nicely with Revel:
+//
+// 1. Protection against job panics.  (They print to ERROR instead of take down the process)
+//
+// 2. (Optional) Limit on the number of jobs that may run simulatenously, to
+// limit resource consumption.
+//
+// 3. (Optional) Protection against multiple instances of a single job running
+// concurrently.  If one execution runs into the next, the next will be queued.
+//
+// 4. Cron expressions may be defined in app.conf and are reusable across jobs.
+//
+// 5. Job status reporting.
+package jobs
+
+import (
+	"strings"
+	"time"
+
+	"github.com/revel/cron"
+	"github.com/revel/revel"
+)
+
+// Callers can use jobs.Func to wrap a raw func.
+// (Copying the type to this package makes it more visible)
+//
+// For example:
+//    jobs.Schedule("cron.frequent", jobs.Func(myFunc))
+type Func func()
+
+func (r Func) Run() { r() }
+
+func Schedule(spec string, job cron.Job) error {
+	// Look to see if given spec is a key from the Config.
+	if strings.HasPrefix(spec, "cron.") {
+		confSpec, found := revel.Config.String(spec)
+		if !found {
+			jobLog.Panic("Cron spec not found: " + spec)
+		}
+		spec = confSpec
+	}
+	sched, err := cron.Parse(spec)
+	if err != nil {
+		return err
+	}
+	MainCron.Schedule(sched, New(job))
+	return nil
+}
+
+// Run the given job at a fixed interval.
+// The interval provided is the time between the job ending and the job being run again.
+// The time that the job takes to run is not included in the interval.
+func Every(duration time.Duration, job cron.Job) {
+	MainCron.Schedule(cron.Every(duration), New(job))
+}
+
+// Run the given job right now.
+func Now(job cron.Job) {
+	go New(job).Run()
+}
+
+// Run the given job once, after the given delay.
+func In(duration time.Duration, job cron.Job) {
+	go func() {
+		time.Sleep(duration)
+		New(job).Run()
+	}()
+}

vendor/github.com/revel/modules/jobs/app/jobs/plugin.go

@@ -0,0 +1,31 @@
+package jobs
+
+import (
+	"github.com/revel/cron"
+	"github.com/revel/revel"
+)
+
+const DefaultJobPoolSize = 10
+
+var (
+	// Singleton instance of the underlying job scheduler.
+	MainCron *cron.Cron
+
+	// This limits the number of jobs allowed to run concurrently.
+	workPermits chan struct{}
+
+	// Is a single job allowed to run concurrently with itself?
+	selfConcurrent bool
+)
+
+func init() {
+	MainCron = cron.New()
+	revel.OnAppStart(func() {
+		if size := revel.Config.IntDefault("jobs.pool", DefaultJobPoolSize); size > 0 {
+			workPermits = make(chan struct{}, size)
+		}
+		selfConcurrent = revel.Config.BoolDefault("jobs.selfconcurrent", false)
+		MainCron.Start()
+		jobLog.Info("Go to /@jobs to see job status.")
+	})
+}

vendor/github.com/revel/modules/jobs/app/views/Jobs/Status.html

@@ -0,0 +1,39 @@
+<html>
+	<head>
+		<style>
+body {
+  font-size: 12px;
+  font-family: sans-serif;
+}
+table {
+  border-collapse: collapse;
+  border: none;
+}
+table td, table th {
+  padding: 4 10px;
+  border: none;
+}
+table tr:nth-child(odd) {
+  background-color: #f0f0f0;
+}
+th {
+  text-align: left;
+}
+		</style>
+	</head>
+	<body>
+
+<h1>Scheduled Jobs</h1>
+
+<table>
+	<tr><th>Name</th><th>Status</th><th>Last run</th><th>Next run</th></tr>
+{{range .entries}}
+	{{$job := castjob .Job}}
+	<tr>
+		<td>{{$job.Name}}</td>
+		<td>{{$job.Status}}</td>
+		<td>{{if not .Prev.IsZero}}{{.Prev.Format "2006-01-02 15:04:05"}}{{end}}</td>
+		<td>{{if not .Next.IsZero}}{{.Next.Format "2006-01-02 15:04:05"}}{{end}}</td>
+	</tr>
+{{end}}
+</table>