public RavenCommand <DatabasePutResult> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new AddDatabaseNodeCommand(_databaseName, _node)); }
public RavenCommand GetCommand(DocumentConventions conventions, JsonOperationContext context) { throw new System.NotImplementedException(); }
public new static ClusterRequestExecutor Create(string[] urls, string databaseName, X509Certificate2 certificate, DocumentConventions conventions) { throw new NotSupportedException(); }
public RavenCommand <OperationState> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new GetOperationStateCommand(DocumentConventions.Default, _id, _isServerStoreOperation)); }
public RavenCommand <ConfigureExpirationOperationResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new ConfigureExpirationCommand(conventions, _configuration)); }
internal static SubscriptionCreationOptions CreateSubscriptionOptionsFromGeneric <T>( DocumentConventions conventions, SubscriptionCreationOptions criteria, Expression <Func <T, bool> > predicate, Expression <Func <T, object> > project, Action <ISubscriptionIncludeBuilder <T> > includes) { criteria ??= new SubscriptionCreationOptions(); var collectionName = conventions.GetCollectionName(typeof(T)); if (criteria.Query == null) { var tType = typeof(T); var includeRevisions = tType.IsConstructedGenericType && tType.GetGenericTypeDefinition() == typeof(Revision <>); if (includeRevisions) { collectionName = conventions.GetCollectionName(tType.GenericTypeArguments[0]); } if (includeRevisions) { criteria.Query = $"from '{collectionName.Replace("'", "\\'")}' (Revisions = true)"; } else { criteria.Query = $"from '{collectionName.Replace("'", "\\'")}'"; } criteria.Query += " as doc"; } if (predicate != null) { var script = predicate.CompileToJavascript( new JavascriptCompilationOptions( JsCompilationFlags.BodyOnly, JavascriptConversionExtensions.MathSupport.Instance, new JavascriptConversionExtensions.DictionarySupport(), JavascriptConversionExtensions.LinqMethodsSupport.Instance, new JavascriptConversionExtensions.SubscriptionsWrappedConstantSupport(conventions), new JavascriptConversionExtensions.ConstSupport(conventions), new JavascriptConversionExtensions.ReplaceParameterWithNewName(predicate.Parameters[0], "this"), JavascriptConversionExtensions.ToStringSupport.Instance, JavascriptConversionExtensions.DateTimeSupport.Instance, JavascriptConversionExtensions.InvokeSupport.Instance, JavascriptConversionExtensions.NullCoalescingSupport.Instance, JavascriptConversionExtensions.NestedConditionalSupport.Instance, JavascriptConversionExtensions.StringSupport.Instance )); criteria.Query = $"declare function predicate() {{ return {script} }}{Environment.NewLine}" + $"{criteria.Query}{Environment.NewLine}" + "where predicate.call(doc)"; } if (project != null) { var script = project.CompileToJavascript( new JavascriptCompilationOptions( JsCompilationFlags.BodyOnly, JavascriptConversionExtensions.MathSupport.Instance, new JavascriptConversionExtensions.DictionarySupport(), JavascriptConversionExtensions.LinqMethodsSupport.Instance, new JavascriptConversionExtensions.ConstSupport(conventions), JavascriptConversionExtensions.ToStringSupport.Instance, JavascriptConversionExtensions.DateTimeSupport.Instance, JavascriptConversionExtensions.InvokeSupport.Instance, JavascriptConversionExtensions.NullCoalescingSupport.Instance, JavascriptConversionExtensions.StringSupport.Instance, JavascriptConversionExtensions.NestedConditionalSupport.Instance, new JavascriptConversionExtensions.ReplaceParameterWithNewName(project.Parameters[0], "doc"), JavascriptConversionExtensions.CounterSupport.Instance, JavascriptConversionExtensions.CompareExchangeSupport.Instance )); criteria.Query += Environment.NewLine + "select " + script; } if (includes != null) { var builder = new IncludeBuilder <T>(conventions); includes(builder); if (builder.DocumentsToInclude != null && builder.DocumentsToInclude.Count > 0) { criteria.Query += Environment.NewLine + "include "; var first = true; foreach (var inc in builder.DocumentsToInclude) { var include = "doc." + inc; if (first == false) { criteria.Query += ","; } first = false; if (IncludesUtil.RequiresQuotes(include, out var escapedInclude)) { criteria.Query += $"'{escapedInclude}'"; } else { criteria.Query += include; } } } } return(criteria); }
public RavenCommand <IndexDefinition> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new GetIndexCommand(_indexName)); }
public RavenCommand<string[]> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return new GetTermsCommand(_indexName, _field, _fromValue, _pageSize); }
/// <summary> /// Executes the index creation against the specified document database using the specified conventions /// </summary> public virtual void Execute(IDocumentStore store, DocumentConventions conventions = null, string database = null) { AsyncHelpers.RunSync(() => ExecuteAsync(store, conventions, database)); }
public RavenCommand <ModifyOngoingTaskResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new UpdateExternalReplication(_database, _newWatcher)); }
public async Task RemoveNodeWithDb() { DebuggerAttachedTimeout.DisableLongTimespan = true; var fromSeconds = Debugger.IsAttached ? TimeSpan.FromSeconds(15) : TimeSpan.FromSeconds(5); var leader = await CreateRaftClusterAndGetLeader(5); var db = await CreateDatabaseInCluster("MainDB", 5, leader.WebUrl); var watcherDb = await CreateDatabaseInCluster("WatcherDB", 1, leader.WebUrl); var conventions = new DocumentConventions { DisableTopologyUpdates = true }; var leaderStore = new DocumentStore { Database = "MainDB", Urls = new[] { leader.WebUrl }, Conventions = conventions }.Initialize(); var watcherStore = new DocumentStore { Database = "WatcherDB", Urls = new[] { watcherDb.Item2.Single().WebUrl }, Conventions = conventions }.Initialize(); var watcher = new ExternalReplication("WatcherDB", new[] { watcherDb.Item2.Single().WebUrl }); var watcherRes = await AddWatcherToReplicationTopology((DocumentStore)leaderStore, watcher); var tasks = new List <Task>(); foreach (var ravenServer in Servers) { tasks.Add(ravenServer.ServerStore.Cluster.WaitForIndexNotification(watcherRes.RaftCommandIndex)); } Assert.True(await Task.WhenAll(tasks).WaitAsync(TimeSpan.FromSeconds(5))); var responsibleServer = Servers.Single(s => s.ServerStore.NodeTag == watcherRes.ResponsibleNode); var responsibleStore = new DocumentStore { Database = "MainDB", Urls = new[] { responsibleServer.WebUrl }, Conventions = conventions }.Initialize(); var serverNodes = db.Item2.Select(s => new ServerNode { ClusterTag = s.ServerStore.NodeTag, Database = "MainDB", Url = s.WebUrl }).ToList(); // check that replication works. using (var session = leaderStore.OpenSession()) { session.Store(new User { Name = "Karmel" }, "users/1"); session.SaveChanges(); } Assert.True(await WaitForDocumentInClusterAsync <User>(serverNodes, "users/1", u => u.Name == "Karmel", fromSeconds)); Assert.True(WaitForDocument <User>(watcherStore, "users/1", u => u.Name == "Karmel", 30_000)); // remove the node from the cluster that is responsible for the external replication Assert.True(await leader.ServerStore.RemoveFromClusterAsync(watcherRes.ResponsibleNode).WaitAsync(fromSeconds)); Assert.True(await responsibleServer.ServerStore.WaitForState(RachisConsensus.State.Passive).WaitAsync(fromSeconds)); var dbInstance = await responsibleServer.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore("MainDB"); await WaitForValueAsync(() => dbInstance.ReplicationLoader.OutgoingConnections.Count(), 0); // replication from the removed node should be suspended using (var session = responsibleStore.OpenAsyncSession()) { await session.StoreAsync(new User { Name = "Karmel2" }, "users/2"); await session.SaveChangesAsync(); } var nodeInCluster = serverNodes.First(s => s.ClusterTag != responsibleServer.ServerStore.NodeTag); var nodeInClusterStore = new DocumentStore { Database = "MainDB", Urls = new [] { nodeInCluster.Url }, Conventions = conventions }.Initialize(); Assert.False(WaitForDocument <User>(nodeInClusterStore, "users/2", u => u.Name == "Karmel2")); Assert.False(WaitForDocument <User>(watcherStore, "users/2", u => u.Name == "Karmel2")); // the task should be reassinged within to another node using (var session = nodeInClusterStore.OpenSession()) { session.Store(new User { Name = "Karmel2" }, "users/3"); session.SaveChanges(); } Assert.True(WaitForDocument <User>(watcherStore, "users/3", u => u.Name == "Karmel2", 30_000)); // rejoin the node var newLeader = Servers.Single(s => s.ServerStore.IsLeader()); Assert.True(await newLeader.ServerStore.AddNodeToClusterAsync(responsibleServer.WebUrl, watcherRes.ResponsibleNode).WaitAsync(fromSeconds)); Assert.True(await responsibleServer.ServerStore.WaitForState(RachisConsensus.State.Follower).WaitAsync(fromSeconds)); using (var session = responsibleStore.OpenSession()) { session.Store(new User { Name = "Karmel4" }, "users/4"); session.SaveChanges(); Assert.True(await WaitForDocumentInClusterAsync <User>(serverNodes, "users/4", u => u.Name == "Karmel4", fromSeconds * 5)); } Assert.True(WaitForDocument <User>(watcherStore, "users/4", u => u.Name == "Karmel4", 30_000)); nodeInClusterStore.Dispose(); leaderStore.Dispose(); watcherStore.Dispose(); responsibleStore.Dispose(); }
public RavenCommand<CountersDetail> GetCommand(IDocumentStore store, DocumentConventions conventions, JsonOperationContext context, HttpCache cache) { return new GetCounterValuesCommand(_docId, _counters, _returnFullResults); }
public RavenCommand GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new SetIndexLockCommand(_indexName, _mode)); }
public RavenCommand <ModifyOngoingTaskResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new ToggleTaskStateCommand(_taskId, _taskName, _type, _disable)); }
public Operation(RequestExecutor requestExecutor, Func <IDatabaseChanges> changes, DocumentConventions conventions, long id) { _requestExecutor = requestExecutor; _changes = changes; _conventions = conventions; _id = id; }
public RavenCommand GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new PutSortersCommand(conventions, context, _sortersToAdd)); }
public RavenCommand <OperationIdResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new RestoreBackupCommand(_restoreConfiguration, NodeTag)); }
public RavenCommand <CertificateRawData> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new CreateClientCertificateCommand(_name, _permissions, _clearance, _password)); }
public CreateSubscriptionCommand(DocumentConventions conventions, SubscriptionCreationOptions options, string id = null) { _conventions = conventions; _options = options; _id = id; }
public RavenCommand <ModifySolverResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new ModifyConflictSolverCommand(conventions, _database, this)); }
public RavenCommand <List <string> > GetCommand(IDocumentStore store, DocumentConventions conventions, JsonOperationContext context, HttpCache cache) { return(new CustomQueryCommand(_rql)); }
public BatchCommand(DocumentConventions conventions, JsonOperationContext context, List <ICommandData> commands, BatchOptions options = null) #endregion { }
public GetOperationStateCommand(DocumentConventions conventions, long id, bool isServerStoreOperation = false) { _conventions = conventions; _id = id; _isServerStoreOperation = isServerStoreOperation; }
public RavenCommand <IndexStaleness> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new GetIndexStalenessCommand(conventions, _indexName)); }
public ConfigureExpirationCommand(DocumentConventions conventions, ExpirationConfiguration configuration) { _conventions = conventions; _configuration = configuration; }
public GetIndexStalenessCommand(DocumentConventions conventions, string indexName) { _conventions = conventions; _indexName = indexName; }
public RavenCommand <DatabasePutResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new CreateDatabaseOperation.CreateDatabaseCommand(_databaseRecord, etag: _etag)); }
protected virtual RavenCommand <OperationState> GetOperationStateCommand(DocumentConventions conventions, long id) { return(new GetOperationStateOperation.GetOperationStateCommand(conventions, id)); }
public new static ClusterRequestExecutor CreateForSingleNodeWithoutConfigurationUpdates(string url, string databaseName, X509Certificate2 certificate, DocumentConventions conventions) { throw new NotSupportedException(); }
/// <summary> /// Toes the index definition. /// </summary> public IndexDefinition ToIndexDefinition(DocumentConventions conventions, bool validateMap = true) { if (Map == null && validateMap) { throw new InvalidOperationException( string.Format("Map is required to generate an index, you cannot create an index without a valid Map property (in index {0}).", _indexName)); } try { if (Reduce != null) { IndexDefinitionHelper.ValidateReduce(Reduce); } string querySource = (typeof(TDocument) == typeof(object) || ContainsWhereEntityIs()) ? "docs" : IndexDefinitionHelper.GetQuerySource(conventions, typeof(TDocument)); var indexDefinition = new IndexDefinition { Name = _indexName, Reduce = IndexDefinitionHelper.PruneToFailureLinqQueryAsStringToWorkableCode <TDocument, TReduceResult>(Reduce, conventions, "results", translateIdentityProperty: false), LockMode = LockMode, Priority = Priority, OutputReduceToCollection = OutputReduceToCollection }; var indexes = ConvertToStringDictionary(Indexes); var stores = ConvertToStringDictionary(Stores); var analyzers = ConvertToStringDictionary(Analyzers); var suggestionsOptions = ConvertToStringSet(SuggestionsOptions).ToDictionary(x => x, x => true); var termVectors = ConvertToStringDictionary(TermVectors); var spatialOptions = ConvertToStringDictionary(SpatialIndexes); #pragma warning disable CS0618 // Type or member is obsolete if (conventions.PrettifyGeneratedLinqExpressions) #pragma warning restore CS0618 // Type or member is obsolete { indexDefinition.Reduce = IndexPrettyPrinter.TryFormat(indexDefinition.Reduce); } foreach (var indexesString in IndexesStrings) { if (indexes.ContainsKey(indexesString.Key)) { throw new InvalidOperationException("There is a duplicate key in indexes: " + indexesString.Key); } indexes.Add(indexesString); } foreach (var storeString in StoresStrings) { if (stores.ContainsKey(storeString.Key)) { throw new InvalidOperationException("There is a duplicate key in stores: " + storeString.Key); } stores.Add(storeString); } foreach (var analyzerString in AnalyzersStrings) { if (analyzers.ContainsKey(analyzerString.Key)) { throw new InvalidOperationException("There is a duplicate key in analyzers: " + analyzerString.Key); } analyzers.Add(analyzerString); } foreach (var termVectorString in TermVectorsStrings) { if (termVectors.ContainsKey(termVectorString.Key)) { throw new InvalidOperationException("There is a duplicate key in term vectors: " + termVectorString.Key); } termVectors.Add(termVectorString); } foreach (var spatialString in SpatialIndexesStrings) { if (spatialOptions.ContainsKey(spatialString.Key)) { throw new InvalidOperationException("There is a duplicate key in spatial indexes: " + spatialString.Key); } spatialOptions.Add(spatialString); } ApplyValues(indexDefinition, indexes, (options, value) => options.Indexing = value); ApplyValues(indexDefinition, stores, (options, value) => options.Storage = value); ApplyValues(indexDefinition, analyzers, (options, value) => options.Analyzer = value); ApplyValues(indexDefinition, termVectors, (options, value) => options.TermVector = value); ApplyValues(indexDefinition, spatialOptions, (options, value) => options.Spatial = value); ApplyValues(indexDefinition, suggestionsOptions, (options, value) => options.Suggestions = value); if (Map != null) { var map = IndexDefinitionHelper.PruneToFailureLinqQueryAsStringToWorkableCode <TDocument, TReduceResult>( Map, conventions, querySource, translateIdentityProperty: true); #pragma warning disable CS0618 // Type or member is obsolete indexDefinition.Maps.Add(conventions.PrettifyGeneratedLinqExpressions ? IndexPrettyPrinter.TryFormat(map) : map); #pragma warning restore CS0618 // Type or member is obsolete } indexDefinition.AdditionalSources = AdditionalSources; indexDefinition.Configuration = Configuration; return(indexDefinition); } catch (Exception e) { throw new IndexCompilationException("Failed to create index " + _indexName, e); } }