コード例 #1
0
 private void CreateAsyncSocket(Socket socket, JobProcessor jobProcessor, IPacketAnalyzer packetAnalyzer)
 {
     this.asyncSocket = this.CreateAsyncSocket(socket, packetAnalyzer);
     this.crypto      = ((packetAnalyzer == null) ? null : packetAnalyzer.CryptoTransform);
     if (jobProcessor == null)
     {
         this.asyncSocket.PacketReceive += delegate(object sender, EventArgs <ArraySegment <byte> > e)
         {
             this.OnPacketReceive(e);
         };
         this.asyncSocket.SocketException += delegate(object sender, EventArgs <Exception> e)
         {
             this.OnExceptionOccur(e);
         };
         this.asyncSocket.SocketClose += delegate(object sender, EventArgs e)
         {
             this.active = false;
             this.OnDisconnected(e);
         };
         return;
     }
     this.asyncSocket.PacketReceive += delegate(object sender, EventArgs <ArraySegment <byte> > e)
     {
         jobProcessor.Enqueue(Job.Create <EventArgs <ArraySegment <byte> > >(new Action <EventArgs <ArraySegment <byte> > >(this.OnPacketReceive), e));
     };
     this.asyncSocket.SocketException += delegate(object sender, EventArgs <Exception> e)
     {
         jobProcessor.Enqueue(Job.Create <EventArgs <Exception> >(new Action <EventArgs <Exception> >(this.OnExceptionOccur), e));
     };
     this.asyncSocket.SocketClose += delegate(object sender, EventArgs e)
     {
         this.active = false;
         jobProcessor.Enqueue(Job.Create <EventArgs>(new Action <EventArgs>(this.OnDisconnected), e));
     };
 }
コード例 #2
0
ファイル: LookUp.cs プロジェクト: ratiel/Vindictus
        public void FindLocation(Location key, Action <IPEndPoint> callback)
        {
            JobProcessor currentProcessor = JobProcessor.Current;

            this.CategoryLookUp.FindLocation(key.Category, delegate(IPEndPoint endpoint)
            {
                if (endpoint == null)
                {
                    Log <LookUp> .Logger.ErrorFormat("Cannot find category {0}", key.Category);
                    currentProcessor.Enqueue(Job.Create <IPEndPoint>(callback, null));
                    return;
                }
                this.Service.ConnectToIP(endpoint, delegate(Peer peer)
                {
                    SelectEntity selectop = new SelectEntity
                    {
                        ID       = key.ID,
                        Category = key.Category
                    };
                    selectop.OnComplete += delegate(Operation op)
                    {
                        switch (selectop.Result)
                        {
                        case SelectEntity.ResultCode.Ok:
                            currentProcessor.Enqueue(Job.Create <IPEndPoint>(callback, endpoint));
                            return;

                        case SelectEntity.ResultCode.Redirect:
                            this.IDLookUp.FindLocation(selectop.RedirectServiceID, callback);
                            return;

                        default:
                            currentProcessor.Enqueue(Job.Create <IPEndPoint>(callback, null));
                            return;
                        }
                    };
                    selectop.OnFail += delegate(Operation op)
                    {
                        Log <LookUp> .Logger.ErrorFormat("SelectEntity failed : [{0}], [{1}], {2}, {3}", new object[]
                        {
                            selectop.Result,
                            key,
                            key.ID,
                            key.Category
                        });
                        currentProcessor.Enqueue(Job.Create <IPEndPoint>(callback, null));
                    };
                    this.Service.RequestOperation(peer, selectop);
                });
            });
        }
コード例 #3
0
ファイル: BService.cs プロジェクト: ratiel/Vindictus
        public static void StartService()
        {
            try
            {
                BService     service      = new BService();
                JobProcessor jobProcessor = new JobProcessor();
                jobProcessor.ExceptionOccur += delegate(object sender, EventArgs <Exception> e)
                {
                    Log <BService> .Logger.Error("StartService", e.Value);
                };
                service.Initialize(jobProcessor);
                jobProcessor.Start();
                Register registerop = new Register(typeof(BService));
                registerop.OnComplete += delegate(Operation op)
                {
                    Log <BService> .Logger.DebugFormat("{0} registered on {1} : port {2}", registerop.Category, registerop.ID, registerop.Port);

                    service.ID     = registerop.ID;
                    service.Suffix = registerop.Suffix;
                    service.Start(registerop.Port);
                };
                registerop.OnFail += delegate(Operation op)
                {
                    Log <BService> .Logger.ErrorFormat("cannot find LocationService or register failed : {0}", registerop.Category);

                    service.Dispose();
                };
                jobProcessor.Enqueue(Job.Create <string, Register>(new Action <string, Register>(service.RequestOperation), typeof(UnifiedNetwork.LocationService.LookUp).FullName, registerop));
            }
            catch (Exception ex)
            {
                Log <BService> .Logger.Error("StartService", ex);
            }
        }
コード例 #4
0
        public static void Call <T>(Func <T> func, Action <T> onComplete, T exceptionCode)
        {
            JobProcessor mainThread = JobProcessor.Current;
            JobProcessor jobThread  = new JobProcessor();

            jobThread.ExceptionOccur += delegate(object s, EventArgs <Exception> e)
            {
                Log <GuildService> .Logger.Fatal("Exception occurred in AsyncFunc Thread", e.Value);
            };
            jobThread.Start();
            jobThread.Enqueue(Job.Create(delegate
            {
                T funcResult;
                try
                {
                    funcResult = func();
                }
                catch (Exception ex)
                {
                    Log <GuildService> .Logger.Error("Exception occurred in Async function call", ex);
                    funcResult = exceptionCode;
                }
                mainThread.Enqueue(Job.Create(delegate
                {
                    if (onComplete != null)
                    {
                        onComplete(funcResult);
                    }
                    jobThread.Stop(false);
                }));
            }));
        }
コード例 #5
0
 public void Initialize <T>(JobProcessor thread, IDictionary <Type, int> typeConverters) where T : ITcpServer, new()
 {
     GlobalContext.Properties["Category"] = this.Category;
     this.Thread = thread;
     thread.Enqueue(Job.Create(delegate
     {
         System.Threading.Thread.CurrentThread.Name = this.Category;
     }));
     //VEH.Install();
     this.Thread.ExceptionFilter += this.Thread_ExceptionFilter;
     this.Thread.ExceptionOccur  += this.Thread_ExceptionOccur;
     this.acceptor             = new Acceptor((default(T) == null) ? Activator.CreateInstance <T>() : default(T), thread);
     this.acceptor.OnAccepted += this.acceptor_OnAccepted;
     if (typeConverters != null)
     {
         this.acceptor.RegisterPipeMessageGroup(typeConverters);
     }
     this.acceptor.RegisterPipeMessageGroup(UnifiedNetwork.Cooperation.Message.TypeConverters);
     if (this.Initializing != null)
     {
         this.Initializing(this, EventArgs.Empty);
     }
     if (Settings.Default.PrintPerformanceInfo)
     {
         new PerformanceTest(this).RegisterPerformanceTestJob();
     }
     this.RegisterMessage(Operations.TypeConverters);
     this.RegisterProcessor(typeof(RequestLookUpInfo), (Operation x) => new RequsetLookUpInfoProcessor(this, x as RequestLookUpInfo));
     this.RegisterProcessor(typeof(RequestUnderingList), (Operation x) => new RequsetUnderingListProcessor(this, x as RequestUnderingList));
     this.RegisterProcessor(typeof(RequestOperationTimeReport), (Operation x) => new RequestOperationTimeReportProcessor(this, x as RequestOperationTimeReport));
     this.RegisterProcessor(typeof(EnableOperationTimeReport), (Operation x) => new EnableOperationTimeReportProcessor(this, x as EnableOperationTimeReport));
     this.RegisterProcessor(typeof(RequestShutDownEntity), (Operation x) => new RequestShutDownEntityProcessor(this, x as RequestShutDownEntity));
 }
コード例 #6
0
        private void EndConnect(IAsyncResult ar)
        {
            object[]        array          = (object[])ar.AsyncState;
            Socket          socket         = (Socket)array[0];
            JobProcessor    jobProcessor   = (JobProcessor)array[1];
            IPacketAnalyzer packetAnalyzer = (IPacketAnalyzer)array[2];

            if (jobProcessor != null && !jobProcessor.IsInThread())
            {
                jobProcessor.Enqueue(Job.Create <IAsyncResult>(new Action <IAsyncResult>(this.EndConnect), ar));
                return;
            }
            try
            {
                socket.EndConnect(ar);
                this.CreateAsyncSocket(socket, jobProcessor, packetAnalyzer);
                this.OnConnectionSucceed(EventArgs.Empty);
                this.asyncSocket.Activate();
            }
            catch (Exception value)
            {
                this.active = false;
                this.OnConnectionFail(new EventArgs <Exception>(value));
            }
        }
コード例 #7
0
        public Test()
        {
            Service1     service      = new Service1();
            Service2     service2     = new Service2();
            JobProcessor jobProcessor = new JobProcessor();

            jobProcessor.ExceptionOccur += this.thread_ExceptionOccur;
            jobProcessor.Start();
            service.Initialize(jobProcessor, TestOperations.TypeConverters);
            service2.Initialize(jobProcessor, TestOperations.TypeConverters);
            service.LookUp.AddLocation(new ServiceInfo
            {
                ID       = 1,
                FullName = typeof(Service2).FullName,
                EndPoint = new IPEndPoint(IPAddress.Loopback, 10001)
            });
            service2.LookUp.AddLocation(new ServiceInfo
            {
                ID       = 2,
                FullName = typeof(Service1).FullName,
                EndPoint = new IPEndPoint(IPAddress.Loopback, 10000)
            });
            service.Start(10000);
            service2.Start(10001);
            TestOp t1 = new TestOp(100);

            t1.OnComplete += delegate(Operation op)
            {
                Console.WriteLine("result of t1 : {0}", t1.OutValue);
            };
            TestOp t2 = new TestOp(200);

            t2.OnComplete += delegate(Operation op)
            {
                Console.WriteLine("result of t2 : {0}", t2.OutValue);
            };
            jobProcessor.Enqueue(Job.Create <string, TestOp>(new Action <string, TestOp>(service.RequestOperation), typeof(Service2).FullName, t1));
            jobProcessor.Enqueue(Job.Create <string, TestOp>(new Action <string, TestOp>(service2.RequestOperation), typeof(Service1).FullName, t2));
        }
コード例 #8
0
ファイル: AService.cs プロジェクト: ratiel/Vindictus
        public static void StartService()
        {
            AService     service = new AService();
            JobProcessor thread  = new JobProcessor();

            thread.ExceptionOccur += delegate(object sender, EventArgs <Exception> e)
            {
                Log <AService> .Logger.Error("StartService", e.Value);
            };
            service.Initialize(thread);
            thread.Start();
            Register registerop = new Register(typeof(AService));

            registerop.OnComplete += delegate(Operation op)
            {
                Log <AService> .Logger.DebugFormat("{0} registered on {1} : port {2}", registerop.Category, registerop.ID, registerop.Port);

                service.ID     = registerop.ID;
                service.Suffix = registerop.Suffix;
                service.Start(registerop.Port);
                Plus1 op2 = new Plus1
                {
                    Input = 5
                };
                op2.OnComplete += delegate(Operation x)
                {
                    Log <AService> .Logger.DebugFormat("result : {0}", op2.Output);
                };
                op2.OnComplete += delegate(Operation x)
                {
                    Scheduler.Schedule(thread, Job.Create(delegate
                    {
                        service.RequestOperation("B", op2);
                    }), 5000);
                };
                op2.OnFail += delegate(Operation x)
                {
                    Log <AService> .Logger.Debug("failed");
                };
                service.RequestOperation("B", op2);
            };
            registerop.OnFail += delegate(Operation op)
            {
                Log <AService> .Logger.ErrorFormat("cannot find LocationService or register failed : {0}", registerop.Category);

                service.Dispose();
            };
            thread.Enqueue(Job.Create <string, Register>(new Action <string, Register>(service.RequestOperation), typeof(LocationService).FullName, registerop));
        }
コード例 #9
0
        public static void Schedule(JobProcessor thread, IJob job, int interval, bool instant)
        {
            ScheduleRepeater @object = new ScheduleRepeater
            {
                thread   = thread,
                job      = job,
                interval = interval
            };

            if (instant)
            {
                thread.Enqueue(Job.Create(new Action(@object.Repeat)));
                return;
            }
            Scheduler.Schedule(thread, Job.Create(new Action(@object.Repeat)), interval);
        }
コード例 #10
0
ファイル: ServiceInvoker.cs プロジェクト: ratiel/Vindictus
        public static void StartService(string ip, string portstr, Service service, bool bUsePerfLog)
        {
            int       port      = int.Parse(portstr);
            IPAddress ipaddress = null;

            foreach (IPAddress ipaddress2 in Dns.GetHostAddresses(ip))
            {
                if (ipaddress2.AddressFamily == AddressFamily.InterNetwork)
                {
                    ipaddress = ipaddress2;
                    break;
                }
            }
            if (ipaddress == null)
            {
                Log <ServiceInvoker> .Logger.ErrorFormat("cannot resolve IPv4 address for hostname [{0}]", ip);

                return;
            }
            IPEndPoint arg = new IPEndPoint(ipaddress, port);

            if (FeatureMatrix.IsEnable("FeatureMatrixSyncService"))
            {
                FeatureMatrix.OverrideFeature(EventLoader.GetStartEventList());
            }
            Type typeFromHandle = typeof(UpdateFeatureMatrix);
            Func <Operation, OperationProcessor> func = (Operation op) => new UpdateFeatureMatrixProcessor(service, op as UpdateFeatureMatrix);
            MethodInfo method = service.GetType().GetMethod("RegisterProcessor", BindingFlags.Instance | BindingFlags.NonPublic);

            method.Invoke(service, new object[]
            {
                typeFromHandle,
                func
            });
            JobProcessor jobProcessor = new JobProcessor();

            service.Initialize(jobProcessor);
            UnifiedNetwork.LocationService.LookUp @object = new UnifiedNetwork.LocationService.LookUp(service);
            jobProcessor.Start();
            service.AddBootStep();
            jobProcessor.Enqueue(Job.Create <IPEndPoint>(new Action <IPEndPoint>(@object.StartService), arg));
            if (bUsePerfLog)
            {
                PerformanceLogger performanceLogger = new PerformanceLogger(service, 300000);
                performanceLogger.Start();
            }
        }
コード例 #11
0
 private void StartPartitionMove(int curCount)
 {
     if (this.startCount != curCount)
     {
         return;
     }
     foreach (MockClient mockClient in this.clients.Values)
     {
         JobProcessor boundThread = this.thread;
         if (mockClient.Player.BoundThread != null)
         {
             boundThread = mockClient.Player.BoundThread;
         }
         boundThread.Enqueue(Job.Create(new Action(mockClient.PartitionMove)));
     }
     Scheduler.Schedule(this.thread, Job.Create <int>(new Action <int>(this.StartPartitionMove), curCount), (int)(this.PartitionMoveRatio * 1000.0));
 }
コード例 #12
0
        protected void RequestOperation(IPEndPoint location, Operation op)
        {
            if (location == null)
            {
                JobProcessor.Current.Enqueue(Job.Create(new Action(op.IssueFailEvent)));
                return;
            }
            JobProcessor currentProcessor = JobProcessor.Current;

            this.ConnectToIP(location, delegate(Peer peer)
            {
                if (peer == null)
                {
                    currentProcessor.Enqueue(Job.Create(new Action(op.IssueFailEvent)));
                    return;
                }
                this.RequestOperation(peer, op);
            });
        }
コード例 #13
0
        private void OnPacketReceive(object sender, EventArgs <ArraySegment <byte> > e)
        {
            //Console.WriteLine("Received packet");
            jp.Enqueue(Job.Create(() =>
            {
                Packet p = new Packet(e.Value);

                if (firstMsg)
                {
                    firstMsg = false;
                    Console.WriteLine("Received TypeConverter");
                    ProcessTypeConverter(p);
                }
                else
                {
                    Console.WriteLine("Received {0}", classNames[p.CategoryId]);
                    mf.Handle(p, this);
                }
            }));
        }
コード例 #14
0
ファイル: ReportService.cs プロジェクト: ratiel/Vindictus
        public static void StartService(string ip, string portstr)
        {
            int port = int.Parse(portstr);

            IPAddress[] hostAddresses = Dns.GetHostAddresses(ip);
            if (hostAddresses.Length == 0)
            {
                Log <Service> .Logger.ErrorFormat("cannot find host [{0}]", ip);

                return;
            }
            IPAddress     address       = hostAddresses[new Random().Next(hostAddresses.Length - 1)];
            IPEndPoint    arg           = new IPEndPoint(address, port);
            ReportService reportService = new ReportService();
            JobProcessor  jobProcessor  = new JobProcessor();

            reportService.Initialize(jobProcessor, (int)Settings.Default.ReportServiceListenPort);
            UnifiedNetwork.LocationService.LookUp @object = new UnifiedNetwork.LocationService.LookUp(reportService);
            jobProcessor.Start();
            jobProcessor.Enqueue(Job.Create <IPEndPoint>(new Action <IPEndPoint>(@object.StartService), arg));
        }
コード例 #15
0
ファイル: AService.cs プロジェクト: ratiel/Vindictus
        public static void StartService()
        {
            try
            {
                AService     service = new AService();
                JobProcessor thread  = new JobProcessor();
                thread.ExceptionOccur += delegate(object sender, EventArgs <Exception> e)
                {
                    Log <AService> .Logger.Error("StartService", e.Value);
                };
                service.Initialize(thread);
                thread.Start();
                Register registerop = new Register(typeof(AService));
                registerop.OnComplete += delegate(Operation op)
                {
                    Log <AService> .Logger.DebugFormat("{0} registered on {1} : port {2}", registerop.Category, registerop.ID, registerop.Port);

                    service.ID     = registerop.ID;
                    service.Suffix = registerop.Suffix;
                    service.Start(registerop.Port);
                    Action <int>   testRequest = null;
                    Entity         entity      = new Entity(5L, "A");
                    IEntityProxy[] connections = new IEntityProxy[5];
                    for (int j = 0; j < 1; j++)
                    {
                        connections[j] = service.Connect(entity, new Location
                        {
                            ID       = (long)j,
                            Category = "B"
                        });
                    }
                    testRequest = delegate(int i)
                    {
                        TestOp op2 = new TestOp
                        {
                            Param = i
                        };
                        op2.OnComplete += delegate(Operation op3)
                        {
                            Log <AService> .Logger.DebugFormat("result : {0}", op2.ResultMessage.Value);

                            Scheduler.Schedule(thread, Job.Create <int>(testRequest, i + 1), 1000);
                        };
                        op2.OnFail += delegate(Operation op3)
                        {
                            Log <AService> .Logger.DebugFormat("TestOp Failed...", new object[0]);
                        };
                        connections[0].RequestOperation(op2);
                    };
                    Scheduler.Schedule(thread, Job.Create <int>(testRequest, 0), 1000);
                };
                registerop.OnFail += delegate(Operation op)
                {
                    Log <AService> .Logger.ErrorFormat("cannot find LocationService or register failed : {0}", registerop.Category);

                    service.Dispose();
                };
                thread.Enqueue(Job.Create <string, Register>(new Action <string, Register>(service.RequestOperation), typeof(UnifiedNetwork.LocationService.LookUp).FullName, registerop));
            }
            catch (Exception ex)
            {
                Log <AService> .Logger.Error("StartService", ex);
            }
        }