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);
}
