github.com/psyb0t/mattermost-server@v4.6.1-0.20180125161845-5503a1351abf+incompatible/jobs/jobs_watcher.go (about)

     1  // Copyright (c) 2017-present Mattermost, Inc. All Rights Reserved.
     2  // See License.txt for license information.
     3  
     4  package jobs
     5  
     6  import (
     7  	"math/rand"
     8  	"time"
     9  
    10  	l4g "github.com/alecthomas/log4go"
    11  	"github.com/mattermost/mattermost-server/model"
    12  )
    13  
    14  const (
    15  	DEFAULT_WATCHER_POLLING_INTERVAL = 15000
    16  )
    17  
    18  type Watcher struct {
    19  	srv     *JobServer
    20  	workers *Workers
    21  
    22  	stop            chan bool
    23  	stopped         chan bool
    24  	pollingInterval int
    25  }
    26  
    27  func (srv *JobServer) MakeWatcher(workers *Workers, pollingInterval int) *Watcher {
    28  	return &Watcher{
    29  		stop:            make(chan bool, 1),
    30  		stopped:         make(chan bool, 1),
    31  		pollingInterval: pollingInterval,
    32  		workers:         workers,
    33  		srv:             srv,
    34  	}
    35  }
    36  
    37  func (watcher *Watcher) Start() {
    38  	l4g.Debug("Watcher Started")
    39  
    40  	// Delay for some random number of milliseconds before starting to ensure that multiple
    41  	// instances of the jobserver  don't poll at a time too close to each other.
    42  	rand.Seed(time.Now().UTC().UnixNano())
    43  	<-time.After(time.Duration(rand.Intn(watcher.pollingInterval)) * time.Millisecond)
    44  
    45  	defer func() {
    46  		l4g.Debug("Watcher Finished")
    47  		watcher.stopped <- true
    48  	}()
    49  
    50  	for {
    51  		select {
    52  		case <-watcher.stop:
    53  			l4g.Debug("Watcher: Received stop signal")
    54  			return
    55  		case <-time.After(time.Duration(watcher.pollingInterval) * time.Millisecond):
    56  			watcher.PollAndNotify()
    57  		}
    58  	}
    59  }
    60  
    61  func (watcher *Watcher) Stop() {
    62  	l4g.Debug("Watcher Stopping")
    63  	watcher.stop <- true
    64  	<-watcher.stopped
    65  }
    66  
    67  func (watcher *Watcher) PollAndNotify() {
    68  	if result := <-watcher.srv.Store.Job().GetAllByStatus(model.JOB_STATUS_PENDING); result.Err != nil {
    69  		l4g.Error("Error occured getting all pending statuses: %v", result.Err.Error())
    70  	} else {
    71  		jobs := result.Data.([]*model.Job)
    72  
    73  		for _, job := range jobs {
    74  			if job.Type == model.JOB_TYPE_DATA_RETENTION {
    75  				if watcher.workers.DataRetention != nil {
    76  					select {
    77  					case watcher.workers.DataRetention.JobChannel() <- *job:
    78  					default:
    79  					}
    80  				}
    81  			} else if job.Type == model.JOB_TYPE_MESSAGE_EXPORT {
    82  				if watcher.workers.MessageExport != nil {
    83  					select {
    84  					case watcher.workers.MessageExport.JobChannel() <- *job:
    85  					default:
    86  					}
    87  				}
    88  			} else if job.Type == model.JOB_TYPE_ELASTICSEARCH_POST_INDEXING {
    89  				if watcher.workers.ElasticsearchIndexing != nil {
    90  					select {
    91  					case watcher.workers.ElasticsearchIndexing.JobChannel() <- *job:
    92  					default:
    93  					}
    94  				}
    95  			} else if job.Type == model.JOB_TYPE_ELASTICSEARCH_POST_AGGREGATION {
    96  				if watcher.workers.ElasticsearchAggregation != nil {
    97  					select {
    98  					case watcher.workers.ElasticsearchAggregation.JobChannel() <- *job:
    99  					default:
   100  					}
   101  				}
   102  			} else if job.Type == model.JOB_TYPE_LDAP_SYNC {
   103  				if watcher.workers.LdapSync != nil {
   104  					select {
   105  					case watcher.workers.LdapSync.JobChannel() <- *job:
   106  					default:
   107  					}
   108  				}
   109  			}
   110  		}
   111  	}
   112  }