Beispiel #1
0
        public void CollectorNet_ReadFromWriter()
        {
            const int proxyServer   = 22337;
            const int distrServer1  = 22338;
            const int distrServer12 = 22339;
            const int st1           = 22335;
            const int st2           = 22336;

            #region hell

            var writer = new HashWriter(new HashMapConfiguration("TestCollectorNet", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
            writer.CreateMap();
            writer.SetServer(0, "localhost", st1, st2);
            writer.Save();

            var common = new CommonConfiguration(1, 100);

            var netconfig = new NetConfiguration("localhost", proxyServer, "testService", 10);
            var toconfig  = new ProxyConfiguration(TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(1),
                                                   TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));

            var proxy = new TestGate(netconfig, toconfig, common);

            var distrNet = new DistributorNetConfiguration("localhost",
                                                           distrServer1, distrServer12, "testService", 10);
            var distrConf = new DistributorConfiguration(1, "TestCollectorNet",
                                                         TimeSpan.FromMilliseconds(100000), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(10000));

            var distr = new DistributorApi(distrNet, distrConf, common);

            var storageNet    = new StorageNetConfiguration("localhost", st1, st2, "testService", 10);
            var storageConfig = new StorageConfiguration("TestCollectorNet", 1, 10, TimeSpan.FromHours(1), TimeSpan.FromHours(1),
                                                         TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);

            var storage     = new WriterApi(storageNet, storageConfig, common);
            var async       = new AsyncTaskModule(new QueueConfiguration(4, 10));
            var distributor =
                new DistributorModule(new CollectorModel(new DistributorHashConfiguration(1),
                                                         new HashMapConfiguration("TestCollectorNet", HashMapCreationMode.ReadFromFile, 1, 1,
                                                                                  HashFileType.Collector)), async, new AsyncTasksConfiguration(TimeSpan.FromMinutes(1)));

            var net = new CollectorNetModule(new ConnectionConfiguration("testService", 10),
                                             new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout), distributor);

            distributor.SetNetModule(net);

            var back   = new BackgroundModule(new QueueConfiguration(5, 10));
            var loader = new DataLoader(net, 100, back);

            var parser = new TestIntParser();
            parser.SetCommandsHandler(
                new UserCommandsHandler <TestCommand, Type, TestCommand, int, int, TestDbReader>(
                    new TestUserCommandCreator(), new TestMetaDataCommandCreator()));
            var merge = new OrderMerge(loader, parser);

            var searchModule = new SearchTaskModule("Int", merge, loader, distributor, back, parser);

            storage.Build();
            proxy.Build();
            distr.Build();

            storage.AddDbModule(new TestInMemoryDbFactory());

            storage.Start();
            proxy.Start();
            distr.Start();

            searchModule.Start();
            distributor.Start();
            merge.Start();
            back.Start();
            net.Start();
            async.Start();

            #endregion

            proxy.Int.SayIAmHere("localhost", distrServer1);

            const int count = 20;

            for (int i = 0; i < count; i++)
            {
                var request = proxy.Int.CreateSync(i, i);
                Assert.AreEqual(RequestState.Complete, request.State);
            }

            var reader = searchModule.CreateReader("asc", -1, 20);
            reader.Start();

            for (int i = 0; i < count; i++)
            {
                Assert.IsTrue(reader.IsCanRead);

                reader.ReadNext();

                Assert.AreEqual(i, reader.GetValue(0));
            }
            reader.ReadNext();
            Assert.IsFalse(reader.IsCanRead);

            reader.Dispose();
            back.Dispose();
            net.Dispose();

            storage.Dispose();
            proxy.Dispose();
            distr.Dispose();
            async.Dispose();
        }
Beispiel #2
0
        public void SearchTaskModule_CreateReader_UnlimitDataReadAndUserPage()
        {
            var       server1  = new ServerId("", 1);
            var       server2  = new ServerId("", 2);
            var       server3  = new ServerId("", 3);
            const int pageSize = 5;
            var       writer   = new HashWriter(new HashMapConfiguration("TestCollector4", HashMapCreationMode.CreateNew, 3, 3, HashFileType.Distributor));

            writer.CreateMap();
            writer.SetServer(0, server1.RemoteHost, server1.Port, 157);
            writer.SetServer(1, server2.RemoteHost, server2.Port, 157);
            writer.SetServer(2, server3.RemoteHost, server3.Port, 157);
            writer.Save();

            var loader = new TestDataLoader(pageSize);
            var parser = new TestIntParser();

            parser.SetCommandsHandler(
                new UserCommandsHandler <TestCommand, Type, TestCommand, int, int, TestDbReader>(
                    new TestUserCommandCreator(), new TestMetaDataCommandCreator()));
            var merge       = new OrderMerge(loader, parser);
            var async       = new AsyncTaskModule(new QueueConfiguration(4, 10));
            var distributor =
                new DistributorModule(new CollectorModel(new DistributorHashConfiguration(1),
                                                         new HashMapConfiguration("TestCollector4", HashMapCreationMode.ReadFromFile, 1, 1,
                                                                                  HashFileType.Writer)), async, new AsyncTasksConfiguration(TimeSpan.FromMinutes(1)));
            var back = new BackgroundModule(new QueueConfiguration(5, 10));

            var searchModule = new SearchTaskModule("", merge, loader, distributor, back, parser);

            #region hell

            loader.Data.Add(server1, new List <SearchData>
            {
                TestHelper.CreateData(1),
                TestHelper.CreateData(2),
                TestHelper.CreateData(4),
                TestHelper.CreateData(5),
                TestHelper.CreateData(6),
                TestHelper.CreateData(7),
                TestHelper.CreateData(8),
            });

            loader.Data.Add(server2, new List <SearchData>
            {
                TestHelper.CreateData(4),
                TestHelper.CreateData(5),
                TestHelper.CreateData(6),
                TestHelper.CreateData(7),
                TestHelper.CreateData(8),
                TestHelper.CreateData(9),
                TestHelper.CreateData(10),
                TestHelper.CreateData(11),
            });

            loader.Data.Add(server3, new List <SearchData>
            {
                TestHelper.CreateData(2),
                TestHelper.CreateData(3),
                TestHelper.CreateData(5),
                TestHelper.CreateData(7),
                TestHelper.CreateData(8),
                TestHelper.CreateData(9),
                TestHelper.CreateData(10),
                TestHelper.CreateData(11),
                TestHelper.CreateData(12),
                TestHelper.CreateData(13),
            });

            #endregion

            searchModule.Start();
            distributor.Start();
            merge.Start();
            back.Start();
            async.Start();

            var reader = searchModule.CreateReader("asc", -1, 5);
            reader.Start();

            const int count = 13;
            for (int i = 0; i < count; i++)
            {
                Assert.IsTrue(reader.IsCanRead);

                reader.ReadNext();

                Assert.AreEqual(i + 1, reader.GetValue(0));
            }
            reader.ReadNext();
            Assert.IsFalse(reader.IsCanRead);

            reader.Dispose();
            async.Dispose();
            back.Dispose();
        }