Example #1
0
        public override string CreateExpiredJob(
            [NotNull] Job job,
            [NotNull] IDictionary <string, string> parameters,
            DateTime createdAt,
            TimeSpan expireIn)
        {
            if (job == null)
            {
                throw new ArgumentNullException(nameof(job));
            }
            if (parameters == null)
            {
                throw new ArgumentNullException(nameof(parameters));
            }

            var backgroundJob = new BackgroundJobEntry
            {
                Key                                              = Guid.NewGuid().ToString(), // TODO: Change with Long type
                InvocationData                                   = _options.DisableJobSerialization == false?InvocationData.SerializeJob(job) : null,
                                                      Job        = _options.DisableJobSerialization ? new Job(job.Type, job.Method, job.Args.ToArray()) : null,
                                                      Parameters = new ConcurrentDictionary <string, string>(parameters, StringComparer.Ordinal), // TODO: case sensitivity
                                                      CreatedAt  = createdAt
            };

            // TODO: Precondition: jobId does not exist
            _dispatcher.QueryAndWait(state =>
            {
                // TODO: We need somehow to ensure that this entry isn't removed before initialization
                backgroundJob.ExpireAt = state.TimeResolver().Add(expireIn);
                state.JobCreate(backgroundJob);
            });

            return(backgroundJob.Key);
        }
        public override string CreateExpiredJob(Job job, IDictionary <string, string> parameters, DateTime createdAt, TimeSpan expireIn)
        {
            var backgroundJob = new BackgroundJobEntry
            {
                Key            = Guid.NewGuid().ToString(), // TODO: Change with Long type
                InvocationData = InvocationData.SerializeJob(job),
                Parameters     = new ConcurrentDictionary <string, string>(parameters, StringComparer.Ordinal),
                CreatedAt      = createdAt
            };

            // TODO: Precondition: jobId does not exist
            _dispatcher.QueryAndWait(state =>
            {
                backgroundJob.ExpireAt = state.TimeResolver().Add(expireIn);
                state.JobCreate(backgroundJob);
            });

            return(backgroundJob.Key);
        }
Example #3
0
        public void Requeue()
        {
            var entry = _dispatcher.QueryAndWait(state =>
            {
                var value = state.QueueGetOrCreate(QueueName);
                value.Queue.Enqueue(JobId);
                return(value);
            });

            _dispatcher.SignalOneQueueWaitNode(entry);
        }
        public override void Commit()
        {
            _dispatcher.QueryAndWait(state =>
            {
                // TODO: Check all the preconditions (for example if locks are still held)
                foreach (var action in _actions)
                {
                    action(state);
                }
            });

            foreach (var queue in _enqueued)
            {
                _dispatcher.SignalOneQueueWaitNode(queue);
            }
        }
        public IList <ServerDto> Servers()
        {
            return(_dispatcher.QueryAndWait(state =>
            {
                var result = new List <ServerDto>(state.Servers.Count);
                foreach (var entry in state.Servers)
                {
                    result.Add(new ServerDto
                    {
                        Name = entry.Key,
                        Queues = entry.Value.Context.Queues.ToArray(),
                        WorkersCount = entry.Value.Context.WorkerCount,
                        Heartbeat = entry.Value.HeartbeatAt,
                        StartedAt = entry.Value.StartedAt,
                    });
                }

                return result;
            }));
        }
Example #6
0
        public override void Commit()
        {
            _dispatcher.QueryAndWait(state =>
            {
                foreach (var action in _actions)
                {
                    action(state);
                }

                // We reorder queue actions and run them after all the other commands, because
                // our GetJobData method is being reordered too
                foreach (var action in _queueActions)
                {
                    action(state);
                }
            });

            foreach (var queue in _enqueued)
            {
                _dispatcher.SignalOneQueueWaitNode(queue);
            }
        }