Example #1
0
 private void ActionSyncOut([PayloadIn] Blah data, [PayloadOut] out string item)
 {
     item = "Super freaky doo dah";
     //var rs = incoming.ToResponse();
     //rs.Message.Blob = PayloadSerializer.PayloadSerialize("");
     //rs.Message.Status = "204";
     //rs.Message.StatusDescription = "Hello";
     //outgoing.Add(rs);
 }
Example #2
0
 private async Task <string> ActionAsync([PayloadIn] Blah data)
 {
     return("Freaky");
     //var rs = incoming.ToResponse();
     //rs.MessageObject = "Freaky";
     //rs.Message.Status = "204";
     //rs.Message.StatusDescription = "Hello";
     //outgoing.Add(rs);
 }
Example #3
0
 private string ActionSync([PayloadIn] Blah data)
 {
     return("Super freaky");
     //var rs = incoming.ToResponse();
     //rs.Message.Blob = PayloadSerializer.PayloadSerialize("");
     //rs.Message.Status = "204";
     //rs.Message.StatusDescription = "Hello";
     //outgoing.Add(rs);
 }
Example #4
0
        public void Pipeline1()
        {
            try
            {
                var pipeline = new MicroservicePipeline("TestPipeline");

                IPipelineChannelIncoming <MicroservicePipeline> cpipeIn     = null;
                IPipelineChannelOutgoing <MicroservicePipeline> cpipeOut    = null;
                PersistenceInternalService <Guid, Blah>         persistence = null;
                PersistenceBlahMemory    persistBlah = null;
                DebugMemoryDataCollector collector;

                int signalChange = 0;

                pipeline
                .AddDebugMemoryDataCollector(out collector)
                .AdjustPolicyTaskManager((t, c) =>
                {
                    t.ConcurrentRequestsMin = 1;
                    t.ConcurrentRequestsMax = 4;
                })
                .CallOut(ConfigureServiceRoot)
                .CallOut(CallOutDefault)
                .AddChannelIncoming("internalIn", internalOnly: true)
                .CallOut(ChannelInConfigure, (c) => true)
                .AttachCommand(new PersistenceBlahMemory(profile: "Blah"), assign: (p) => persistBlah    = p)
                .AttachCommand(new PersistenceInternalService <Guid, Blah>(), assign: (c) => persistence = c, channelResponse: cpipeOut)
                .CallOut((c) => cpipeIn = c)
                .Revert()
                .AddChannelOutgoing("internalOut", internalOnly: true)
                .CallOut(ChannelOutConfigure, (c) => false)
                .CallOut((c) => cpipeOut = c)
                .Revert();

                persistBlah.OnEntityChangeAction += ((o, e) => { signalChange++; });

                pipeline.Start();


                Guid cId  = Guid.NewGuid();
                var  blah = new Blah {
                    ContentId = cId, Message = "Hello", VersionId = Guid.NewGuid()
                };
                var result = persistence.Create(blah).Result;
                Assert.IsTrue(result.IsSuccess);

                var result2 = persistence.Read(cId).Result;
                Assert.IsTrue(result2.IsSuccess);

                blah.VersionId = Guid.NewGuid();
                var result3 = persistence.Update(blah).Result;
                Assert.IsTrue(result3.IsSuccess);

                var result4 = persistence.Delete(blah.ContentId).Result;
                Assert.IsTrue(result4.IsSuccess);


                Assert.IsTrue(signalChange == 3);

                Assert.IsTrue(calloutDefault.HasValue);
                Assert.IsTrue(calloutIn.HasValue);
                Assert.IsFalse(calloutOut.HasValue);

                pipeline.Stop();
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.Message);
            }
        }