Esempio n. 1
0
        static void Main(string[] args)
        {
            DebugMemoryDataCollector coll;
            //PersistenceManagerHandlerMemory<int, LightwaveMessage> pm = null;
            PersistenceManagerHandlerFileSystem <int, LightwaveMessage> pm = null;
            PersistenceClient <int, LightwaveMessage> pc = null;

            mservice = new MicroservicePipeline("PiO", description: "PiO Server");

            mservice
            .AdjustPolicyTaskManagerForDebug()
            .ConfigurationSetFromConsoleArgs(args)
            .AddDebugMemoryDataCollector(out coll)
            .AddChannelIncoming("lightwave", "LightwaveRF UDP traffic", ListenerPartitionConfig.Init(1))
            .AttachUdpListener(UdpConfig.UnicastAllIps(9761)
                               , requestAddress: ("message", "in")
                               , deserialize: (holder) => holder.SetObject(new LightwaveMessage(holder.Blob, (IPEndPoint)holder.Metadata), true))
            .AttachCommand(async(ctx) =>
            {
                //Do nothing
                var debug = pm.ChannelId;
                var rs    = await pc.Create(ctx.Request.Message.Holder.Object as LightwaveMessage);
            }, ("message", "in"))
            //.AttachPersistenceManagerHandlerMemory((LightwaveMessage m) => m.Trans, (s) => int.Parse(s), out pm)
            .AttachPersistenceManagerFileSystem((LightwaveMessage m) => m.Trans, (s) => int.Parse(s), out pm)
            .AttachPersistenceClient(out pc)
            .Revert()
            .AddChannelOutgoing("status", "Outgoing UDP status", SenderPartitionConfig.Init(1))
            .AttachUdpSender(UdpConfig.BroadcastAllIps(44723), serializer: new StatisticsSummaryLogUdpSerializer())
            .Revert()
            .OnDataCollection
            (
                (ctx, ev) =>
            {
                ctx.Outgoing.Process(("status", null, null), ev.Data, 1, ProcessOptions.RouteExternal);
            }
                , DataCollectionSupport.Statistics
            )
            ;

            mservice.StartWithConsole(args: args);
        }
        public void PipelineCaseInsensitive()
        {
            try
            {
                DebugMemoryDataCollector collector1, collector2;
                CommandInitiator         init = null;

                var fabric       = new ManualFabricBridge();
                var bridgeOut    = new ManualCommunicationBridgeAgent(fabric, CommunicationBridgeMode.RoundRobin);
                var bridgeReturn = new ManualCommunicationBridgeAgent(fabric, CommunicationBridgeMode.Broadcast);

                var pClient = new MicroservicePipeline("Client");
                var pServer = new MicroservicePipeline("Server");

                pServer
                .AdjustPolicyTaskManagerForDebug()
                .AddDebugMemoryDataCollector(out collector2)
                .AddPayloadSerializerDefaultJson()
                .AddChannelIncoming("INTERNALIN", internalOnly: false
                                    , autosetPartition01: false)
                .AttachPriorityPartition((0, 1.0M), (1, 0.9M))
                .AttachListener(bridgeOut.GetListener())
                .AttachMessagePriorityOverrideForResponse()
                .AttachCommand((CommandMethodRequestContext ctx) =>
                {
                    var payload = ctx.DtoGet <Blah>();
                    ctx.ResponseSet(200, payload.Message);
                    return(Task.FromResult(0));
                }, ("FRANKY", "johnny5"))
                .AttachCommand((CommandMethodRequestContext ctx) =>
                {
                    var payload = ctx.DtoGet <Blah>();
                    ctx.ResponseSet(201, payload.Message);
                    return(Task.FromResult(0));
                }, ("franky", "JoHnny6"))
                .Revert()
                .AddChannelOutgoing("return")
                .AttachSender(bridgeReturn.GetSender())
                .Revert();
                ;

                pClient
                .AdjustPolicyTaskManagerForDebug()
                .AddDebugMemoryDataCollector(out collector1)
                .AddChannelIncoming("Return")
                .AttachListener(bridgeReturn.GetListener())
                .AttachMessagePriorityOverrideForResponse()
                .AttachCommandInitiator(out init)
                .Revert()
                .AddChannelOutgoing("internalIn", internalOnly: false
                                    , autosetPartition01: false)
                .AttachPriorityPartition(0, 1)
                .AttachSender(bridgeOut.GetSender())
                .Revert()
                ;

                pClient.Start();
                pServer.Start();

                var list = new List <Task <ResponseWrapper <string> > >();

                list.Add(init.Process <ICaseSensitiveTest1, Blah, string>(new Blah()
                {
                    Message = "hello1"
                }));
                list.Add(init.Process <Blah, string>("Internalin", "franky", "johnny5", new Blah()
                {
                    Message = "hello2"
                }));
                list.Add(init.Process <Blah, string>(("InternalIn", "Franky", "johnny5"), new Blah()
                {
                    Message = "hello3"
                }));
                list.Add(init.Process <Blah, string>(("internalIN", "FRANKY", "johnny6"), new Blah()
                {
                    Message = "hello3"
                }));

                var result = Task.WhenAll(list).Result;

                result.ForEach((r) => Assert.IsTrue(r.ResponseCode == 200 || r.ResponseCode == 201));

                pClient.Stop();
                pServer.Stop();
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.Message);
            }
        }
Esempio n. 3
0
        public void Pipeline2()
        {
            try
            {
                DebugMemoryDataCollector collector1, collector1a, collector2;
                CommandInitiator         init  = null;
                CommandInitiator         init2 = null;

                IPipelineChannelIncoming <MicroservicePipeline> cpipeIn  = null;
                IPipelineChannelOutgoing <MicroservicePipeline> cpipeOut = null;

                var fabric       = new ManualFabricBridge();
                var bridgeOut    = new ManualCommunicationBridgeAgent(fabric, CommunicationBridgeMode.RoundRobin);
                var bridgeReturn = new ManualCommunicationBridgeAgent(fabric, CommunicationBridgeMode.Broadcast);

                //bridgeReturn.Agent.OnReceive += (o, e) => { if (e.Payload.Extent.Days == 42) init.ToString(); };
                //bridgeReturn.Agent.OnException += (o, e) => { if (e.Payload.Extent.Days == 42) init.ToString(); };

                var pClient  = new MicroservicePipeline("Client");
                var pClient2 = new MicroservicePipeline("Client2");
                var pServer  = new MicroservicePipeline("Server");

                pServer
                .AdjustPolicyTaskManagerForDebug()
                .AddDebugMemoryDataCollector(out collector2)
                .AddPayloadSerializerDefaultJson()
                .AddChannelIncoming("internalIn", internalOnly: false
                                    , autosetPartition01: false
                                    , assign: (p, c) => cpipeIn = p)
                .AttachPriorityPartition((0, 1.0M), (1, 0.9M))
                .AttachListener(bridgeOut.GetListener())
                .AttachMessagePriorityOverrideForResponse()
                .AttachCommand((CommandMethodRequestContext ctx) =>
                {
                    var payload = ctx.DtoGet <Blah>();
                    ctx.ResponseSet(200, payload.Message);
                    return(Task.FromResult(0));
                }, ("franky", "johnny5"))
                .AttachCommand((CommandMethodRequestContext ctx) =>
                {
                    var payload = ctx.DtoGet <Blah>();
                    ctx.ResponseSet(201, payload.Message);
                    return(Task.FromResult(0));
                }, ("franky", "johnny6"))
                .Revert()
                .AddChannelOutgoing("return")
                .AttachSender(bridgeReturn.GetSender())
                .Revert();
                ;

                pClient
                .AdjustPolicyTaskManagerForDebug()
                .AddDebugMemoryDataCollector(out collector1)
                .AddChannelIncoming("spooky", internalOnly: true)
                .AttachCommand((CommandMethodRequestContext ctx) =>
                {
                    var payload = ctx.DtoGet <Blah>();
                    ctx.ResponseSet(200, payload.Message);
                    return(Task.FromResult(0));
                }, ("franky", "johnny5"))
                .Revert()
                .AddChannelIncoming("return")
                .AttachListener(bridgeReturn.GetListener())
                .AttachMessagePriorityOverrideForResponse()
                .AttachCommandInitiator(out init)
                .Revert()
                .AddChannelOutgoing("internalIn", internalOnly: false
                                    , autosetPartition01: false
                                    , assign: (p, c) => cpipeOut = p)
                .AttachPriorityPartition(0, 1)
                .AttachSender(bridgeOut.GetSender())
                .Revert()
                ;


                pClient2
                .AdjustPolicyTaskManagerForDebug()
                .AddDebugMemoryDataCollector(out collector1a)
                .AddChannelIncoming("spooky", internalOnly: true)
                .AttachCommand((CommandMethodRequestContext ctx) =>
                {
                    var payload = ctx.DtoGet <Blah>();
                    ctx.ResponseSet(200, payload.Message);
                    return(Task.FromResult(0));
                }, ("franky", "johnny5"))
                .Revert()
                .AddChannelIncoming("return")
                .AttachListener(bridgeReturn.GetListener())
                .AttachMessagePriorityOverrideForResponse()
                .AttachCommandInitiator(out init2)
                .Revert()
                .AddChannelOutgoing("internalIn", internalOnly: false
                                    , autosetPartition01: false)
                .AttachPriorityPartition(0, 1)
                .AttachSender(bridgeOut.GetSender())
                .Revert()
                ;

                pClient.Start();
                pClient2.Start();
                pServer.Start();

                init.OnRequestUnresolved  += Init_OnRequestUnresolved;
                init2.OnRequestUnresolved += Init_OnRequestUnresolved;

                var list = new List <Task <ResponseWrapper <string> > >();

                list.Add(init.Process <IPipelineTest2, Blah, string>(new Blah()
                {
                    Message = "hello1"
                }));
                list.Add(init.Process <Blah, string>("internalIn", "franky", "johnny5", new Blah()
                {
                    Message = "hello2"
                }));
                list.Add(init.Process <Blah, string>(("internalIn", "franky", "johnny5"), new Blah()
                {
                    Message = "hello3"
                }));
                list.Add(init.Process <Blah, string>(("internalIn", "franky", "johnny6"), new Blah()
                {
                    Message = "hello3"
                }));
                list.Add(init.Process <Blah, string>(("spooky", "franky", "johnny5"), new Blah()
                {
                    Message = "hellospooky"
                }));

                var result = Task.WhenAll(list).Result;

                result.ForEach((r) => Assert.IsTrue(r.ResponseCode == 200 || r.ResponseCode == 201));

                pClient.Stop();
                pClient2.Stop();
                pServer.Stop();
            }
            catch (Exception ex)
            {
                Assert.Fail(ex.Message);
            }
        }
Esempio n. 4
0
        public void RPipeExternal()
        {
            PersistenceClient <Guid, PipeTest1> persistence, persistence2;
            CommandInitiator         init;
            DebugMemoryDataCollector collectorS, collectorC;

            var fabric       = new ManualFabricBridge();
            var bridgeOut    = new ManualCommunicationBridgeAgent(fabric, CommunicationBridgeMode.RoundRobin);
            var bridgeReturn = new ManualCommunicationBridgeAgent(fabric, CommunicationBridgeMode.Broadcast);

            var server = new MicroservicePipeline($"{nameof(RPipeExternal)}server");
            var client = new MicroservicePipeline($"{nameof(RPipeExternal)}client");

            server.ToMicroservice().Events.ProcessRequestError += Events_ProcessRequestError;
            server.ToMicroservice().Events.ProcessRequestUnresolved += Events_ProcessRequestUnresolved;

            client.ToMicroservice().Events.ProcessRequestError += Events_ProcessRequestError;
            client.ToMicroservice().Events.ProcessRequestUnresolved += Events_ProcessRequestUnresolved;

            server
            .AdjustPolicyTaskManagerForDebug()
            .AddDebugMemoryDataCollector(out collectorS)
            .AddChannelIncoming("inChannel")
            .AttachPersistenceManagerHandlerMemory(
                (PipeTest1 e) => e.Id
                , (s) => new Guid(s)
                , resourceProfile: "Entity")
            .AttachListener(bridgeOut.GetListener())

            .Revert()
            .AddChannelOutgoing("return")
            .AttachSender(bridgeReturn.GetSender())
            .Revert()
            ;

            client
            .AdjustPolicyTaskManagerForDebug()
            .AddDebugMemoryDataCollector(out collectorC)
            .AddChannelIncoming("return")
            .AttachCommandInitiator(out init)
            .AttachListener(bridgeReturn.GetListener())
            .Revert()
            .AddChannelOutgoing("inChannel")
            .AttachPersistenceClient("return", out persistence)
            .AttachSender(bridgeOut.GetSender())
            .Revert()
            ;

            server.Start();
            client.Start();

            var result = persistence.Create(new PipeTest1()
            {
                Message = "Hello"
            }
                                            , new RepositorySettings()
            {
                WaitTime = TimeSpan.FromMinutes(5)
            }
                                            ).Result;

            Assert.IsTrue(result.ResponseCode == 201);

            //var result2 = persistence2.Create(new PipeTest1() { Message = "Hello" }
            //    , new RepositorySettings() { WaitTime = TimeSpan.FromSeconds(5) }
            //    ).Result;

            //Assert.IsTrue(result2.ResponseCode == 501);

            //var result3 = init.Process<string, string>(("franky", "four", "fingers"), ""
            //    , new RequestSettings { WaitTime = TimeSpan.FromSeconds(5) }, routing: ProcessOptions.RouteInternal
            //    ).Result;

            //Assert.IsTrue(result3.ResponseCode == 501);
        }