Exemple #1
0
        [Fact] // FAILS
        public void NotContainsWhenEmpty()
        {
            using (var store = GetDocumentStore())
            {
                using (var s = store.OpenSession())
                {
                    s.Store(new MyDoc {
                        DocArrayProp = new[] { 1, 2 }
                    });
                    s.Store(new MyDoc {
                        DocArrayProp = new int[0]
                    });
                    s.SaveChanges();
                }

                IndexCreation.CreateIndexes(new[] { new MyIndex() }, store);
                WaitForIndexing(store);

                using (var s = store.OpenSession())
                {
                    var results = s.Query <MyIndex.ReduceResult, MyIndex>().Where(d => !d.IndexArrayProp.Contains(1)).OfType <MyDoc>().ToArray();
                    Assert.Equal(1, results.Length); // FAILS HERE
                    Assert.Empty(results.Single().DocArrayProp);
                }
            }
        }
Exemple #2
0
        public void write_then_read_from_complex_entity_types()
        {
            using (EmbeddableDocumentStore documentStore = NewDocumentStore())
            {
                IndexCreation.CreateIndexes(typeof(QuestionWithVoteTotalIndex).Assembly, documentStore);

                string answerId = CreateEntities(documentStore);
                // Working
                using (IDocumentSession session = documentStore.OpenSession())
                {
                    AnswerEntity answerInfo = session.Query <Answer, Answers_ByAnswerEntity>()
                                              .Customize(x => x.WaitForNonStaleResultsAsOfNow())
                                              .Where(x => x.Id == answerId)
                                              .As <AnswerEntity>()
                                              .SingleOrDefault();
                    Assert.NotNull(answerInfo);
                    Assert.NotNull(answerInfo.Question);
                }
                // Failing
                using (IDocumentSession session = documentStore.OpenSession())
                {
                    AnswerVoteEntity[] votes = session.Query <AnswerVote, Votes_ByAnswerEntity>()
                                               .Customize(x => x.WaitForNonStaleResultsAsOfNow())
                                               .Where(x => x.AnswerId == answerId)
                                               .As <AnswerVoteEntity>()
                                               .ToArray();
                    Assert.NotNull(votes);
                    Assert.True(votes.Length == 2);
                    Assert.NotNull(votes[0].Answer);
                    Assert.True(votes[0].Answer.Id == answerId);
                    Assert.NotNull(votes[1].Answer);
                    Assert.True(votes[1].Answer.Id == answerId);
                }
            }
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Prepairing Database for sample");

            var url      = "http://localhost:8080";
            var database = "ravendb-dependency-injection";

            var store = new DocumentStore
            {
                Urls = new[] {
                    url
                },
                Database = database
            };

            store.Initialize();

            var doc = new DatabaseRecord(database);

            store.Maintenance.Server.Send(new CreateDatabaseOperation(doc));

            IndexCreation.CreateIndexes(typeof(Article_ByName).Assembly, store);

            using (BulkInsertOperation bulkInsert = store.BulkInsert())
            {
                for (int i = 0; i < 50; i++)
                {
                    bulkInsert.Store(new Article
                    {
                        Name = "Article #" + i
                    });
                }
            }
        }
Exemple #4
0
        private static void TryCreatingIndexesOrRedirectToErrorPage()
        {
            try
            {
                IndexCreation.CreateIndexes(typeof(Tags_Count).Assembly, DocumentStore);
            }
            catch (WebException e)
            {
                var socketException = e.InnerException as SocketException;
                if (socketException == null)
                {
                    throw;
                }

                switch (socketException.SocketErrorCode)
                {
                case SocketError.AddressNotAvailable:
                case SocketError.NetworkDown:
                case SocketError.NetworkUnreachable:
                case SocketError.ConnectionAborted:
                case SocketError.ConnectionReset:
                case SocketError.TimedOut:
                case SocketError.ConnectionRefused:
                case SocketError.HostDown:
                case SocketError.HostUnreachable:
                case SocketError.HostNotFound:
                    HttpContext.Current.Response.Redirect("~/RavenNotReachable.htm");
                    break;

                default:
                    throw;
                }
            }
        }
Exemple #5
0
 public void CanCreateIndexes()
 {
     using (var store = GetDocumentStore())
     {
         IndexCreation.CreateIndexes(new AbstractIndexCreationTask[] { new AllDocs1(), new AllDocs2() }, store);
     }
 }
Exemple #6
0
        /// <inheritdoc />
        public virtual Task ExecuteIndexesAsync(IEnumerable <AbstractIndexCreationTask> tasks, string database = null, CancellationToken token = default)
        {
            AssertInitialized();
            var indexesToAdd = IndexCreation.CreateIndexesToAdd(tasks, Conventions);

            return(Maintenance.ForDatabase(database ?? Database).SendAsync(new PutIndexesOperation(indexesToAdd), token));
        }
Exemple #7
0
        public DocumentStoreHolder(IOptions <RavenSettings> ravenSettings, ILogger <DocumentStoreHolder> logger)
        {
            this._logger = logger;
            var settings = ravenSettings.Value;

            Store = new DocumentStore()
            {
                Urls     = new[] { settings.Url },
                Database = settings.Database
            };


            //Store.Conventions.UseOptimisticConcurrency = true;
            //Store.Conventions.CustomizeJsonSerializer = (serializer) =>
            //{
            //    serializer.
            //}

            Store.Initialize();
            CreateDatabaseIfNotExists();

            IndexCreation.CreateIndexes(
                typeof(Talks_BySpeaker).Assembly,
                Store
                );

            using (var session = Store.OpenSession())
            {
                session.Load <Talk>("Talks/1");
            }
            // TODO: Connect to RavenDB
            this._logger.LogWarning("**Initailized RavenDB document store for {0} at {1}", settings.Database, settings.Url);
        }
        /// <summary>
        /// Executes indexes creation.
        /// </summary>
        public virtual Task ExecuteIndexesAsync(IEnumerable <AbstractIndexCreationTask> tasks, CancellationToken token = default(CancellationToken))
        {
            AssertInitialized();
            var indexesToAdd = IndexCreation.CreateIndexesToAdd(tasks, Conventions);

            return(Admin.SendAsync(new PutIndexesOperation(indexesToAdd), token));
        }
Exemple #9
0
        public void BootstrapOrganisation(Organisation organisation)
        {
            MasterRavenDatabaseCommands.EnsureDatabaseExists(_organisation.FriendlyId);

            var docStore = _documentStoreFactory.Create(organisation.RavenInstance);

            IndexCreation.CreateIndexes(
                new CompositionContainer(new AssemblyCatalog(typeof(Indexing.Issues).Assembly), new ExportProvider[0]),
                RavenDatabaseCommands, docStore.Conventions);

            _organisationSession = docStore.OpenSession(_organisation.FriendlyId);
            _organisationSession.Advanced.MaxNumberOfRequestsPerSession = 500;

            var facets = new List <Facet>
            {
                new Facet {
                    Name = "Status"
                },
            };

            _organisationSession.Store(new FacetSetup {
                Id = CoreConstants.FacetDocuments.IssueStatus, Facets = facets
            });
            _organisationSession.SaveChanges();
        }
Exemple #10
0
        public static void Startup()
        {
            var documentStore = new DocumentStore
            {
                ConnectionStringName = "RavenDB"
            }.Initialize();

            documentStore.DatabaseCommands.EnsureDatabaseExists("RepositoryExample");

            ObjectFactory.Initialize(config =>
            {
                config.For <IAuctionRepository>().Use <AuctionRepository>();
                config.For <IBidHistoryRepository>().Use <Infrastructure.BidHistoryRepository>();
                config.For <IClock>().Use <SystemClock>();

                config.For <IDocumentStore>().Use(documentStore);
                config.For <IDocumentSession>()
                .HybridHttpOrThreadLocalScoped()
                .Use(x =>
                {
                    var store   = x.GetInstance <IDocumentStore>();
                    var session = store.OpenSession();
                    session.Advanced.UseOptimisticConcurrency = true;
                    return(session);
                });

                IndexCreation.CreateIndexes(typeof(BidHistory_NumberOfBids).Assembly, documentStore);
            });
        }
Exemple #11
0
        private static void CreateIndexes(IServiceCollection services)
        {
            var serviceProvider = services.BuildServiceProvider();
            var store           = serviceProvider.GetService <IDocumentStore>();

            IndexCreation.CreateIndexes(typeof(RavenModule).Assembly, store);
        }
Exemple #12
0
        /* Uncomment to enable ServiceStack Authentication and CustomUserSession
         * private void ConfigureAuth(Funq.Container container)
         * {
         *  var appSettings = new AppSettings();
         *
         *  //Default route: /auth/{provider}
         *  Plugins.Add(new AuthFeature(this, () => new CustomUserSession(),
         *      new IAuthProvider[] {
         *          new CredentialsAuthProvider(appSettings),
         *          new FacebookAuthProvider(appSettings),
         *          new TwitterAuthProvider(appSettings),
         *          new BasicAuthProvider(appSettings),
         *      }));
         *
         *  //Default route: /register
         *  Plugins.Add(new RegistrationFeature());
         *
         *  //Requires ConnectionString configured in Web.Config
         *  var connectionString = ConfigurationManager.ConnectionStrings["AppDb"].ConnectionString;
         *  container.Register<IDbConnectionFactory>(c =>
         *      new OrmLiteConnectionFactory(connectionString, SqlServerOrmLiteDialectProvider.Instance));
         *
         *  container.Register<IUserAuthRepository>(c =>
         *      new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>()));
         *
         *  var authRepo = (OrmLiteAuthRepository)container.Resolve<IUserAuthRepository>();
         *  authRepo.CreateMissingTables();
         * }
         */

        public static void Start()
        {
            Raven.Database.Server.NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8887);

#if DEBUG
            MvcApplication.Store = new DocumentStore {
                ConnectionStringName = "localRaven"
            };
#else
            MvcApplication.Store = new EmbeddableDocumentStore {
                UseEmbeddedHttpServer = false
            };
#endif

            MvcApplication.Store.Initialize();


            //MvcApplication.Store.DatabaseCommands.PutIndex("Reminders/ToBeSent",
            //                            new IndexDefinitionBuilder<Reminder>
            //                            {
            //                                Map = reminders => from reminder in reminders
            //                                                   select reminder ,

            //                                Reduce = result => from r in result
            //                                                   where r.RemindersSent < 3
            //                                                   select r

            //                            });

            IndexCreation.CreateIndexes(Assembly.GetCallingAssembly(), MvcApplication.Store);

            new AppHost(MvcApplication.Store).Init();
        }
        /// <summary>
        ///     Configures the document store internal.
        /// </summary>
        /// <param name="documentStore">The document store.</param>
        private void ConfigureDocumentStoreInternal(EmbeddableDocumentStore documentStore)
        {
            documentStore.RegisterListener(new StoreListener(this.OnPagePublish, this.OnPageSave, this.OnPageUnPublish));
            documentStore.RegisterListener(new DeleteListener(this.OnDocumentDelete));

            IndexCreation.CreateIndexes(typeof(DefaultBrickPileBootstrapper).Assembly, documentStore);
        }
Exemple #14
0
        public void CanLoadFromIndex()
        {
            using (var documentStore = NewDocumentStore())
            {
                using (var session = documentStore.OpenSession())
                {
                    IndexCreation.CreateIndexes(typeof(Doc).Assembly, documentStore);
                    session.Store(new Doc {
                        Id = "test/doc1", Date = SystemTime.UtcNow
                    });
                    session.Store(new Doc {
                        Id = "test/doc2", Date = null
                    });
                    session.SaveChanges();
                }

                using (var session = documentStore.OpenSession())
                {
                    session
                    .Query <Doc, UnsetDocs>()
                    .Customize(x => x.WaitForNonStaleResults())
                    .AsProjection <DocSummary>()
                    .ToArray();
                }
            }
        }
Exemple #15
0
        public void SideBySideIndexCreated()
        {
            using (var store = NewDocumentStore())
            {
                IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(typeof(OldIndex))), store);

                WaitForIndexing(store);

                var e = Assert.Throws <InvalidOperationException>(() =>
                {
                    using (var session = store.OpenSession())
                    {
                        var count = session.Query <Person, OldIndex>()
                                    .Count(x => x.LastName == "Doe");
                    }
                });

                Assert.Contains("The field 'LastName' is not indexed, cannot query on fields that are not indexed", e.InnerException.Message);

                var mre = new ManualResetEventSlim(false);
                var documentDatabase = store.ServerIfEmbedded.Server.GetDatabaseInternal(store.DefaultDatabase).Result;
                documentDatabase.IndexReplacer.IndexReplaced += s =>
                {
                    mre.Set();
                };
                IndexCreation.SideBySideCreateIndexes(new CompositionContainer(new TypeCatalog(typeof(NewIndex))), store);
                WaitForUserToContinueTheTest(store);

                Assert.True(mre.Wait(10000));
                Assert.Equal(2, store.DatabaseCommands.GetStatistics().CountOfIndexes);
            }
        }
        public void DefineMapReduceIndex()
        {
            //Define indexes from class
            IndexCreation.CreateIndexes(typeof(BlogPosts_PostsCountByTag).Assembly, DocumentStore);

            //Directly define index
            DocumentStore.DatabaseCommands
            .PutIndex("BlogPosts/PostsCountByTag",
                      new IndexDefinitionBuilder <BlogPost, BlogTagPostsCount>
            {
                // The Map function: for each tag of each post, create a new BlogTagPostsCount
                // object with the name of a tag and a count of one.
                Map = posts => from post in posts
                      from tag in post.Tags
                      select new
                {
                    Tag   = tag,
                    Count = 1
                },

                // The Reduce function: group all the BlogTagPostsCount objects we got back
                // from the Map function, use the Tag name as the key, and sum up all the
                // counts. Since the Map function gives each tag a Count of 1, when the Reduce
                // function returns we are going to have the correct Count of posts filed under
                // each tag.
                Reduce = results => from result in results
                         group result by result.Tag
                         into g
                         select new
                {
                    Tag   = g.Key,
                    Count = g.Sum(x => x.Count)
                }
            });
        }
Exemple #17
0
        public void SetUp()
        {
            _store = NewDocumentStore();
            _store.Initialize();

            // We first have to create the static indexes
            IndexCreation.CreateIndexes(typeof(Player_Index_R03).Assembly, _store);

            _teams = DataGenerator.CreateTeamList();

            // Store some players and teams in the database
            using (var session = _store.OpenSession())
            {
                foreach (var team in _teams)
                {
                    session.Store(team);
                }

                _players = DataGenerator.CreatePlayerListWithTeams();

                foreach (var player in _players)
                {
                    session.Store(player);
                }

                session.SaveChanges();
            }

            // Let's wait for indexing to happen
            // this method is part of RavenTestBase and thus should only be used in tests
            WaitForIndexing(_store);
        }
        public void CanUseTranslatorToModifyQueryResults_UsingClientGeneratedIndex()
        {
            using (var ds = NewDocumentStore())
            {
                using (var s = ds.OpenSession())
                {
                    var entity = new User {
                        Name = "Ayende", Age = 1
                    };
                    s.Store(entity);
                    s.Store(new User {
                        Name = "Oren", PartnerId = entity.Id, Age = 1
                    });
                    s.SaveChanges();
                }

                IndexCreation.CreateIndexes(
                    new CompositionContainer(new TypeCatalog(typeof(Users))),
                    ds);

                using (var s = ds.OpenSession())
                {
                    var first = s.Query <User, Users>()
                                .Customize(x => x.WaitForNonStaleResults())
                                .Where(x => x.Name == "Oren")
                                .As <UserWithPartner>()
                                .First();

                    Assert.Equal("Oren", first.User);
                    Assert.Equal("Ayende", first.Partner);
                }
            }
        }
        public DocumentStoreHolder(string urlDatabase)
            : base(urlDatabase)
        {
            var asm = Assembly.GetExecutingAssembly();

            IndexCreation.CreateIndexes(asm, Instance);
        }
        public void WhenTransformResultsHasAnError()
        {
            using (var ds = NewDocumentStore())
            {
                using (var s = ds.OpenSession())
                {
                    var entity = new User {
                        Name = "Ayende"
                    };
                    s.Store(entity);
                    s.Store(new User {
                        Name = "Oren", PartnerId = entity.Id
                    });
                    s.SaveChanges();
                }

                IndexCreation.CreateIndexes(
                    new CompositionContainer(new TypeCatalog(typeof(Users))),
                    ds);

                using (var s = ds.OpenSession())
                {
                    var exception = Assert.Throws <InvalidOperationException>(() => s.Query <User, Users>()
                                                                              .Customize(x => x.WaitForNonStaleResults())
                                                                              .Where(x => x.Name == "Ayende")
                                                                              .As <UserWithPartner>()
                                                                              .First());

                    dynamic dynamicNullObject = new DynamicNullObject();
                    var     expectedError     = Assert.Throws <DivideByZeroException>(() => 1 / dynamicNullObject);

                    Assert.Equal("The transform results function failed.\r\nDoc 'users/1', Error: " + expectedError.Message, exception.Message);
                }
            }
        }
Exemple #21
0
        public void CanAutomaticallyCreateIndexes()
        {
            using (var store = NewDocumentStore())
            {
                IndexCreation.CreateIndexes(typeof(Movies_ByActor).Assembly, store);

                using (var s = store.OpenSession())
                {
                    s.Store(new Movie
                    {
                        Name    = "Hello Dolly",
                        Tagline = "She's a jolly good"
                    });
                    s.SaveChanges();
                }

                using (var s = store.OpenSession())
                {
                    var movies = s.Advanced.LuceneQuery <Movie>("Movies/ByActor")
                                 .Where("Name:Dolly")
                                 .WaitForNonStaleResults()
                                 .ToList();

                    Assert.Equal(1, movies.Count);
                }
            }
        }
Exemple #22
0
        public void CollectionNameWithDashesCanBeIndexed()
        {
            using (var store = GetDocumentStore(new Options()
            {
                ModifyDocumentStore = a => a.Conventions.FindCollectionName = t => String.Join("-", t.Name.ToCharArray())
            }))
            {
                IndexCreation.CreateIndexes(new AbstractIndexCreationTask[] { new ThingIndex(), new ThingIndex2() }, store);
                using (var session = store.OpenSession())
                {
                    session.Store(new Thing {
                        Name = "Oren"
                    });
                    session.SaveChanges();
                }

                Indexes.WaitForIndexing(store);

                WaitForUserToContinueTheTest(store);

                using (var session = store.OpenSession())
                {
                    Assert.NotEmpty(session.Query <Thing, ThingIndex>().Where(x => x.Name == "Oren").ToList());
                    Assert.NotEmpty(session.Query <Thing, ThingIndex2>().Where(x => x.Name == "Oren").ToList());
                }
            }
        }
Exemple #23
0
 public void CanCreateIndex()
 {
     using (var store = NewDocumentStore())
     {
         IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(typeof(Transaction_ByMrn))), store);
     }
 }
Exemple #24
0
        public override void Configure(Container container)
        {
            Licensing.RegisterLicense(new AppSettings().GetString("servicestack:license"));

            SetConfig(new HostConfig
            {
                DebugMode             = true,
                WriteErrorsToResponse = true,
            });

            JsConfig.DateHandler = DateHandler.ISO8601;

            Plugins.Add(new CorsFeature());
            Plugins.Add(new SwaggerFeature());
            Plugins.Add(new PostmanFeature
            {
                DefaultLabelFmt = new List <string> {
                    "route"
                }
            });

            var documentStore = new DocumentStore {
                DefaultDatabase = "PowerDeploy", Url = "http://localhost:8080",
            }.Initialize();

            IndexCreation.CreateIndexes(typeof(Deployment_Latest).Assembly, documentStore);

            Bootstrapper.ConfigureDependencies(container, documentStore);

            DataInitializer.InitializerWithDefaultValuesIfEmpty(documentStore);
        }
        public void TestFixtureSetUp()
        {
            _store = NewDocumentStore();

            IndexCreation.CreateIndexes(typeof(Player_Index_R03).Assembly, _store);

            var playerDictionary = DataGenerator.CreatePlayerList().ToDictionary(p => p.Id);
            var teamDictionary   = DataGenerator.CreateTeamList().ToDictionary(p => p.Id);
            var employmentList   = DataGenerator.CreateEmploymentList();

            using (var bulkInsert = _store.BulkInsert(null, new BulkInsertOptions {
                OverwriteExisting = true
            }))
            {
                foreach (var player in playerDictionary.Values)
                {
                    bulkInsert.Store(player);
                }

                foreach (var team in teamDictionary.Values)
                {
                    bulkInsert.Store(team);
                }

                foreach (var employment in employmentList)
                {
                    bulkInsert.Store(employment);
                }
            }

            WaitForIndexing(_store);
        }
        public static void Initialize(IContainer container)
        {
            if (_documentStore != null)
            {
                return;
            }

            var documentStore = new EmbeddableDocumentStore {
                //DataDirectory = "App_Data",
                RunInMemory           = true,
                UseEmbeddedHttpServer = true
            };

            documentStore.Configuration.PluginsDirectory = System.IO.Path.Combine(AppDomain.CurrentDomain.RelativeSearchPath, "Plugins");
            documentStore.RegisterListener(new DocumentStoreListener());
            documentStore.Initialize();

            _documentStore = documentStore;

            IndexCreation.CreateIndexes(typeof(RavenConfig).Assembly, _documentStore);

            RavenProfiler.InitializeFor(_documentStore);

            using (var session = _documentStore.OpenSession()) {
                RavenQueryStatistics stats;
                session.Query <Document>().Statistics(out stats).Take(0).ToList();
                if (stats.TotalResults == 0)
                {
                    // we need to create some documents
                    var rootDoc = new Document {
                        Slug = string.Empty, Title = "Home page", Body = "<p>Welcome to this site. Go and see <a href=\"/blog\">the blog</a>.</p><p><a href=\"/about\">here</a> is the about page.</p>"
                    };
                    session.Store(rootDoc);
                    session.Store(new Document {
                        ParentId = rootDoc.Id,
                        Slug     = "about",
                        Title    = "About",
                        Body     = "This is about this site."
                    });

                    var blogDoc = new Document {
                        ParentId = rootDoc.Id,
                        Slug     = "blog",
                        Title    = "Blog",
                        Body     = "This is my blog."
                    };
                    session.Store(blogDoc);
                    session.Store(new Document {
                        ParentId = blogDoc.Id,
                        Slug     = "First",
                        Title    = "my first blog post",
                        Body     = "Hooray"
                    });

                    session.SaveChanges();
                }
            }

            container.Configure(x => x.For <IDocumentSession>().HybridHttpOrThreadLocalScoped().Use(() => _documentStore.OpenSession()));
        }
        //public override void ConfigureConventions(BrickPileConventions brickPileConventions)
        //{
        //    brickPileConventions.VirtualPathProviderConventions.Register("static", () => new NativeVirtualPathProvider());
        //}

        public override void ConfigureDocumentStore(IDocumentStore documentStore)
        {
            IndexCreation.CreateIndexes(typeof(CustomBootstrapper).Assembly, documentStore);

            // Initialize MiniProfiler
            //MvcMiniProfiler.RavenDb.Profiler.AttachTo(documentStore);
        }
Exemple #28
0
        public static void InitializeWithDefaults(this IDocumentStore documentStore, bool isDataToBeSeeded,
                                                  IList <Type> indexesToExecute)
        {
            Condition.Requires(documentStore).IsNotNull();

            // Default initializtion;
            documentStore.Initialize();

            // Index initialisation.
            if (indexesToExecute != null)
            {
                Type[] indexes = (from type in indexesToExecute
                                  where type.IsSubclassOf(typeof(AbstractIndexCreationTask))
                                  select type).ToArray();

                IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(indexes)), documentStore);
            }
            else
            {
                IndexCreation.CreateIndexes(typeof(RecentPopularTags).Assembly, documentStore);
            }

            // Create our Seed Data (if required).
            // NOTE: This would be handled differently if it was a -real- production system.
            //       Like, wrapping this called in a #if RELEASE #endif, for example.
            if (isDataToBeSeeded)
            {
                HelperUtilities.CreateSeedData(documentStore);
            }

            // Now lets check to make sure there are now errors.
            documentStore.AssertDocumentStoreErrors();
        }
Exemple #29
0
        public void ServerShouldThrow()
        {
            var exception = Assert.Throws <IndexCompilationException>(
                () =>
            {
                using (var store = NewDocumentStore())
                {
                    var container = new CompositionContainer(new TypeCatalog(typeof(Index), typeof(Record)));
                    IndexCreation.CreateIndexes(container, store);
                }
            });

            Assert.Equal("Reduce cannot contain Average() methods in grouping.", exception.Message);

            exception = Assert.Throws <IndexCompilationException>(
                () =>
            {
                using (var store = NewDocumentStore())
                {
                    var container = new CompositionContainer(new TypeCatalog(typeof(FancyIndex), typeof(Record)));
                    IndexCreation.CreateIndexes(container, store);
                }
            });

            Assert.Equal("Reduce cannot contain Average() methods in grouping.", exception.Message);
        }
Exemple #30
0
        private static void TryCreatingIndexesOrRedirectToErrorPage()
        {
            try
            {
                IndexCreation.CreateIndexes(Assembly.GetAssembly(typeof(Company)), DocumentStore);
            }
            catch (WebException e)
            {
                var socketException = e.InnerException as SocketException;
                if (socketException == null)
                {
                    throw;
                }

                switch (socketException.SocketErrorCode)
                {
                case SocketError.AddressNotAvailable:
                case SocketError.NetworkDown:
                case SocketError.NetworkUnreachable:
                case SocketError.ConnectionAborted:
                case SocketError.ConnectionReset:
                case SocketError.TimedOut:
                case SocketError.ConnectionRefused:
                case SocketError.HostDown:
                case SocketError.HostUnreachable:
                case SocketError.HostNotFound:
                    // Shameless "borrow" from RacoonBlog, to show a nice page if it can't connect to RavenDB
                    HttpContext.Current.Response.Redirect("~/RavenNotReachable.htm");
                    break;

                default:
                    throw;
                }
            }
        }