Example #1
0
 public QueriesFactory(IErrorsInbox errorsInbox, IErrorsBacklog errorsBacklog, IErrorsBacklogReader errorsBacklogReader, IVisibilityPublisher visibilityPublisher, IVisibilityPersistor visibilityPersistor,
                       IBackendNotifier backendNotifier,
                       params Func <IBackendQuery>[] subscriptors)
 {
     _errorsInbox         = errorsInbox;
     _errorsBacklog       = errorsBacklog;
     _errorsBacklogReader = errorsBacklogReader;
     _visibilityPublisher = visibilityPublisher;
     _visibilityPersistor = visibilityPersistor;
     _backendNotifier     = backendNotifier;
     _subscriptors        = subscriptors;
 }
Example #2
0
        public FrontendBackendNotifier(string endpoint, IErrorsInbox errorsInbox, IVisibilityPersistor visibilityPublisher)
        {
            var connection = new HubConnection(endpoint)
            {
                Credentials = CredentialCache.DefaultCredentials
            };

            _proxy = connection.CreateHubProxy("relmah-backend");

            _proxy.On <ErrorPayload>("error", p => errorsInbox.Post(p));

            _proxy.On <Delta <Cluster> >("cluster", p =>
            {
                switch (p.Type)
                {
                case DeltaType.Added:   visibilityPublisher.AddCluster(p.Target.Name, true);    break;

                case DeltaType.Removed: visibilityPublisher.RemoveCluster(p.Target.Name, true); break;
                }
            });

            _proxy.On <Delta <Source> >("source", p =>
            {
                switch (p.Type)
                {
                case DeltaType.Added:   visibilityPublisher.AddSource(p.Target.SourceId, p.Target.Description, true); break;

                case DeltaType.Removed: visibilityPublisher.RemoveSource(p.Target.SourceId, true); break;
                }
            });

            _proxy.On <Delta <User> >("user", p =>
            {
                switch (p.Type)
                {
                case DeltaType.Added:   visibilityPublisher.AddUser(p.Target.Name, true); break;

                case DeltaType.Removed: visibilityPublisher.RemoveUser(p.Target.Name, true); break;
                }
            });

            _proxy.On <Delta <Relationship <Cluster, Source> > >("clusterSource", p =>
            {
                switch (p.Type)
                {
                case DeltaType.Added:   visibilityPublisher.AddSourceToCluster(p.Target.Primary.Name, p.Target.Secondary.SourceId, true); break;

                case DeltaType.Removed: visibilityPublisher.RemoveSourceFromCluster(p.Target.Primary.Name, p.Target.Secondary.SourceId, true); break;
                }
            });

            _proxy.On <Delta <Relationship <Cluster, User> > >("clusterUser", p =>
            {
                switch (p.Type)
                {
                case DeltaType.Added:   visibilityPublisher.AddUserToCluster(p.Target.Primary.Name, p.Target.Secondary.Name, true); break;

                case DeltaType.Removed: visibilityPublisher.RemoveUserFromCluster(p.Target.Primary.Name, p.Target.Secondary.Name, true); break;
                }
            });

            connection.Start().Wait();
        }
 public RandomSourceErrorsMiddleware(OwinMiddleware next, IErrorsInbox inbox, IVisibilityPersistor visibilityPersistor, string prefix)
     : base(next, inbox, prefix)
 {
     _visibilityPersistor = visibilityPersistor;
 }
Example #4
0
        public VisibilityMiddleware(OwinMiddleware next, IVisibilityPersistor updater, string prefix)
            : base(next)
        {
            Router.Build(builder => builder

                         .WithPrefix(prefix)

                         .ForRoute("clusters/{cluster}/sources/{source}", route => route
                                   .Get(async(environment, keys, _) =>
            {
                var cluster = await updater.GetCluster(keys["cluster"]);
                return(cluster.HasValue
                            ? cluster.Value.GetSource(keys["source"])
                            : null);
            })
                                   .Delete(async(environment, keys, _) =>
                                           await updater.RemoveSourceFromCluster(keys["cluster"], keys["source"]))
                                   )
                         .ForRoute("clusters/{cluster}/sources", route => route
                                   .Post(async(environment, keys, form) =>
                                         await updater.AddSourceToCluster(keys["cluster"], form["name"]))
                                   .Get(async(environment, keys, _) =>
            {
                var cluster = await updater.GetCluster(keys["cluster"]);
                return(cluster.HasValue
                            ? cluster.Value.Sources
                            : null);
            })
                                   )

                         //  This portion is "hacky" for now,
                         //  I'll have to make it cleaner when
                         //  I'll have more time for details.

                         //AD users
                         .ForRoute("clusters/{cluster}/users/{domain}/{user}", route => route
                                   .Get(async(environment, keys, _) =>
            {
                var cluster = await updater.GetCluster(keys["cluster"]);
                return(cluster.HasValue
                            ? cluster.Value.GetUser(string.Format(@"{0}\{1}", keys["domain"], keys["user"]))
                            : null);
            })
                                   .Delete(async(environment, keys, _) =>
                                           await updater.RemoveUserFromCluster(keys["cluster"], string.Format(@"{0}\{1}", keys["domain"], keys["user"])))
                                   )
                         //plain users
                         .ForRoute("clusters/{cluster}/users/{user}", route => route
                                   .Get(async(environment, keys, _) =>
            {
                var cluster = await updater.GetCluster(keys["cluster"]);
                return(cluster.HasValue
                            ? cluster.Value.GetUser(keys["user"])
                            : null);
            })
                                   .Delete(async(environment, keys, _) =>
                                           await updater.RemoveUserFromCluster(keys["cluster"], keys["user"]))
                                   )

                         .ForRoute("clusters/{cluster}/users", route => route
                                   .Post(async(environment, keys, form) =>
                                         await updater.AddUserToCluster(keys["cluster"], form["name"]))
                                   .Get(async(environment, keys, _) =>
            {
                var cluster = await updater.GetCluster(keys["cluster"]);
                return(cluster.HasValue
                            ? cluster.Value.Users
                            : null);
            })
                                   )

                         .ForRoute("clusters/{cluster}", route => route
                                   .Get(async(environment, keys, _) =>
                                        await updater.GetCluster(keys["cluster"]))
                                   .Delete(async(environment, keys, _) =>
                                           await updater.RemoveCluster(keys["cluster"]))
                                   )
                         .ForRoute("clusters", route => route
                                   .Post(async(environment, keys, form) =>
                                         await updater.AddCluster(form["name"]))
                                   .Get(async(environment, keys, _) =>
                                        await updater.GetClusters())
                                   )

                         .ForRoute("users/{user}", route => route
                                   .Get(async(environment, keys, _) =>
                                        await updater.GetUser(keys["user"]))
                                   .Delete(async(environment, keys, _) =>
                                           await updater.RemoveUser(keys["user"]))
                                   )
                         .ForRoute("users", route => route
                                   .Post(async(environment, keys, form) =>
                                         await updater.AddUser(form["name"]))
                                   .Get(async(environment, keys, _) =>
                                        await updater.GetUsers())
                                   )

                         .ForRoute("sources/{source}", route => route
                                   .Get(async(environment, keys, _) =>
                                        await updater.GetSource(keys["source"]))
                                   .Delete(async(environment, keys, _) =>
                                           await updater.RemoveSource(keys["source"]))
                                   )
                         .ForRoute("sources", route => route
                                   .Post(async(environment, keys, form) =>
                                         await updater.AddSource(form["name"], form["description"]))
                                   .Get(async(environment, keys, _) =>
                                        await updater.GetSources())
                                   )

                         );
        }