public void an_interface_based_message_is_published()
{
_receivedAnyRat = new Future <CorrelatedSwedishRat>();
var details = new AccountDetails();
_publisherBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_correlated_interface_publisher"));
sbc.SetPurgeOnStartup(true);
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
_subscriberBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_correlated_interface_subscriber"));
sbc.SetPurgeOnStartup(true);
sbc.Subscribe(s => s.Handler <CorrelatedSwedishRat>(_receivedAnyRat.Complete).Transient());
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
// wait for the inbound transport to become ready before publishing
_subscriberBus.Endpoint.InboundTransport.Receive(c1 => c2 => { }, 1.Milliseconds());
correlationId = CombGuid.Generate();
_publisherBus.Publish <CorrelatedSwedishRat>(new CorrImpl(correlationId, "meek"));
_receivedAnyRat.WaitUntilCompleted(15.Seconds()).ShouldBeTrue();
}
public void an_interface_based_message_is_published()
{
supertypeConsumer = new ConsumerOf <SpecialSwedishRat>();
subtypeConsumer = new ConsumerOf <SvenskSkogsråtta>();
var details = new AccountDetails();
PublisherBus = SetupServiceBus(details.BuildUri("When_publishing_subsuper_publisher"), cfg =>
{
cfg.SetPurgeOnStartup(true);
cfg.UseAzureServiceBusRouting();
});
SubscriberBus = SetupServiceBus(details.BuildUri("When_publishing_subtype_interfaces_single_publish_and_subscribing_supertype_subscriber"), cfg =>
{
cfg.SetPurgeOnStartup(true);
cfg.Subscribe(s =>
{
s.Instance(supertypeConsumer).Transient();
s.Instance(subtypeConsumer).Transient();
});
cfg.UseAzureServiceBusRouting();
});
// wait for the inbound transport to become ready before publishing
SubscriberBus.Endpoint.InboundTransport.Receive(c1 => c2 => { }, 1.Milliseconds());
PublisherBus.Publish <SpecialSwedishRat>(new DanneDenGråafläckigaRåttan
{
SoundsLike = "meeeäää",
GömmerSigIMyllan = true,
AnimalTag = new byte[] { 1, 2, 3 }
});
}
public void an_interface_based_message_is_published()
{
_receivedAnyRat = new Future <TMesg>();
var details = new AccountDetails();
_publisherBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_ordinary_interfaces_publisher"));
sbc.SetPurgeOnStartup(true);
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
_subscriberBus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(details.BuildUri("When_publishing_ordinary_interfaces_subscriber"));
sbc.SetPurgeOnStartup(true);
sbc.Subscribe(s => s.Handler <TMesg>(_receivedAnyRat.Complete).Transient());
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
});
// wait for the inbound transport to become ready before publishing
_subscriberBus.Endpoint.InboundTransport.Receive(c1 => c2 => { }, 1.Milliseconds());
_publisherBus.Publish <TMesg>(new
{
SoundsLike = "peep"
});
_receivedAnyRat.WaitUntilCompleted(35.Seconds()).ShouldBeTrue();
}
public Point_to_point_spec()
{
var creds = new AccountDetails();
LocalUri = creds.BuildUri("rat_hole");
RemoteUri = creds.BuildUri("hungry_cat");
}
public void An_interface_based_message_is_published()
{
_receivedAnyRat = new TaskCompletionSource <CorrelatedTestMessage>();
var details = new AccountDetails();
_subscriberBus = ServiceBusFactory.New(sbc =>
{
var uri = details.BuildUri("test_subscriber");
Console.WriteLine(uri);
sbc.ReceiveFrom(uri);
sbc.SetPurgeOnStartup(true);
sbc.Subscribe(s => s.Handler <CorrelatedTestMessage>(x => _receivedAnyRat.TrySetResult(x)).Transient());
sbc.UseAzureServiceBus(x =>
{
x.ConfigureNamespace(uri.Host, h =>
{
h.SetKeyName(AccountDetails.KeyName);
h.SetKey(AccountDetails.Key);
});
});
sbc.UseAzureServiceBusRouting();
});
_publisherBus = ServiceBusFactory.New(sbc =>
{
var uri = details.BuildUri("test_publisher");
sbc.ReceiveFrom(uri);
sbc.SetPurgeOnStartup(true);
sbc.UseAzureServiceBus(x =>
{
x.ConfigureNamespace(uri.Host, h =>
{
h.SetKeyName(AccountDetails.KeyName);
h.SetKey(AccountDetails.Key);
});
});
sbc.UseAzureServiceBusRouting();
});
_correlationId = NewId.NextGuid();
_publisherBus.Publish <CorrelatedTestMessage>(new CorrelatedTestMessageImpl(_correlationId, "meek"));
}
private static Uri GetEndpointUrl(string applicationName)
{
var details = new AccountDetails();
return(details.BuildUri(applicationName));
}
public override void Run()
{
// This is a sample worker implementation. Replace with your logic.
_logger.Info("starting receiver");
RoleEnvironment.Stopping += (sender, args) => _isStopping = true;
ConfigureDiagnostics();
var stopping = new AutoResetEvent(false);
long rampUp = Convert.ToInt32(RoleEnvironment.GetConfigurationSettingValue("RampUpCount"));
long sampleSize = Convert.ToInt32(RoleEnvironment.GetConfigurationSettingValue("SampleSize"));
long failures = 0;
long received = 0;
var watch = new Stopwatch();
var datapoints = new LinkedList <DataPoint>();
var senders = new LinkedList <IEndpoint>();
var maxSenders = Convert.ToInt32(RoleEnvironment.GetConfigurationSettingValue("WaitForNumberOfSenders"));
var allSendersUp = new CountdownEvent(maxSenders);
var creds = new AccountDetails();
using (var sb = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(creds.BuildUri("receiver"));
sbc.SetPurgeOnStartup(true);
sbc.UseNLog();
sbc.UseAzureServiceBus();
sbc.UseAzureServiceBusRouting();
}))
{
UnsubscribeAction unsubscribeMe = null;
unsubscribeMe += sb.SubscribeHandler <SenderUp>(su =>
{
_logger.Info("received SenderUp!");
lock (senders)
{
var endpoint = sb.GetEndpoint(su.Source);
if (!senders.Any(x => x.Address.Uri.Equals(endpoint.Address.Uri)) &&
allSendersUp.CurrentCount < maxSenders)
{
senders.AddLast(endpoint);
allSendersUp.Signal();
}
}
});
_logger.Info("waiting for all senders ...");
allSendersUp.Wait();
_logger.Info("sending 'ReadySetGo' to all senders");
lock (senders)
senders.Each(sender => sender.Send <ReadySetGo>(new {}));
//unsubscribeMe = sb.SubscribeHandler<IConsumeContext<ZoomZoom>>(consumeContext =>
unsubscribeMe += sb.SubscribeHandler <ZoomZoom>(payment =>
{
//var payment = consumeContext.Message;
long currentReceived;
if ((currentReceived = Interlocked.Increment(ref received)) == rampUp)
{
watch.Start();
}
else if (currentReceived < rampUp)
{
return;
}
var localFailures = new long?();
if (Math.Abs(payment.Amount - 1024m) > 0.0001m)
{
localFailures = Interlocked.Increment(ref failures);
}
if (currentReceived + rampUp == sampleSize || _isStopping)
{
unsubscribeMe();
watch.Stop();
stopping.Set();
}
if (currentReceived % 100 == 0)
{
var point = new DataPoint
{
Received = currentReceived,
Ticks = watch.ElapsedTicks,
Failures = localFailures ?? failures,
SampleMessage = payment,
Instance = DateTime.UtcNow
/* assume all prev 100 msgs same size */
//Size = consumeContext.BaseContext.BodyStream.Length * 100
};
lock (datapoints) datapoints.AddLast(point);
_logger.Debug(string.Format("Logging {0}", point));
}
});
PipelineViewer.Trace(sb.InboundPipeline);
_logger.Info("waiting for all messages!");
stopping.WaitOne();
sb.GetEndpoint(creds.BuildUri("sender")).Send <ZoomDone>(new{});
}
_logger.Info(
string.Format(@"
Performance Test Done
=====================
Total messages received: {0}
Time taken: {1}
of which:
Corrupt messages count: {2}
Valid messages count: {3}
metrics:
Message per second: {4}
Total bytes transferred:{5}
All samples' data equal:{6}
data points:
{7}
",
sampleSize, watch.Elapsed, failures,
sampleSize - failures,
1000d * sampleSize / (double)watch.ElapsedMilliseconds,
datapoints.Sum(dp => dp.Size),
datapoints.Select(x => x.SampleMessage).All(x => x.Payload.Equals(TestData.PayloadMessage, StringComparison.InvariantCulture)),
datapoints.Aggregate("", (str, dp) => str + dp.ToString() + Environment.NewLine)));
_logger.Info("Idling... aka. softar.");
while (true)
{
Thread.Sleep(10000);
}
// now have a look in Server Explorer, WADLogsTable, w/ Filter similar to "Timestamp gt datetime'2012-02-03T10:06:50Z'"
// (if this isn't your first deployment, or no filter if you feel like that)
}
