public async Task send_message_via_forwarding()
{
var tracker = new MessageTracker();
var channel = "tcp://localhost:2345/incoming".ToUri();
using (var runtime = JasperRuntime.For(_ =>
{
_.Handlers.DisableConventionalDiscovery(true);
_.Handlers.IncludeType <NewMessageHandler>();
_.Services.AddSingleton(tracker);
_.Publish.Message <OriginalMessage>().To(channel);
_.Transports.ListenForMessagesFrom(channel);
}))
{
var waiter = tracker.WaitFor <NewMessage>();
await runtime.Bus.Send(new OriginalMessage { FirstName = "James", LastName = "Worthy" }, e =>
{
e.Destination = channel;
e.ContentType = typeof(OriginalMessage).ToContentType("json");
});
waiter.Wait(5.Seconds());
waiter.Result.Message.As <NewMessage>().FullName.ShouldBe("James Worthy");
}
}
public outbox_usage()
{
theSender = JasperRuntime.For <ItemSender>();
theReceiver = JasperRuntime.For <ItemReceiver>();
theTracker = theReceiver.Get <MessageTracker>();
theSender.RebuildMessageStorage();
theReceiver.RebuildMessageStorage();
thePersistor = theReceiver.Get <SqlServerEnvelopePersistor>();
using (var conn = new SqlConnection(ConnectionSource.ConnectionString))
{
conn.Open();
conn.CreateCommand(@"
IF OBJECT_ID('receiver.item_created', 'U') IS NOT NULL
drop table receiver.item_created;
").ExecuteNonQuery();
conn.CreateCommand(@"
create table receiver.item_created
(
id uniqueidentifier not null
primary key,
name varchar(100) not null
);
").ExecuteNonQuery();
}
}
public async Task enqueue_locally_with_designated_worker_queue()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery();
registry.Services.Scan(x =>
{
x.TheCallingAssembly();
x.WithDefaultConventions();
});
registry.Handlers.IncludeType <MessageConsumer>();
registry.Handlers.Worker("foo").MaximumParallelization(3);
var tracker = new MessageTracker();
registry.Services.AddSingleton(tracker);
using (var runtime = JasperHost.For(registry))
{
var waiter = tracker.WaitFor <Message1>();
var message = new Message1
{
Id = Guid.NewGuid()
};
await runtime.Get <IMessageContext>().Enqueue(message, "foo");
var received = await waiter;
received.Message.As <Message1>().Id.ShouldBe(message.Id);
}
}
public async Task enqueue_locally_lightweight()
{
var registry = new JasperRegistry();
registry.Handlers.IncludeType <RecordCallHandler>();
registry.Services.ForSingletonOf <IFakeStore>().Use <FakeStore>();
var tracker = new MessageTracker();
registry.Services.AddSingleton(tracker);
using (var runtime = JasperHost.For(registry))
{
var waiter = tracker.WaitFor <Message1>();
var message = new Message1
{
Id = Guid.NewGuid()
};
await runtime.Get <IMessageContext>().EnqueueLightweight(message);
waiter.Wait(5.Seconds());
var received = waiter.Result;
received.Message.As <Message1>().Id.ShouldBe(message.Id);
}
}
public SendingContext()
{
theTracker = new MessageTracker();
receiverRegistry.Handlers
.DisableConventionalDiscovery()
.IncludeType <MessageConsumer>();
receiverRegistry.Services.For <MessageTracker>().Use(theTracker);
}
public void Tracking()
{
var tracker = new MessageTracker();
var now = DateTime.Now;
Assert.IsFalse(tracker.RecentlySeen("a", now));
Assert.IsTrue(tracker.RecentlySeen("a", now));
Assert.IsFalse(tracker.RecentlySeen("a", now + tracker.Recent));
}
public OutboxSender(MessageTracker tracker)
{
Handlers.DisableConventionalDiscovery().IncludeType <CascadeReceiver>();
Services.AddSingleton(tracker);
Publish.Message <TriggerMessage>().To("durable://localhost:2337");
Transports.DurableListenerAt(2338);
Settings.PersistMessagesWithSqlServer(ConnectionSource.ConnectionString, "outbox_sender");
}
public sending_messages_without_sharing_types()
{
theTracker = new MessageTracker();
greenApp = JasperRuntime.For <GreenApp>();
blueApp = JasperRuntime.For(new BlueApp(theTracker));
theTracker.ShouldBeTheSameAs(blueApp.Get <MessageTracker>());
}
public void setup()
{
//AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
if (!isserverconok)
{
server = new TradeLink.Common.TLServer_WM();
con = new IQFeedHelper(server);
con.VerboseDebugging = verbosesetting;
con.SendDebug += new DebugDelegate(g.d);
// get login information
var data = Util.getfile(loginfile, g.d);
Assert.IsFalse(string.IsNullOrWhiteSpace(data), "no login info");
var li = data.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(3, li.Length, "missing login info");
// attempt to startup connection
con.Start(li[userr], li[pwr], li[prodr], Util.TLBuild());
// wait a moment
Util.sleep(4000);
Assert.IsTrue(isserverconok, "server connection failed");
}
if (isserverconok && !isclientconok)
{
var c = new TLClient_WM("tempiqclient", false);
c.VerboseDebugging = verbosesetting;
c.SendDebugEvent += new DebugDelegate(g.d);
if (c.ProvidersAvailable[0] != Providers.IQFeed)
{
throw new Exception("unable to find test server");
}
c.Mode(0, false);
client = c;
client.gotUnknownMessage += new MessageDelegate(client_gotUnknownMessage);
// verify
Assert.IsTrue(isclientconok, "client connection failed");
}
// reset everything
mt = new MessageTracker();
mt.VerboseDebugging = verbosesetting;
blt = new BarListTracker();
mt.BLT = blt;
mt.SendDebug += new DebugDelegate(g.d);
mt.GotNewBar += new SymBarIntervalDelegate(mt_GotNewBar);
recvbarcount = 0;
msgok = true;
g.d("iqfeed started.");
// wait a moment
Util.sleep(1000);
}
public static async Task Handle(
ItemCreated created,
SqlConnection conn, // the connection for the container scope
SqlTransaction tx, // the current transaction
MessageTracker tracker,
Envelope envelope)
{
await conn.CreateCommand(tx, "insert into receiver.item_created (id, name) values (@id, @name)")
.With("id", created.Id)
.With("name", created.Name)
.ExecuteNonQueryAsync();
tracker.Record(created, envelope);
}
public OutboxSender(MessageTracker tracker)
{
Handlers.DisableConventionalDiscovery().IncludeType <CascadeReceiver>();
Services.AddSingleton(tracker);
Publish.Message <TriggerMessage>().To("durable://localhost:2337");
Transports.DurableListenerAt(2338);
Settings.ConfigureMarten(marten =>
{
marten.Connection(ConnectionSource.ConnectionString);
marten.DatabaseSchemaName = "outbox_sender";
});
Include <MartenBackedPersistence>();
}
public outbox_usage()
{
theSender = JasperRuntime.For <ItemSender>();
theReceiver = JasperRuntime.For <ItemReceiver>();
theTracker = theReceiver.Get <MessageTracker>();
var senderStore = theSender.Get <IDocumentStore>();
senderStore.Advanced.Clean.CompletelyRemoveAll();
senderStore.Tenancy.Default.EnsureStorageExists(typeof(Envelope));
var receiverStore = theReceiver.Get <IDocumentStore>();
receiverStore.Advanced.Clean.CompletelyRemoveAll();
receiverStore.Tenancy.Default.EnsureStorageExists(typeof(Envelope));
}
void Response_SendMessage(MessageTypes type, long source, long dest, long id, string data, ref string response)
{
switch (type)
{
case MessageTypes.DOMREQUEST:
int d = 0;
string[] r = MessageTracker.ParseRequest(data);
if (r.Length > 1)
{
if (int.TryParse(MessageTracker.RequestParam(data, 1), out d))
{
_depth = d;
}
}
break;
}
}
public async Task send_via_the_alias_and_messages_actually_get_there_2()
{
var tracker = new MessageTracker();
await with(_ =>
{
_.Services.AddSingleton(tracker);
_.Services.For <IUriLookup>().Use <FakeUriLookup>();
_.Transports.ListenForMessagesFrom("fake://one");
});
var waiter = tracker.WaitFor <Message1>();
await Bus.Send("fake://one".ToUri(), new Message1());
var envelope = await waiter;
envelope.Destination.ShouldBe("loopback://one".ToUri());
}
// GET: api/Bot/5/userInput
public string Get(string appId, string userInput)
{
try
{
if (string.IsNullOrEmpty(appId))
{
return("Sorry Bot cannot identify user.");
}
if (string.IsNullOrEmpty(userInput))
{
return("Please input some text for Bot to read.");
}
string LastMsg = MessageTracker.GetLastMessage(appId);
string response = MessageResponse.Response(LastMsg, userInput).Trim();
MessageTracker.WriteLastMessaage(appId, response);
return(response);
}
catch (Exception ex) { return(ex.Message); } //return "Something went wrong while communicating with Bot!"; }
}
public async Task enqueue_locally_with_designated_worker_queue()
{
var registry = new JasperRegistry();
registry.Handlers.DisableConventionalDiscovery(false);
registry.Services.Scan(x =>
{
x.TheCallingAssembly();
x.WithDefaultConventions();
});
registry.Handlers.IncludeType <RecordCallHandler>();
registry.Services.ForSingletonOf <IFakeStore>().Use <FakeStore>();
registry.Handlers.Worker("foo").MaximumParallelization(3);
var tracker = new MessageTracker();
registry.Services.AddSingleton(tracker);
var runtime = await JasperRuntime.ForAsync(registry);
try
{
var waiter = tracker.WaitFor <Message1>();
var message = new Message1
{
Id = Guid.NewGuid()
};
await runtime.Get <IMessageContext>().Enqueue(message, "foo");
var received = await waiter;
received.Message.As <Message1>().Id.ShouldBe(message.Id);
}
finally
{
await runtime.Shutdown();
}
}
public SingletonArgMethod(MessageTracker tracker)
{
}
public Response Handle(Request request, Envelope envelope, MessageTracker tracker)
{
tracker.Record(request, envelope);
return(new Response());
}
public static void Handle(ItemCreated created, IDocumentSession session, MessageTracker tracker,
Envelope envelope)
{
session.Store(created);
tracker.Record(created, envelope);
}
public MessageConsumer(MessageTracker tracker)
{
_tracker = tracker;
}
public Service(MessageTracker tracker)
{
}
public sending_messages_without_sharing_types()
{
theTracker = new MessageTracker();
}
public static void Consume(Envelope envelope, BlueMessage message, MessageTracker tracker)
{
tracker.Record(message, envelope);
}
public RecordingHandler(MessageTracker tracker)
{
_tracker = tracker;
}
public MultipleArgMethod(MessageTracker tracker, IWidget widget)
{
}
public void Handle(ColorChosen message, ColorHistory history, Envelope envelope, MessageTracker tracker)
{
history.Name = message.Name;
history.Envelope = envelope;
tracker.Record(message, envelope);
}
public void Handle(NewMessage message, MessageTracker tracker, Envelope envelope)
{
tracker.Record(message, envelope);
}
public void Handle(ReceivedMessage message, Envelope envelope, ReceivingSettings settings, MessageTracker tracker)
{
if (settings.Latched)
{
throw new DivideByZeroException();
}
tracker.Record(message, envelope);
}
