Example #1
0
        public void Model_TrySubmitForm_ValidatingEventHandlerFails_InvalidResult()
        {
            var validatingRisen = false;

            SitefinityEventHandler <IFormValidatingEvent> validatingHandler = (IFormValidatingEvent @event) =>
            {
                validatingRisen = true;
                throw new ValidationException("Not valid");
            };

            EventHub.Subscribe <IFormValidatingEvent>(validatingHandler);

            try
            {
                var model = new FormModel();
                model.FormId = FormEventsTests.formId;

                var values = new NameValueCollection();
                values.Add(FormEventsTests.FieldName, "text");

                var result = model.TrySubmitForm(new System.Web.Mvc.FormCollection(values), null, string.Empty);

                Assert.IsTrue(validatingRisen, "Form Validating event was not risen.");
                Assert.AreEqual(SubmitStatus.InvalidEntry, result, "Form was not invalidated via the validating event handler.");
            }
            finally
            {
                EventHub.Unsubscribe <IFormValidatingEvent>(validatingHandler);
            }
        }
Example #2
0
 public void Disconnected(EventHub eventHub, CancellationToken token)
 {
     if (eventHub.reconnectCount == 1)
     {
         logger.Warn($"Channel {eventHub.Channel.Name} detected disconnect on event hub {eventHub} ({eventHub.Url})");
     }
     Task.Run(async() =>
     {
         await Task.Delay(500, token).ConfigureAwait(false);
         try
         {
             if (eventHub.TransactionContext == null)
             {
                 logger.Warn($"{ToString()} reconnect failed with no user context");
             }
             else
             {
                 await eventHub.ConnectAsync(eventHub.TransactionContext, true, token).ConfigureAwait(false);
             }
         }
         catch (Exception e)
         {
             logger.Warn($"Failed {ToString()} to reconnect. {e.Message}");
         }
     }, token);
 }
        private async void btnSend_Click(object sender, EventArgs e)
        {
            btnSend.Enabled = false;
            var partitionKey = textPartitionKey.Text;

            OutputStatus("Sending message...");
            try
            {
                var eventData = CreateEventData();
                if (!String.IsNullOrEmpty(partitionKey))
                {
                    await EventHub.SendAsync(eventData, partitionKey);
                }
                else
                {
                    await EventHub.SendAsync(eventData);
                }
                OutputStatus("Message sent.");
            }
            catch (Exception ex)
            {
                OutputStatus($"ERROR! {ex.Message}");
            }
            finally
            {
                btnSend.Enabled = true;
            }
        }
Example #4
0
        public void Controller_PostIndex_RaisesBeforeAction()
        {
            bool beforeActionRisen = false;
            SitefinityEventHandler <BeforeFormActionEvent> beforeActionHandler = (BeforeFormActionEvent @event) =>
            {
                beforeActionRisen = true;
            };

            try
            {
                EventHub.Subscribe <BeforeFormActionEvent>(beforeActionHandler);

                var model = new FormModel();
                model.FormId = FormEventsTests.formId;

                var formController = new FormController();
                formController.Model = model;

                var values = new NameValueCollection();
                values.Add(FormEventsTests.FieldName, "text");
                formController.Index(new System.Web.Mvc.FormCollection(values));

                Assert.IsTrue(beforeActionRisen, "Before Form Action event was not risen.");
            }
            finally
            {
                EventHub.Unsubscribe <BeforeFormActionEvent>(beforeActionHandler);
            }
        }
 public static void AssemblyCleanup()
 {
     _iisExpress.Dispose();
     // Executes once after the test run. (Optional)
     Console.WriteLine("CredentialFixture: Disposing CredentialFixture");
     EventHub.ClearListeners();
 }
Example #6
0
        public void Setup(GameSetting gameSetting)
        {
            EventHub.Bind <EventTouchMoved>(OnTouchMoved);
            EventHub.Bind <EventPedestalDestroy>(OnPedestalDestroyed);

            _canInteract = false;

            MeshRenderer propMeshRenderer = _propInstance.GetComponent <MeshRenderer>();

            _propHeight       = propMeshRenderer.bounds.size.y;
            _propBottomHeight = -_propHeight * 2;

            float     propHeight     = _propInstance.GetComponent <MeshRenderer>().bounds.size.y;
            Transform propBackBuffer = Instantiate(_propInstance, new Vector3(0, -propHeight * 2f, 0), Quaternion.identity, transform);

            propBackBuffer.localScale = new Vector3(1f, -_propInstance.localScale.y, 1f);

            _props = new List <Transform>();
            _props.Add(_propInstance);
            _props.Add(propBackBuffer);

            _platformAngle = 0;

            _pedestalPool   = new PedestalPool(this.transform, _pedestalePrefabs);
            _pedestalLayers = new List <PedestalLayer>();
            _platformRule   = new SimplePlatformRule();

            _genericPool = new GenericGOPool();

            _gameSetting = gameSetting;
            RecycleOldPedestales();
            AddNewPedestales();
        }
Example #7
0
        public void TestUploadAttendanceHandlerOk()
        {
            var bundle = new Bundle(new SqliteConnector(), _mock.Object);
            var hub    = new EventHub(bundle.Database);

            hub.Subscribe(EventType.AttTransactionEx, new UploadAttendanceHandler(bundle));

            var attendance = new AttendanceLog("2", 1, 1, 2018, 1, 13, 12, 11, 30, 1, 1, "gate01", DeviceType.OnlyIn);

            hub.PublishAsync(new EventMessage(EventType.AttTransactionEx, attendance)).GetAwaiter().GetResult();

            Thread.Sleep(20000);

            var results = bundle.Database.QueryScalar(
                "select count(*) from queue where refer_id=@refer_id",
                new Dictionary <string, object>
            {
                { "@refer_id", attendance.Id }
            });

            var count = (long)results;

            Assert.IsTrue(count == 0);

            results = bundle.Database.QueryScalar(
                "select sync from attendance_logs where id=@id",
                new Dictionary <string, object>
            {
                { "@id", attendance.Id }
            });
            var sync = Convert.ToInt32(results);

            Assert.IsTrue(sync == 1);
        }
Example #8
0
        private void Bootstrapper_Initialized(object sender, Telerik.Sitefinity.Data.ExecutedEventArgs e)
        {
            //Telerik.Microsoft.Practices.EnterpriseLibrary.Caching.ICacheManager cazy = SystemManager.GetCacheManager(CacheManagerInstance.Configuration);


            if (e.CommandName == "Bootstrapped")
            {
                PublishingSystemFactory.UnregisterPipe(SearchIndexOutboundPipe.PipeName);
                PublishingSystemFactory.RegisterPipe(SearchIndexOutboundPipe.PipeName, typeof(ResourceLibraryOutboundPipe));
                //use UnauthorizedPageAccessEvent
                EventHub.Subscribe <IUnauthorizedPageAccessEvent>(new Telerik.Sitefinity.Services.Events.SitefinityEventHandler <IUnauthorizedPageAccessEvent>(OnUnauthorizedAccess));

                /*
                 * EventHub.Subscribe<IFormFieldValidatingEvent>(FormFileUploadFieldValidation);*/
                EventHub.Subscribe <IContextOperationEvent>(ContextOperationEvent);
            }

            if (e.CommandName == "RegisterRoutes")
            {
                RegisterRoutes(RouteTable.Routes);
                //ReplaceDefaultRoute(e.Data as IQueryable<RouteBase>);
                //SystemManager.RegisterServiceStackPlugin(new );
                //SystemManager.RegisterServiceStackPlugin(new MatrixGroup.Implementation.Services.Plugins.ServiceFeaturePlugin());
            }
        }
Example #9
0
        public override async Task Restart()
        {
            try
            {
                if (!Restarting)
                {
                    Restarting = true;

                    Logger.LogWarning($"Restarting server {Name} on {IpAddress}:{Port}.");

                    if (!Stopped)
                    {
                        Listener?.Stop();
                        await Timeout(2);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Exception while restarting server {Name} at {IpAddress}:{Port}");
                EventHub.Publish(new StartMessage(UniqueIdentifier, true));
            }

            await base.Restart();
        }
Example #10
0
        public void TestUploadAttendanceHandlerFailedToMessage()
        {
            var bundle = new Bundle(new SqliteConnector(), _mock.Object);
            var hub    = new EventHub(bundle.Database);

            hub.Subscribe(EventType.AttTransactionEx, new UploadAttendanceHandler(bundle));

            var attendance = new AttendanceLog("3", 1, 1, 2018, 1, 14, 12, 11, 30, 1, 1, "gate01", DeviceType.OnlyIn);

            hub.PublishAsync(new EventMessage(EventType.AttTransactionEx, attendance)).GetAwaiter().GetResult();

            Thread.Sleep(15000);

            var result = bundle.Database.QueryScalar(
                "select count(*) from failed_queue;", null);
            var count = (long)result;

            Assert.IsTrue(count > 0);

            Thread.Sleep(1000);
            result = bundle.Database.QueryScalar(
                "select count(*) from attendance_logs where id=@id",
                new Dictionary <string, object>
            {
                { "@id", attendance.Id }
            });
            count = (long)result;
            Assert.IsTrue(count == 0);
        }
Example #11
0
        public override async Task <bool> Run()
        {
            try
            {
                await SpawnProcess().ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                Stopped = true;
                Logger.LogInformation($"Server {Name} on {IpAddress}:{Port} has shut down.  Attempting to restart...");
                StopToken?.Dispose();

                StopToken = new CancellationTokenSource();
                EventHub.Publish(new StartMessage(UniqueIdentifier, true));
                return(false);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Thread running server {Name} on {IpAddress}:{Port} has crashed.  Attempting to restart it...");
                OnError(ex);
                return(false);
            }

            return(true);
        }
Example #12
0
        private static ICancellableEvent PubishSubscribingEvent(Message request, IClient client)
        {
            ICancellableEvent subscribingEvent = new SubscribingEvent(client, request.subscription);

            EventHub.Publish(subscribingEvent);
            return(subscribingEvent);
        }
Example #13
0
        public void GlobalEvents()
        {
            EventHub testHub = new EventHub();
            testHub.RegisterEventProcessor("Test.Var1.Var2", ehd => { ((Stack<string>)ehd.Data).Push("mod1"); return ehd.Data; }, "mod1");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack<string>)ehd.Data).Push("mod2"); return ehd.Data; }, "mod2");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack<string>)ehd.Data).Push("mod4"); return ehd.Data; }, "mod4");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack<string>)ehd.Data).Push("mod3"); return ehd.Data; }, "md3",
                new OrderConstraint("md3", ConstraintType.ItemsAfter, "mod4"));
            testHub.RegisterEventProcessor("Test", ehd => { ((Stack<string>)ehd.Data).Push("mod5"); return ehd.Data; }, "mod5",
                new OrderConstraint("mod5", "mod4"));
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack<string>)ehd.Data).Push("mod25"); return ehd.Data; }, "mod25",
                new OrderConstraint("mod25", new string[] { "mod2" }, new string[] { "md3", "mod4" }));
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack<string>)ehd.Data).Push("mod2.x"); return ehd.Data; }, "mod2.x");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack<string>)ehd.Data).Push("mod2.x.y"); return ehd.Data; }, "mod2.x.y");

            Stack<string> callOrder;
            List<string> callList;

            callOrder = (Stack<string>)testHub.ProcessEvent("Test", this, new Stack<string>()).Data;
            Assert.IsTrue(callOrder.SequenceEqual(new string[] { "mod5" }));

            callOrder = (Stack<string>)testHub.ProcessEvent("Test.Var1", this, new Stack<string>()).Data;
            callList = callOrder.Reverse().ToList();
            Assert.IsTrue(CheckOrderA(callList), "Test.Var1 event sequencing error");

            callOrder = (Stack<string>)testHub.ProcessEvent("Test.Var1.Var2", this, new Stack<string>()).Data;
            callList = callOrder.Reverse().ToList();
            Assert.IsTrue(CheckOrderA(callList));
            Assert.IsTrue(callList.Contains("mod1"));
        }
        private async void btnDisconnect_Click(object sender, EventArgs e)
        {
            try
            {
                btnDisconnect.Enabled = false;
                OutputStatus("Disconnecting...");

                if (ReaderEnabled)
                {
                    await ProcessorHost.UnregisterEventProcessorAsync();

                    ReaderEnabled = false;
                }

                if (SenderEnabled)
                {
                    await EventHub.CloseAsync();

                    SenderEnabled = false;
                }

                OutputStatus("Disconnected.");
            }
            catch (Exception ex)
            {
                OutputStatus($"ERROR! {ex.Message}");
            }
            finally
            {
                btnConnect.Enabled    = true;
                btnDisconnect.Enabled = false;
            }
        }
        /**
         * Record transactions event.
         *
         * @param transactionEvent
         * @return True if transactions have been seen on all eventing peers and eventhubs.
         */
        public bool EventReceived(TransactionEvent transactionEvent)
        {
            sweepTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + DELTA_SWEEP; //seen activity keep it active.
            Peer     peer     = transactionEvent.Peer;
            EventHub eventHub = transactionEvent.EventHub;

            if (peer != null && !peers.Contains(peer))
            {
                return(false);
            }
            if (eventHub != null && !eventHubs.Contains(eventHub))
            {
                return(false);
            }
            if (failFast && !transactionEvent.IsValid)
            {
                return(true);
            }
            if (peer != null)
            {
                nOfEvents.Seen(peer);
                intlogger.Debug($"Channel {channel.Name} seen transaction event {txID} for peer {peer}");
            }
            else if (null != eventHub)
            {
                nOfEvents.Seen(eventHub);
                intlogger.Debug($"Channel {channel.Name} seen transaction event {txID} for eventHub {eventHub}");
            }
            else
            {
                intlogger.Error($"Channel {channel.Name} seen transaction event {txID} with no associated peer or eventhub");
            }

            return(nOfEvents.Ready);
        }
Example #16
0
        public void EventHub_PostAndSubscribeOverThread_EventHandled()
        {
            // arrange
            var publishThreadId = -1;

            var eventHub             = new EventHub();
            var subscriber1          = new object();
            var subscriberThreadId   = Thread.CurrentThread.ManagedThreadId;
            var subscribedThreadId   = -2;
            var subscriber1Triggered = false;
            var subscriber1Action    = new Action <ItemChangedEvent>(itemChangedEvent =>
            {
                subscribedThreadId   = Thread.CurrentThread.ManagedThreadId;
                subscriber1Triggered = true;
            });


            // act
            eventHub.Subscribe(subscriber1, subscriber1Action);

            Task.Run(() =>
            {
                publishThreadId = Thread.CurrentThread.ManagedThreadId;
                eventHub.Publish(new ItemChangedEvent());
            }).Wait();


            // assert
            Assert.AreEqual(true, subscriber1Triggered);
            Assert.AreEqual(publishThreadId, subscribedThreadId);
            Assert.AreNotEqual(publishThreadId, subscriberThreadId);
        }
        private void Main_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (ReaderEnabled)
            {
                try
                {
                    Task.Run(() => ProcessorHost.UnregisterEventProcessorAsync());
                }
                catch
                {
                    // suppress error and close app
                }
            }

            if (SenderEnabled)
            {
                try
                {
                    Task.Run(() => EventHub.CloseAsync());
                }
                catch
                {
                    // suppress error and close app
                }
            }

            try
            {
                Trace.Listeners.Remove(EventHubTrace);
            }
            catch
            {
                // suppress error and close app
            }
        }
Example #18
0
        /// <summary>
        /// Uninitializes this instance.
        /// </summary>
        public static void Uninitialize()
        {
            EventHub.Unsubscribe <IScriptsRegisteringEvent>(Initializer.RegisteringFormScriptsHandler);
            Bootstrapper.Initialized -= Initializer.Bootstrapper_Initialized;

            Initializer.UnregisterTemplatableControl();
        }
Example #19
0
    // Start is called before the first frame update
    void Start()
    {
        // get event hub
        this.ehub = GameObject.Find("EventHub").gameObject.GetComponent <EventHub>();

        // get robot sprite
        this.rg = GameObject.Find("RobotGraphics");

        // get access to the pathfinder
        this.pathfinder = this.gameObject.GetComponent <AIDestinationSetter>();

        // setup each individual program that the robot can run
        this.packageRetrieve = GameObject.Find("RetrievePackageProgram").gameObject.GetComponent <RetrievePackageProgram>();
        this.vacuum          = GameObject.Find("VacuumProgram").gameObject.GetComponent <VacuumProgram>();
        this.coffee          = GameObject.Find("MakeCoffeeProgram").gameObject.GetComponent <MakeCoffeeProgram>();

        // register each individual trigger
        this.triggers = new Trigger();
        this.triggers.RegisterActionWithTrigger("PackageArrives", this.packageRetrieve);
        this.triggers.RegisterActionWithTrigger("VacuumTime", this.vacuum);
        this.triggers.RegisterActionWithTrigger("MakeCoffeeTime", this.coffee);

        this.goals   = null;
        this.goalIdx = -1;
    }
Example #20
0
        public void GlobalEvents()
        {
            EventHub testHub = new EventHub();

            testHub.RegisterEventProcessor("Test.Var1.Var2", ehd => { ((Stack <string>)ehd.Data).Push("mod1"); return(ehd.Data); }, "mod1");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack <string>)ehd.Data).Push("mod2"); return(ehd.Data); }, "mod2");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack <string>)ehd.Data).Push("mod4"); return(ehd.Data); }, "mod4");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack <string>)ehd.Data).Push("mod3"); return(ehd.Data); }, "md3",
                                           new OrderConstraint("md3", ConstraintType.ItemsAfter, "mod4"));
            testHub.RegisterEventProcessor("Test", ehd => { ((Stack <string>)ehd.Data).Push("mod5"); return(ehd.Data); }, "mod5",
                                           new OrderConstraint("mod5", "mod4"));
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack <string>)ehd.Data).Push("mod25"); return(ehd.Data); }, "mod25",
                                           new OrderConstraint("mod25", new string[] { "mod2" }, new string[] { "md3", "mod4" }));
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack <string>)ehd.Data).Push("mod2.x"); return(ehd.Data); }, "mod2.x");
            testHub.RegisterEventProcessor("Test.Var1", ehd => { ((Stack <string>)ehd.Data).Push("mod2.x.y"); return(ehd.Data); }, "mod2.x.y");

            Stack <string> callOrder;
            List <string>  callList;

            callOrder = (Stack <string>)testHub.ProcessEvent("Test", this, new Stack <string>()).Data;
            Assert.IsTrue(callOrder.SequenceEqual(new string[] { "mod5" }));

            callOrder = (Stack <string>)testHub.ProcessEvent("Test.Var1", this, new Stack <string>()).Data;
            callList  = callOrder.Reverse().ToList();
            Assert.IsTrue(CheckOrderA(callList), "Test.Var1 event sequencing error");

            callOrder = (Stack <string>)testHub.ProcessEvent("Test.Var1.Var2", this, new Stack <string>()).Data;
            callList  = callOrder.Reverse().ToList();
            Assert.IsTrue(CheckOrderA(callList));
            Assert.IsTrue(callList.Contains("mod1"));
        }
Example #21
0
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            // Create branch to the CometMiddleware.
            // All requests ending in comet/45.0 will follow this branch.
            app.MapWhen(
                context => context.Request.Path.ToString().Contains("/comet/45.0"),
                appBranch => {
                // ... optionally add more middleware to this branch
                appBranch.UseCometMiddleware();    //formerly an 'HttpHandler'
            });



            EventHub.Subscribe <HandshakingEvent>(app.ApplicationServices.GetService <HandshakeAuthenticator>().CheckHandshake);
            EventHub.Subscribe <PublishingEvent>(app.ApplicationServices.GetService <BadLanguageBlocker>().CheckMessage);
            EventHub.Subscribe <SubscribingEvent>(app.ApplicationServices.GetService <SubscriptionChecker>().CheckSubscription);
            EventHub.Subscribe <PublishingEvent>("/service/whisper", app.ApplicationServices.GetService <Whisperer>().SendWhisper);

            app.UseFileServer();
        }
Example #22
0
        void Bootstrapper_Initialized(object sender, ExecutedEventArgs e)
        {
            // Register any Resource classes
            Res.RegisterResource <SocialLinkResources>();
            Res.RegisterResource <JobSearchResources>();
            Res.RegisterResource <JobSearchResultsResources>();
            Res.RegisterResource <JobAlertResources>();
            Res.RegisterResource <JobDetailsResources>();
            Res.RegisterResource <LoginStatusExtendedResources>();
            Res.RegisterResource <UsersListExtendedResources>();
            Res.RegisterResource <MapsResources>();
            Res.RegisterResource <JobApplicationResources>();
            Res.RegisterResource <MemberSavedJobsResources>();
            Res.RegisterResource <MemberAppliedJobsResources>();
            Res.RegisterResource <ConsultantResources>();
            Res.RegisterResource <SocialHandlerResources>();
            Res.RegisterResource <JXTNextResumeResources>();

            if (e.CommandName == "Bootstrapped")
            {
                GlobalFilters.Filters.Add(new SocialShareAttribute());
                FrontendModule.Current.DependencyResolver.Rebind <IDynamicContentModel>().To <CustomDynamicContentModel>();
                Config.RegisterSection <InstagramConfig>();
                EventHub.Subscribe <IUnauthorizedPageAccessEvent>(new Telerik.Sitefinity.Services.Events.SitefinityEventHandler <IUnauthorizedPageAccessEvent>(OnUnauthorizedAccess));
            }
        }
Example #23
0
        public async Task GetAllEventhubs()
        {
            //create two eventhubs
            string eventhubName1 = Recording.GenerateAssetName("eventhub1");
            string eventhubName2 = Recording.GenerateAssetName("eventhub2");

            _ = (await _eventHubCollection.CreateOrUpdateAsync(true, eventhubName1, new EventHubData())).Value;
            _ = (await _eventHubCollection.CreateOrUpdateAsync(true, eventhubName2, new EventHubData())).Value;

            //validate
            int      count     = 0;
            EventHub eventHub1 = null;
            EventHub eventHub2 = null;

            await foreach (EventHub eventHub in _eventHubCollection.GetAllAsync())
            {
                count++;
                if (eventHub.Id.Name == eventhubName1)
                {
                    eventHub1 = eventHub;
                }
                if (eventHub.Id.Name == eventhubName2)
                {
                    eventHub2 = eventHub;
                }
            }
            Assert.AreEqual(count, 2);
            Assert.NotNull(eventHub1);
            Assert.NotNull(eventHub2);
        }
Example #24
0
 public async Task Create()
 {
     #region Snippet:Managing_EventHubs_CreateEventHub
     string   eventhubName = "myEventhub";
     EventHub eventHub     = (await eventHubCollection.CreateOrUpdateAsync(WaitUntil.Completed, eventhubName, new EventHubData())).Value;
     #endregion
 }
Example #25
0
        public async Task Get()
        {
            #region Snippet:Managing_EventHubs_GetEventHub
            EventHub eventHub = await eventHubCollection.GetAsync("myEventHub");

            #endregion
        }
Example #26
0
        private async Task SendAsync(Memory <byte> packet)
        {
            try
            {
                var safeStream = Stream.Synchronized(Sender.GetStream());
                var writer     = new BinaryWriter(safeStream);
                writer.Write(packet.ToArray());

                if (!await WaitForAckAsync(safeStream))
                {
                    Logger.LogWarning($"Server has not responded with an ack.  The last message sent by client {Name} may have been lost on {IpAddress}:{Port}.");
                }
            }
            catch (ObjectDisposedException ode)
            {
                Logger.LogError(ode, $"The client {Name} socket was disposed before the Send operation completed to {IpAddress}:{Port}");
            }
            catch (OperationCanceledException)
            {
                StopToken?.Dispose();
                StopToken = new CancellationTokenSource();
                EventHub.Publish(new StartMessage(UniqueIdentifier, true));
            }
            catch (SocketException sox)
            {
                Logger.LogError(sox, $"Socket Exception on Client {Name} sending on {IpAddress}:{Port}.");
            }
            catch (Exception ex)
            {
                Logger.LogError($"Client {Name} failed to Send to host from {IpAddress}:{Port}.");
                OnError(ex);
            }
        }
        /// <summary>
        ///     Performs the core execution
        /// </summary>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>A task that when complete will signal the completion of this work</returns>
        /// <inheritdoc />
        public Task Process(CancellationToken cancellationToken)
        {
            return(EventHub.Get <ExcelReportComplete>().ForEachAsync(message =>
            {
                // todo: fix
                var shouldUpload = false; // SettingsRepository.GetBool(UploadExcelToS3, true);
                if (!shouldUpload)
                {
                    Log.Information("Skipping upload excel report to s3. Is the setting {UploadExcelToS3} set to true?", UploadExcelToS3);
                    return;
                }

                // note: this looks for ~/.aws/credentials for a profile named default
                // see https://docs.aws.amazon.com/AmazonS3/latest/dev/walkthrough1.html#walkthrough1-add-users
                // todo: move this out to a decoupled component
                BasicAWSCredentials creds;
                try
                {
                    var accessKey = ""; // SettingsRepository.Get("aws-access-key-id");
                    var secretKey = ""; // SettingsRepository.Get("aws-secret-key");
                    creds = new BasicAWSCredentials(accessKey, secretKey);
                }
                catch (Exception e)
                {
                    Log.Error("Unable to create credentials for S3 client: {Message}", e.Message);
                    return;
                }

                using (var client = new AmazonS3Client(creds, RegionEndpoint.USEast1))
                    using (var fs = File.OpenRead(message.ReportFile))
                    {
                        var putReportRequest = new PutObjectRequest
                        {
                            // todo: this sould be a setting
                            BucketName = "", // SettingsRepository.Get(ExcelBucketId),
                            Key = message.ReportFile,
                            InputStream = fs
                        };

                        // todo: make a service
                        Log.Information("Attempting to upload report to S3");
                        try
                        {
                            var putObjectResponse = client.PutObject(putReportRequest);
                            if (putObjectResponse.HttpStatusCode == HttpStatusCode.OK)
                            {
                                Log.Information($"Upload of {message.ReportFile} was successful");
                            }
                            else
                            {
                                throw new ApplicationException("Unknown error");
                            }
                        }
                        catch (Exception e)
                        {
                            Log.Error(e, "Unable to upload {ReportFile} to S3: {Message}", message.ReportFile, e.Message);
                        }
                    }
            }, cancellationToken));
        }
Example #28
0
        public override async Task Restart()
        {
            try
            {
                if (!Restarting)
                {
                    Restarting = true;

                    Logger.LogWarning($"Restarting client {Name} responding on {IpAddress}:{Port}.");

                    if (!Stopped)
                    {
                        Sender?.Close();
                        await Timeout(2);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Client {Name} has thrown an exception while restarting from {IpAddress}:{Port}.");
                EventHub.Publish(new StartMessage(UniqueIdentifier, true));
            }

            await base.Restart();
        }
Example #29
0
        public void Wait_For_The_Observers_To_Finish_After_Analyzers_Finish()
        {
            // arrange
            var sw     = Stopwatch.StartNew();
            var engine = new Engine();

            engine.AnalyzerTaskFactory = new AnalyzerTaskFactory();
            var eventHub = new EventHub();
            var analyzer = new DummyAnalyzer();
            var observer = new DummyAnalysisObserver();

            engine.Analyzers         = new[] { analyzer };
            engine.AnalysisObservers = new[] { observer };
            engine.EventHub          = eventHub;
            analyzer.EventHub        = eventHub;
            observer.EventHub        = eventHub;

            // act
            var task = engine.Process();

            task.Wait();

            // assert
            sw.ElapsedMilliseconds.Should().BeLessThan(2000);
            task.IsCompleted.Should().BeTrue();
            task.IsFaulted.Should().BeFalse();
        }
Example #30
0
        IEnumerator LoadScene(string sceneName)
        {
            Debug.Log($"[Client] <b>Loading level</b> '<i>{sceneName}</i>'");

            EventHub <StartedLoading> .Emit(new StartedLoading());

            // Cleanup
            currentReplicaPossess = ReplicaId.Invalid;

            Client.replicaManager.Reset();

            if (sceneHandle.IsValid())
            {
                yield return(Addressables.UnloadSceneAsync(sceneHandle));
            }

            // New map
#if !UNITY_EDITOR
            sceneHandle            = Addressables.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
            sceneHandle.Completed += ctx => {
                SendLoadSceneDone();
                EventHub <EndedLoading> .Emit(new EndedLoading());
            };
#else
            SendLoadSceneDone();
            EventHub <EndedLoading> .Emit(new EndedLoading());
#endif
        }
Example #31
0
        /// <summary>
        /// Initializes and configurates the resources functionality.
        /// </summary>
        public void Initialize()
        {
            ObjectFactory.Container.RegisterType <IResourceResolverStrategy, ResourceResolverStrategy>(new ContainerControlledLifetimeManager());

            SystemManager.RegisterRoute(
                "ServerContext",
                new Route(
                    "Telerik.Sitefinity.Frontend/ServerContext.js",
                    new RouteHandler <ServerContextHandler>()),
                typeof(ResourcesInitializer).Assembly.GetName().Name,
                requireBasicAuthentication: false);

            ObjectFactory.Container.RegisterType <DialogBase, MvcControlTemplateEditor>(typeof(ControlTemplateEditor).Name);

            EventHub.Subscribe <IDataEvent>(this.HandleIDataEvent);

            var resourceClass   = typeof(InfrastructureResources);
            var resourceClassId = Res.GetResourceClassId(resourceClass);

            if (!ObjectFactory.IsTypeRegistered <InfrastructureResources>(resourceClassId))
            {
                Res.RegisterResource(resourceClass);
            }

            var clientComponentsResourcesClass   = typeof(ClientComponentsResources);
            var clientComponentsResourcesClassId = Res.GetResourceClassId(clientComponentsResourcesClass);

            if (!ObjectFactory.IsTypeRegistered <ClientComponentsResources>(clientComponentsResourcesClassId))
            {
                Res.RegisterResource(clientComponentsResourcesClass);
            }
        }
        public FirstPersonCamera(EventHub event_hub)
        {
            _event_hub = event_hub;
            _pressed_keys = new bool[(int)ControlKeys.NumControlKeys];
            _view = new Vector3(0, 0, 1);
            _up = new Vector3(0, 1, 0);

            _event_hub.OnKeyDownEvent += new EventHandler<KeyEventArgs>(_event_hub_OnKeyDownEvent);
            _event_hub.OnKeyUpEvent += new EventHandler<KeyEventArgs>(_event_hub_OnKeyUpEvent);

            _event_hub.OnMouseMoveEvent += new EventHandler<MouseEventArgs>(_event_hub_OnMouseMoveEvent);
            _event_hub.OnMouseLeaveEvent += new EventHandler<EventArgs>(_event_hub_OnMouseLeaveEvent);
            _event_hub.OnMouseDownEvent += new EventHandler<MouseEventArgs>(_event_hub_OnMouseDownEvent);
            _event_hub.OnMouseUpEvent += new EventHandler<MouseEventArgs>(_event_hub_OnMouseUpEvent);

            _timer = new Stopwatch();
            _timer.Start();
        }
Example #33
0
	public void InitGrid() {
		
		GameObject g;
		
		g = SafeFind("EventHub"); 
		EventHub = (EventHub)SafeComponent( g, "EventHub" );

		g = SafeFind("Game"); 
		GameLogic = (Game)SafeComponent( g, "Game" );

		g = SafeFind ("SoundManager");
		SoundManager = (SoundManager)SafeComponent (g, "SoundManager");

        //Player = GameObject.Find("Lokahi");
        Player = SafeFind("Lokahi");

		SpawnPoint = SafeFind("SpawnPoint");

		g = SafeFind ("Directional Light");
		DirectionalLight = (Light)SafeComponent (g, "Light");

		WinUI = SafeFind ("WinUI");
	}