コード例 #1
0
        public void RoundRobinLocalSchedulerGoesSequentiallyThroughAllSpecifiedServiceUris()
        {
            int noOfUris = 10;
            var serviceUris = new ServiceUri[noOfUris];
            for(int i=0;i<noOfUris;i++)
            {
                serviceUris[i] = new ServiceUri() { Address = i.ToString() };
            }

            var scheduler = new RoundRobinLocalScheduler(serviceUris);
            for(int i=0;i<noOfUris;i++)
            {
                scheduler.GetRemoteServiceUri().Address.ShouldBe(serviceUris[i].Address);
            }

            scheduler.GetRemoteServiceUri().Address.ShouldBe(serviceUris[0].Address);
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: pbazydlo/bluepath
        static void Main(string[] args)
        {
            Program.Prefixes = new Dictionary<string, List<string>>();
            var options = new Options();
            if (CommandLine.Parser.Default.ParseArguments(args, options))
            {
                Bluepath.Log.DistributedMemoryHost = options.RedisHost;
                Bluepath.Log.WriteInfoToConsole = false;
                Bluepath.Log.WriteToDistributedMemory = false;

                var bluepathListener = Bluepath.Services.BluepathListener.InitializeDefaultListener(options.Ip, options.Port);
                using (var serviceDiscoveryClient = new CentralizedDiscovery.Client.CentralizedDiscovery(
                    new ServiceUri(options.CentralizedDiscoveryURI, BindingType.BasicHttpBinding),
                    bluepathListener
                    ))
                {
                    using (var connectionManager = new ConnectionManager(
                        remoteService: null,
                        listener: bluepathListener,
                        serviceDiscovery: serviceDiscoveryClient,
                        serviceDiscoveryPeriod: TimeSpan.FromSeconds(1)))
                    {
                        System.Threading.Thread.Sleep(1500);

                        string command = string.Empty;
                        string sharedStorageKey = "loadlist";
                        var sharedCounterKey = "counter";

                        Console.WriteLine("Initializing Redis");
                        var storage = new RedisStorage(options.RedisHost);
                        var list = new DistributedList<string>(storage, sharedStorageKey);
                        Console.WriteLine("List count: {0}", list.Count);

                        var commands = new Dictionary<string, Action>()
                        {
                            {"LOAD", ()=>
                            {
                                var sw = new Stopwatch();
                                sw.Start();
                                var scheduler = new RoundRobinLocalScheduler(connectionManager.RemoteServices.Select(s=>s.Key).ToArray());
                                list.Clear();
                                var counter = new DistributedCounter(storage, sharedCounterKey);
                                counter.SetValue(0);
                                var localList = new List<string>();
                                foreach(var file in Directory.EnumerateFiles(options.InputFolder))
                                {
                                    var fileContent = File.ReadAllText(file);
                                    localList.Add(fileContent);
                                }

                                list.AddRange(localList);
                                localList.Clear();
                                var servicesCount = connectionManager.RemoteServices.Count;
                                if(servicesCount==0)
                                {
                                    servicesCount = 1;
                                }

                                var calculatedChunkSize = (int)Math.Floor(Convert.ToDouble(list.Count) / servicesCount);
                                if(calculatedChunkSize==0)
                                {
                                    calculatedChunkSize = 1;
                                }

                                var threads = new List<DistributedThread>();
                                for(int i=0;i<servicesCount;i++)
                                {
                                    var loadThread = DistributedThread.Create(
                                    new Func<string, string, int, IBluepathCommunicationFramework, int>(
                                        (inputKey, counterKey, chunkSize, bluepath) =>
                                        {
                                            return LoadDocuments(inputKey, counterKey, chunkSize, bluepath);
                                        }), connectionManager, scheduler);
                                    loadThread.Start(sharedStorageKey, sharedCounterKey, calculatedChunkSize);
                                    threads.Add(loadThread);
                                }

                                foreach (var thread in threads)
                                {
                                    thread.Join();
                                }

                                list.Clear();
                                sw.Stop();
                                Console.WriteLine("Loaded in {0}ms", sw.ElapsedMilliseconds);
                            }},
                            {"SEARCH", ()=>
                            {
                                var services = connectionManager.RemoteServices.Select(s => s.Key).ToArray();
                                var scheduler = new RoundRobinLocalScheduler(services);
                                var threads = new List<DistributedThread>();
                                Console.Write("Word part: ");
                                var query = Console.ReadLine();
                                var sw = new Stopwatch();
                                sw.Start();
                                for(int i = 0;(i<services.Length) || i < 1;i++)
                                {
                                    var searchThread = DistributedThread.Create(
                                        new Func<string,string[]>((searchPhraze) =>
                                            {
                                                List<string> result = new List<string>();
                                                lock(Program.prefixesDictionaryLock)
                                                {
                                                    if(Program.Prefixes.ContainsKey(searchPhraze))
                                                    {
                                                        result = Program.Prefixes[searchPhraze];
                                                    }
                                                }

                                                return result.ToArray();
                                            }), null, scheduler);
                                    searchThread.Start(query);
                                    threads.Add(searchThread);
                                }

                                var joinedResult = new List<string>();
                                foreach (var thread in threads)
                                {
                                    thread.Join();
                                    joinedResult.AddRange(thread.Result as string[]);
                                }

                                var endResult = joinedResult.Distinct().ToArray();
                                sw.Stop();

                                Console.WriteLine();
                                Console.WriteLine(string.Join("||", endResult));
                                Console.WriteLine("Found in {0}ms", sw.ElapsedMilliseconds);

                            }},
                            {"CLEAN", ()=>
                            {
                                var services = connectionManager.RemoteServices.Select(s => s.Key).ToArray();
                                var scheduler = new RoundRobinLocalScheduler(services);
                                var threads = new List<DistributedThread>();
                                for(int i = 0;(i<services.Length) || i < 1;i++)
                                {
                                    var searchThread = DistributedThread.Create(
                                        new Func<int>(() =>
                                            {
                                                List<string> result = null;
                                                lock(Program.prefixesDictionaryLock)
                                                {
                                                    Program.Prefixes.Clear();
                                                }

                                                return 0;
                                            }), null, scheduler);
                                    searchThread.Start();
                                    threads.Add(searchThread);
                                }

                                foreach (var thread in threads)
                                {
                                    thread.Join();
                                }
                            }}
                        };
                        do
                        {
                            Console.WriteLine("Available commands:");
                            foreach (var key in commands.Keys)
                            {
                                Console.WriteLine(key);
                            }

                            Console.Write("Command['q' to exit]: ");
                            command = Console.ReadLine().ToUpper();
                            if (commands.ContainsKey(command))
                            {
                                commands[command]();
                            }

                        } while (command != "Q");
                    }
                }
            }
        }