cluster

func (*Job) Close ¶

func (j *Job) Close() error

Close terminates a scheduled job, preventing it from being scheduled on this plugin instance.

func (*JobOnce) Cancel ¶ added in v0.0.13

func (j *JobOnce) Cancel()

Cancel terminates a scheduled job, preventing it from being scheduled on this plugin instance. It also removes the job from the db, preventing it from being run in the future.

func (*JobOnceScheduler) Cancel ¶ added in v0.0.13

func (s *JobOnceScheduler) Cancel(key string)

Cancel cancels a job by its key. This is useful if the plugin lost the original *JobOnce, or is stopping a job found in ListScheduledJobs().

func (*JobOnceScheduler) ListScheduledJobs ¶ added in v0.0.13

func (s *JobOnceScheduler) ListScheduledJobs() ([]JobOnceMetadata, error)

ListScheduledJobs returns a list of the jobs in the db that have been scheduled. There is no guarantee that list is accurate by the time the caller reads the list. E.g., the jobs in the list may have been run, canceled, or new jobs may have scheduled.

func (*JobOnceScheduler) ScheduleOnce ¶ added in v0.0.13

func (s *JobOnceScheduler) ScheduleOnce(key string, runAt time.Time, props any) (*JobOnce, error)

ScheduleOnce creates a scheduled job that will run once. When the clock reaches runAt, the callback will be called with key and props as the argument.

If the job key already exists in the db, this will return an error. To reschedule a job, first cancel the original then schedule it again.

package main

import (
	"log"
	"time"

	"github.com/mattermost/mattermost-server/v6/plugin"
)

func HandleJobOnceCalls(key string, props any) {
	if key == "the key i'm watching for" {
		log.Println(props)
		// Work to do only once per cluster
	}
}

func main() {
	// Use p.API from your plugin instead.
	pluginAPI := plugin.API(nil)

	// Get the scheduler, which you can pass throughout the plugin...
	scheduler := GetJobOnceScheduler(pluginAPI)

	// Set the plugin's callback handler
	_ = scheduler.SetCallback(HandleJobOnceCalls)

	// Now start the scheduler, which starts the poller and schedules all waiting jobs.
	_ = scheduler.Start()

	// main thread...

	// add a job
	_, _ = scheduler.ScheduleOnce("the key i'm watching for", time.Now().Add(2*time.Hour), struct{ foo string }{"aasd"})

	// Maybe you want to check the scheduled jobs, or cancel them. This is completely optional--there
	// is no need to cancel jobs, even if you are shutting down. Call Cancel only when you want to
	// cancel a future job. Cancelling a job will prevent it from running in the future on this or
	// any server.
	jobs, _ := scheduler.ListScheduledJobs()
	defer func() {
		for _, j := range jobs {
			scheduler.Cancel(j.Key)
		}
	}()
}

Output:

func (*JobOnceScheduler) SetCallback ¶ added in v0.0.13

func (s *JobOnceScheduler) SetCallback(callback func(string, any)) error

SetCallback sets the scheduler's callback. When a job fires, the callback will be called with the job's id.

func (*JobOnceScheduler) Start ¶ added in v0.0.13

func (s *JobOnceScheduler) Start() error

Start starts the Scheduler. It finds all previous ScheduleOnce jobs and starts them running, and fires any jobs that have reached or exceeded their runAt time. Thus, even if a cluster goes down and is restarted, Start will restart previously scheduled jobs.

func (*Mutex) Lock ¶

func (m *Mutex) Lock()

Lock locks m. If the mutex is already locked by any plugin instance, including the current one, the calling goroutine blocks until the mutex can be locked.

func (*Mutex) LockWithContext ¶ added in v0.0.8

func (m *Mutex) LockWithContext(ctx context.Context) error

LockWithContext locks m unless the context is canceled. If the mutex is already locked by any plugin instance, including the current one, the calling goroutine blocks until the mutex can be locked, or the context is canceled.

The mutex is locked only if a nil error is returned.

func (*Mutex) Unlock ¶

func (m *Mutex) Unlock()

Unlock unlocks m. It is a run-time error if m is not locked on entry to Unlock.

Just like sync.Mutex, a locked Lock is not associated with a particular goroutine or plugin instance. It is allowed for one goroutine or plugin instance to lock a Lock and then arrange for another goroutine or plugin instance to unlock it. In practice, ownership of the lock should remain within a single plugin instance.