public async Task ConnectWorker_WatchesOnlySpecifiedTubes() { await ConnectAsync(); await prod.UseAsync("watched"); await DrainUsedTube(); int counter = 0; var options = new WorkerOptions { Tubes = { "watched" } }; var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, async(c, job) => { counter++; await c.DeleteAsync(); }); using (await worker) { await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await prod.UseAsync("default"); await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(200); } Assert.Equal(1, counter); }
public async Task ConnectWorker_CallsTheWorkerOnTheCurrentSyncContextByDefault() { await ConnectAsync(); const int MESSAGE_COUNT = 10; int wrongContextCount = 0; SynchronizationContext startingContext = SynchronizationContext.Current; var options = new WorkerOptions { }; var countdown = new CountdownEvent(MESSAGE_COUNT); var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, async(c, job) => { countdown.Signal(); if (startingContext != SynchronizationContext.Current) { wrongContextCount++; } await c.DeleteAsync(); }); using (await worker) { foreach (var n in Enumerable.Repeat(0, MESSAGE_COUNT)) { await prod.PutAsync(BitConverter.GetBytes(n), 1, TenSeconds, ZeroSeconds); } var consumedAllMessages = countdown.Wait(TimeSpan.FromSeconds(10)); Assert.True(consumedAllMessages, $"Did not consume all messages, remaining: {countdown.CurrentCount}"); } Assert.Equal(0, wrongContextCount); }
public async Task ConnectWorker_StopsWhenDisposed() { await ConnectAsync(); var tube = "i-am-a-tube"; int counter = 0; var options = new WorkerOptions { Tubes = { tube } }; var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, async(c, job) => { counter++; await c.DeleteAsync(); }); using (await worker) { await prod.UseAsync(tube); await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(200); } Assert.True(counter > 0); var finalValue = counter; await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(200); Assert.Equal(finalValue, counter); }
public async Task ConnectWorker_FollowsFailureOptionsIfTheWorkerFuncDoesntTakeAction() { await ConnectAsync(); await prod.UseAsync("watched"); await DrainUsedTube(); int receivedJobId = 0; var options = new WorkerOptions { Tubes = { "watched" }, FailureBehavior = WorkerFailureBehavior.Bury }; var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, async(c, job) => { if (receivedJobId == 0) { receivedJobId = job.Id; } await Task.Delay(0); // Don't call any IWorker methods }); using (await worker) { await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(100); } var stat = await prod.JobStatisticsAsync(receivedJobId); Assert.Equal(JobState.Buried, stat.State); }
private async Task <IProducer> ConnectToQueueAsync() { var producer = await BeanstalkConnection.ConnectProducerAsync(Connection); await producer.UseAsync("test_tube"); return(producer); }
public override async Task StartAsync(CancellationToken cancellationToken) { _consumer = await BeanstalkConnection.ConnectConsumerAsync(Connection); await _consumer.WatchAsync("test_tube"); await base.StartAsync(cancellationToken); }
public async Task ConnectWorker_FollowsFailureOptionsIfTheDeserializerThrows(WorkerFailureBehavior behavior) { await ConnectAsync(); await prod.UseAsync("watched"); await DrainUsedTube(); // Ensure all messages will fail horribly during deserialization var configuration = ConnectionConfiguration.Parse(connectionString); configuration.JobSerializer = new ThrowingSerializer(); bool gotInsideWorkerFunc = false; var options = new WorkerOptions { Tubes = { "watched" }, FailureBehavior = behavior, FailureReleaseDelay = TenSeconds, }; var worker = BeanstalkConnection.ConnectWorkerAsync <Jobject>(configuration, options, async(c, _) => { gotInsideWorkerFunc = true; await c.DeleteAsync(); }); int jobId; using (await worker) { jobId = await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(200); Assert.False(gotInsideWorkerFunc); var stats = await prod.JobStatisticsAsync(jobId); switch (behavior) { case WorkerFailureBehavior.Delete: Assert.Null(stats); return; case WorkerFailureBehavior.Bury: Assert.Equal(JobState.Buried, stats.State); return; case WorkerFailureBehavior.Release: Assert.Equal(JobState.Delayed, stats.State); return; case WorkerFailureBehavior.NoAction: Assert.Equal(JobState.Reserved, stats.State); return; default: throw new Exception("Untested behavior: " + behavior); } } }
public async Task ConnectAsync() { prod = await BeanstalkConnection.ConnectProducerAsync(config); cons = await BeanstalkConnection.ConnectConsumerAsync(config); await prod.UseAsync("jobjects"); await cons.WatchAsync("jobjects"); await cons.IgnoreAsync("default"); }
/// <summary> /// Write data in "anpr-out" tube /// </summary> /// <param name="data">Data to be written</param> public static async void WriteTubeAsync(JObject data) { // Producer connection to local host IProducer producer = await BeanstalkConnection.ConnectProducerAsync("localhost:11300"); // Use "anpr-out" tube await producer.UseAsync("anpr-out"); // Put data in tube await producer.PutAsync(data, 5, TimeSpan.Zero, TimeSpan.FromSeconds(0)); // Dispose producer producer.Dispose(); }
static async Task Main(string[] args) { var imageResizeRequest = new ImageResizeRequestDto { ClientId = "e552ed0c-5dde-475a-983e-ef3e4defb700", Id = 548667, Uri = new Uri("http://digitalcommunications.wp.st-andrews.ac.uk/files/2019/04/JPEG_compression_Example-768x576.jpg"), Name = "Test" }; var beanstalkdClient = await BeanstalkConnection.ConnectProducerAsync("localhost:11300"); await beanstalkdClient.UseAsync(JobChannelsEnum.ImageResize.ToString()); await beanstalkdClient.PutAsync(imageResizeRequest, 5, TimeSpan.Zero); }
async void connectButton_Click(object sender, EventArgs e) { connectButton.Enabled = false; disconnectButton.Enabled = true; var hostname = hostnameTextBox.Text; var port = Convert.ToInt32(portTextBox.Text); var connectionString = string.Format("{0}:{1}", hostname, port); var c = BeanstalkConnection.ConnectConsumerAsync(connectionString); var p = BeanstalkConnection.ConnectProducerAsync(connectionString); await Task.WhenAll(c, p); consumer = c.Result; producer = p.Result; }
async void connectButton_Click(object sender, EventArgs e) { connectButton.Enabled = false; var options = new WorkerOptions { Tubes = { watchTextBox.Text.Trim() } }; subscription = await BeanstalkConnection.ConnectWorkerAsync(_connectionString, options, async (conn, job) => { jobs.Add(job); await conn.DeleteAsync(); await Task.Delay(1000); }); disconnectButton.Enabled = true; }
public async Task UsesCustomSerializer() { var serializer = new CountingSerializer(); config.JobSerializer = serializer; using (var prod = await BeanstalkConnection.ConnectProducerAsync(config)) { await prod.UseAsync("jobjects"); var id = await prod.PutAsync <Jobject>(new Jobject(), 1, TimeSpan.FromSeconds(10)); await prod.PeekAsync <Jobject>(id); } Assert.Equal(1, serializer.SerializeCount); Assert.Equal(1, serializer.DeserializeCount); }
public async Task ConnectWorker_ThrownExceptionFollowsSpecifiedBehavior(WorkerFailureBehavior behavior) { await ConnectAsync(); var tube = "test-failure-behaviors"; await prod.UseAsync(tube); await DrainUsedTube(); var options = new WorkerOptions { Tubes = { tube }, FailureBehavior = behavior, FailurePriority = 1, FailureReleaseDelay = TimeSpan.FromSeconds(10), }; var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, (c, job) => { throw new Exception(); }); JobStatistics stats; using (await worker) { var id = await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(100); stats = await prod.JobStatisticsAsync(id); } switch (behavior) { case WorkerFailureBehavior.Delete: Assert.Null(stats); return; case WorkerFailureBehavior.Bury: Assert.Equal(JobState.Buried, stats.State); return; case WorkerFailureBehavior.Release: Assert.Equal(JobState.Delayed, stats.State); return; case WorkerFailureBehavior.NoAction: Assert.Equal(JobState.Reserved, stats.State); return; default: throw new Exception("Untested behavior"); } }
public async Task DoWork() { var options = new WorkerOptions { Tubes = new List <string>(1) { "alprd" }, //TaskScheduler = TaskScheduler.Current, }; var beanstalkAddress = Helper.ReadConfigKey("BeanstalkAddress"); if (string.IsNullOrEmpty(beanstalkAddress)) { beanstalkAddress = "localhost:11300"; } Program.Logger.Log.Info($"Beanstalk address used: {beanstalkAddress}"); worker = await BeanstalkConnection.ConnectWorkerAsync(beanstalkAddress, options, async (iworker, job) => { bool done = true; if (job != null) { var json = Encoding.UTF8.GetString(job.Data, 0, job.Data.Length); done = ProcessJob(json); } else { Program.Logger.Log.Warn("Job received was null."); } if (done) { await iworker.DeleteAsync(); } else { await iworker.BuryAsync(2); } }); }
/// <summary> /// Reads "anpr-in" tube /// </summary> /// <returns>Data from tube as object</returns> public static async Task <JObject> ReadTubeAsync() { // Consummer connection to local host IConsumer consumer = await BeanstalkConnection.ConnectConsumerAsync("localhost:11300"); // Watch "anpr-in" tube await consumer.WatchAsync("anpr-in"); // Get data from tube Job <JObject> job = await consumer.ReserveAsync <JObject>(); // Delete data from tube await consumer.DeleteAsync(job.Id); // Dispose consumer consumer.Dispose(); // Return data from tube as object return(job.Object); }
public async Task ConnectWorker_ConsumesJobsAsTheyAppear() { await ConnectAsync(); int counter = 0; var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, new WorkerOptions(), async(c, job) => { counter++; await c.DeleteAsync(); }); using (await worker) { await prod.PutAsync(new byte[] { }, 1, TenSeconds, ZeroSeconds); await Task.Delay(200); } Assert.NotEqual(0, counter); }
public async Task ConnectWorker_CreatesTheSpecifiedNumberOfWorkers() { var tube = "5-second-tasks"; await ConnectAsync(); await prod.UseAsync(tube); await Task.WhenAll( prod.PutAsync(new byte[] { }, 1, TenSeconds), prod.PutAsync(new byte[] { }, 1, TenSeconds), prod.PutAsync(new byte[] { }, 1, TenSeconds)); var reserved = new List <Job>(); var options = new WorkerOptions { Tubes = { tube }, NumberOfWorkers = 3 }; var worker = BeanstalkConnection.ConnectWorkerAsync(connectionString, options, async(c, job) => { reserved.Add(job); await Task.Delay(5000); await c.DeleteAsync(); }); var stats = new List <JobStatistics>(); using (await worker) { await Task.Delay(200); foreach (var job in reserved) { stats.Add(await prod.JobStatisticsAsync(job.Id)); } } Assert.Equal(3, stats.Count); Assert.All(stats, stat => Assert.Equal(JobState.Reserved, stat.State)); }
public async Task TypedWorkersWork() { int counter = 0; var worker = BeanstalkConnection.ConnectWorkerAsync <Jobject>(config, options, async(w, j) => { counter++; await w.DeleteAsync(); }); using (await worker) { await ConnectAsync(); await prod.PutAsync <Jobject>(new Jobject { }, 1, TimeSpan.FromSeconds(30)); await prod.PutAsync <Jobject>(new Jobject { }, 1, TimeSpan.FromSeconds(30)); await prod.PutAsync <Jobject>(new Jobject { }, 1, TimeSpan.FromSeconds(30)); await Task.Delay(200); } Assert.InRange(counter, 3, int.MaxValue); }
async Task ConnectAsync() { cons = await BeanstalkConnection.ConnectConsumerAsync(connectionString); prod = await BeanstalkConnection.ConnectProducerAsync(connectionString); }