public void PagingOnBoundStatementTest_Async_UsingConfigBasedPagingSetting()
{
var pageSize = 10;
var queryOptions = new QueryOptions().SetPageSize(pageSize);
Builder builder = new Builder().WithQueryOptions(queryOptions).WithDefaultKeyspace(KeyspaceName);
builder.AddContactPoint(TestCluster.InitialContactPoint);
using (ISession session = builder.Build().Connect())
{
var totalRowLength = 1003;
Tuple<string, string> tableNameAndStaticKeyVal = CreateTableWithCompositeIndexAndInsert(session, totalRowLength);
string statementToBeBound = "SELECT * from " + tableNameAndStaticKeyVal.Item1 + " where label=?";
PreparedStatement preparedStatementWithoutPaging = session.Prepare(statementToBeBound);
PreparedStatement preparedStatementWithPaging = session.Prepare(statementToBeBound);
BoundStatement boundStatemetWithoutPaging = preparedStatementWithoutPaging.Bind(tableNameAndStaticKeyVal.Item2);
BoundStatement boundStatemetWithPaging = preparedStatementWithPaging.Bind(tableNameAndStaticKeyVal.Item2);
var rsWithSessionPagingInherited = session.ExecuteAsync(boundStatemetWithPaging).Result;
var rsWithoutPagingInherited = Session.Execute(boundStatemetWithoutPaging);
//Check that the internal list of items count is pageSize
Assert.AreEqual(pageSize, rsWithSessionPagingInherited.InnerQueueCount);
Assert.AreEqual(totalRowLength, rsWithoutPagingInherited.InnerQueueCount);
var allTheRowsPaged = rsWithSessionPagingInherited.ToList();
Assert.AreEqual(totalRowLength, allTheRowsPaged.Count);
}
}
private static Configuration GetConfig(QueryOptions queryOptions = null)
{
return new Configuration(new Policies(),
new ProtocolOptions(),
null,
new SocketOptions(),
new ClientOptions(),
NoneAuthProvider.Instance,
null,
queryOptions ?? DefaultQueryOptions,
new DefaultAddressTranslator());
}
public void RequestHandler_GetRequest_SimpleStatement_QueryOptions_Are_Used()
{
var stmt = new SimpleStatement("DUMMY QUERY");
Assert.AreEqual(0, stmt.PageSize);
Assert.Null(stmt.ConsistencyLevel);
var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum).SetPageSize(100);
var request = (QueryRequest)RequestHandler<RowSet>.GetRequest(stmt, 2, GetConfig(queryOptions));
Assert.AreEqual(100, request.PageSize);
Assert.AreEqual(queryOptions.GetPageSize(), request.PageSize);
Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency);
Assert.AreEqual(ConsistencyLevel.Any, request.SerialConsistency);
}
private static Session GetInstance(QueryOptions queryOptions = null)
{
var config = new Configuration(new Policies(),
new ProtocolOptions(),
null,
new SocketOptions(),
new ClientOptions(),
NoneAuthProvider.Instance,
null,
queryOptions ?? new QueryOptions(),
new DefaultAddressTranslator());
return new Session(null, config, null, 2);
}
public LinqCommandInfo(LinqCommand command, QueryOptions options, LinqCommandFlags flags,
List<Type> entityTypes, string cacheKey, List<ParameterExpression> externalParameters,
List<LambdaExpression> includes)
{
CommandType = command.CommandType;
CommandKind = command.Kind;
Options = options;
Flags = flags;
EntityTypes = entityTypes;
CacheKey = cacheKey;
ExternalParameters = externalParameters;
Includes = includes;
}
public void SimpleStatement_QueryOptions_Are_Used()
{
var stmt = new SimpleStatement("DUMMY QUERY");
Assert.AreEqual(0, stmt.PageSize);
Assert.Null(stmt.ConsistencyLevel);
var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum).SetPageSize(100);
var session = GetInstance(queryOptions);
var request = (QueryRequest)session.GetRequest(stmt);
Assert.AreEqual(100, request.PageSize);
Assert.AreEqual(queryOptions.GetPageSize(), request.PageSize);
Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency);
Assert.AreEqual(ConsistencyLevel.Any, request.SerialConsistency);
}
//Query the crawled data by keywords. The inputs of the method are the inputs of the PI Web API correspondent action
public Dictionary<string, dynamic> Search(string query, QueryOptions queryOption, string[] scope = null, string[] fields = null, int count = 10, int start = 0)
{
List<string> foundItems = new List<string>();
string scopeQueryString = GenerateQueryString(scope, "scope");
string fieldsQueryString = GenerateQueryString(fields, "fields");
Url = baseUrl + "search/query?q=" + queryOption.ToString().ToLower() + ":" + query + scopeQueryString + fieldsQueryString + "&count=" + count + "&start=" + start;
dynamic result = MakeGetRequest(Url);
Dictionary<string, dynamic> dataDic = new Dictionary<string, dynamic>();
foreach (dynamic item in result.Items)
{
dataDic.Add(item.Paths[0].Value,item);
}
return dataDic;
}
internal static GridContext Create(HttpContext context, string gridName, IMVCGridDefinition grid, QueryOptions options)
{
var httpContext = new HttpContextWrapper(context);
var urlHelper = new System.Web.Mvc.UrlHelper(new RequestContext(httpContext, new RouteData()));
var gridContext = new GridContext()
{
GridName = gridName,
CurrentHttpContext = context,
GridDefinition = grid,
QueryOptions = options,
UrlHelper = urlHelper
};
return gridContext;
}
public ActionResult Index()
{
if (IsXrdsRequest())
return View("Xrds");
IList<Review> reviews;
var queryOptions = new QueryOptions<Review>
{
Take = 12,
OrderDirection = OrderByDirection.Descending,
OrderBySelector = r => r.PublicationDate
};
var user = _userService.GetCurrentUser();
if(user != null)
reviews = _repository.FindAll(r => user.IsSubscribedTo(r.ReviewType), queryOptions);
else
reviews = _repository.FindAll(queryOptions);
return View(reviews);
}
public void BatchStatement_QueryOptions_Are_Used()
{
var stmt = new BatchStatement();
Assert.Null(stmt.ConsistencyLevel);
var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum);
var session = GetInstance(queryOptions);
var request = (BatchRequest)session.GetRequest(stmt);
Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency);
}
public async Task<QueryResult<PreparedQueryDefinition[]>> List(QueryOptions q)
{
return await _client.Get<PreparedQueryDefinition[]>("/v1/query", q).Execute().ConfigureAwait(false);
}
public IEnumerable<QueryRow> GetAllDocs(QueryOptions options)
{
var remainingIDs = default(List<string>);
var enumerator = GetDocEnumerator(options, out remainingIDs);
var current = 0;
foreach(var next in enumerator) {
if (current++ >= options.Limit) {
yield break;
}
var sequenceNumber = 0L;
var docID = next.CurrentDocID;
remainingIDs.Remove(docID);
var value = default(IDictionary<string, object>);
if (next.Exists) {
sequenceNumber = (long)next.SelectedRev.sequence;
var conflicts = default(IList<string>);
if (options.AllDocsMode >= AllDocsMode.ShowConflicts && next.IsConflicted) {
SelectCurrentRevision(next);
using (var innerEnumerator = new CBForestHistoryEnumerator(next, true, false)) {
conflicts = innerEnumerator.Select(x => (string)x.SelectedRev.revID).ToList();
}
if (conflicts.Count == 1) {
conflicts = null;
}
}
bool valid = conflicts != null || options.AllDocsMode != AllDocsMode.OnlyConflicts;
if (!valid) {
continue;
}
value = new NonNullDictionary<string, object> {
{ "rev", next.CurrentRevID },
{ "deleted", next.IsDeleted ? (object)true : null },
{ "_conflicts", conflicts }
};
}
var row = new QueryRow(value == null ? null : docID, sequenceNumber, docID, value,
value == null ? null : new RevisionInternal(next, options.IncludeDocs), null);
if (options.Filter == null || options.Filter(row)) {
yield return row;
}
}
foreach (var docId in remainingIDs) {
var value = GetAllDocsEntry(docId);
var row = new QueryRow(value != null ? docId as string : null, 0, docId, value, null, null);
if (options.Filter == null || options.Filter(row)) {
yield return row;
}
}
}
public void Should_Use_Statement_ReadTimeout()
{
const int generalReadTimeout = 1500;
const int statementReadTimeout = 12000;
var testCluster = TestClusterManager.CreateNew();
var socketOptions = new SocketOptions().SetReadTimeoutMillis(generalReadTimeout);
var queryOptions = new QueryOptions().SetRetryOnTimeout(false);
var builder = Cluster.Builder().AddContactPoint(testCluster.InitialContactPoint)
.WithSocketOptions(socketOptions)
.WithPoolingOptions(new PoolingOptions()
.SetCoreConnectionsPerHost(HostDistance.Local, 1)
.SetHeartBeatInterval(0))
.WithQueryTimeout(Timeout.Infinite)
.WithQueryOptions(queryOptions);
using (var cluster = builder.Build())
{
var session = cluster.Connect();
//warmup
TestHelper.Invoke(() => session.Execute("SELECT key FROM system.local"), 10);
testCluster.PauseNode(1);
var stopWatch = new Stopwatch();
stopWatch.Start();
Assert.Throws<OperationTimedOutException>(() => session.Execute("SELECT key FROM system.local"));
stopWatch.Stop();
//precision of the timer is not guaranteed
Assert.Greater(stopWatch.ElapsedMilliseconds, generalReadTimeout - 1000);
Assert.Less(stopWatch.ElapsedMilliseconds, generalReadTimeout + 1000);
//Try with an specified timeout at Statement level
var stmt = new SimpleStatement("SELECT key FROM system.local")
.SetReadTimeoutMillis(statementReadTimeout);
stopWatch.Restart();
Assert.Throws<OperationTimedOutException>(() => session.Execute(stmt));
stopWatch.Stop();
//precision of the timer is not guaranteed
Assert.Greater(stopWatch.ElapsedMilliseconds, statementReadTimeout - 3000);
Assert.Less(stopWatch.ElapsedMilliseconds, statementReadTimeout + 3000);
testCluster.ResumeNode(1);
}
}
public static QueryOptions ParseOptions(IMVCGridDefinition grid, HttpRequest httpRequest)
{
string qsKeyPage = grid.QueryStringPrefix + QueryStringSuffix_Page;
string qsKeySort = grid.QueryStringPrefix + QueryStringSuffix_Sort;
string qsKeyDirection = grid.QueryStringPrefix + QueryStringSuffix_SortDir;
string qsKeyEngine = grid.QueryStringPrefix + QueryStringSuffix_Engine;
string qsKeyPageSize = grid.QueryStringPrefix + QueryStringSuffix_ItemsPerPage;
string qsColumns = grid.QueryStringPrefix + QueryStringSuffix_Columns;
var options = new QueryOptions();
if (httpRequest.QueryString[qsKeyEngine] != null)
{
string re = httpRequest.QueryString[qsKeyEngine];
options.RenderingEngineName = re;
}
if (!grid.Paging)
{
options.ItemsPerPage = null;
options.PageIndex = null;
}
else
{
options.ItemsPerPage = grid.ItemsPerPage;
if (grid.AllowChangingPageSize)
{
if (httpRequest.QueryString[qsKeyPageSize] != null)
{
int pageSize;
if (Int32.TryParse(httpRequest.QueryString[qsKeyPageSize], out pageSize))
{
options.ItemsPerPage = pageSize;
}
}
if (grid.MaxItemsPerPage.HasValue && grid.MaxItemsPerPage.Value < options.ItemsPerPage)
{
options.ItemsPerPage = grid.MaxItemsPerPage.Value;
}
}
if (options.ItemsPerPage <= 0)
{
options.ItemsPerPage = 20;
}
options.PageIndex = 0;
if (httpRequest.QueryString[qsKeyPage] != null)
{
int pageNum;
if (Int32.TryParse(httpRequest.QueryString[qsKeyPage], out pageNum))
{
options.PageIndex = pageNum - 1;
if (options.PageIndex < 0) options.PageIndex = 0;
}
}
}
if (!grid.Filtering)
{
//options.Filters
}
else
{
var filterableColumns = grid.GetColumns().Where(p => p.EnableFiltering);
foreach (var col in filterableColumns)
{
string qsKey = grid.QueryStringPrefix + col.ColumnName;
if (httpRequest.QueryString[qsKey] != null)
{
string filterValue = httpRequest.QueryString[qsKey];
if (!String.IsNullOrWhiteSpace(filterValue))
{
options.Filters.Add(col.ColumnName, filterValue);
}
}
}
}
if (!grid.Sorting)
{
options.SortColumnName = null;
options.SortColumnData = null;
options.SortDirection = SortDirection.Unspecified;
}
else
{
options.SortColumnName = null;
string sortColName = null;
if (httpRequest.QueryString[qsKeySort] != null)
{
sortColName = httpRequest.QueryString[qsKeySort];
}
if (String.IsNullOrWhiteSpace(sortColName))
{
sortColName = grid.DefaultSortColumn;
}
string thisSortColName = sortColName.Trim().ToLower();
// validate SortColumn
var colDef = grid.GetColumns().SingleOrDefault(p => p.ColumnName.ToLower() == thisSortColName);
if (colDef != null && !colDef.EnableSorting)
{
colDef = null;
}
if (colDef != null)
{
options.SortColumnName = colDef.ColumnName;
options.SortColumnData = colDef.SortColumnData;
}
options.SortDirection = grid.DefaultSortDirection;
if (httpRequest.QueryString[qsKeyDirection] != null)
{
string sortDir = httpRequest.QueryString[qsKeyDirection];
if (String.Compare(sortDir, "dsc", true) == 0)
{
options.SortDirection = SortDirection.Dsc;
}
else if (String.Compare(sortDir, "asc", true) == 0)
{
options.SortDirection = SortDirection.Asc;
}
}
}
if (grid.AdditionalQueryOptionNames.Count > 0)
{
foreach (var aqon in grid.AdditionalQueryOptionNames)
{
string qsKeyAQO = grid.QueryStringPrefix + aqon;
string val = "";
if (httpRequest.QueryString[qsKeyAQO] != null)
{
val = httpRequest.QueryString[qsKeyAQO];
}
options.AdditionalQueryOptions.Add(aqon, val);
}
}
if (grid.PageParameterNames.Count > 0)
{
foreach (var aqon in grid.PageParameterNames)
{
string qsKeyAQO = QueryStringPrefix_PageParameter + grid.QueryStringPrefix + aqon;
string val = "";
if (httpRequest.QueryString[qsKeyAQO] != null)
{
val = httpRequest.QueryString[qsKeyAQO];
}
options.PageParameters.Add(aqon, val);
}
}
var gridColumns = grid.GetColumns();
List<ColumnVisibility> requestedColumns = new List<ColumnVisibility>();
if (httpRequest.QueryString[qsColumns] == null)
{
foreach (var gridColumn in gridColumns)
{
requestedColumns.Add(
new ColumnVisibility() {
ColumnName = gridColumn.ColumnName,
Visible = gridColumn.Visible
});
}
}
else
{
string cols = httpRequest.QueryString[qsColumns];
string[] colParts = cols.Split(',', ';');
foreach (var colPart in colParts)
{
if (String.IsNullOrWhiteSpace(colPart))
{
continue;
}
string thisColPart = colPart.ToLower().Trim();
var gridColumn = gridColumns.SingleOrDefault(p => p.ColumnName.ToLower() == thisColPart);
if (gridColumn != null)
{
if (requestedColumns.SingleOrDefault(p=>p.ColumnName== gridColumn.ColumnName) == null)
{
requestedColumns.Add(
new ColumnVisibility()
{
ColumnName = gridColumn.ColumnName,
Visible = true
});
}
}
}
}
foreach (var gridColumn in gridColumns)
{
var requestedCol = requestedColumns.SingleOrDefault(p => p.ColumnName == gridColumn.ColumnName);
if (requestedCol == null)
{
requestedCol = new ColumnVisibility() { ColumnName = gridColumn.ColumnName, Visible = false };
requestedColumns.Add(requestedCol);
}
if (!requestedCol.Visible && gridColumn.Visible && !gridColumn.AllowChangeVisibility)
{
requestedCol.Visible = true;
}
}
options.ColumnVisibility.AddRange(requestedColumns);
return options;
}
private CBForestDocEnumerator GetDocEnumerator(QueryOptions options, out List<string> remainingIDs)
{
var forestOps = options.AsC4EnumeratorOptions();
var enumerator = default(CBForestDocEnumerator);
remainingIDs = new List<string>();
if(options.Keys != null) {
try {
remainingIDs = options.Keys.Cast<string>().ToList();
enumerator = new CBForestDocEnumerator(Forest, remainingIDs.ToArray(), forestOps);
} catch(InvalidCastException) {
Log.E(TAG, "options.keys must contain strings");
throw;
}
} else {
enumerator = new CBForestDocEnumerator(Forest, options.StartKey as string, options.EndKey as string, forestOps);
}
return enumerator;
}
public Task<QueryResult<PreparedQueryDefinition[]>> Get(string queryID, QueryOptions q)
{
return _client.Get<PreparedQueryDefinition[]>(string.Format("/v1/query/{0}", queryID), q).Execute();
}
public Task<QueryResult<PreparedQueryDefinition[]>> List(QueryOptions q)
{
return _client.Get<PreparedQueryDefinition[]>("/v1/query", q).Execute();
}
/// <summary>
/// Queries the specified view using the specified options
/// </summary>
/// <returns>The HTTP response containing the results of the query</returns>
/// <param name="context">The request context</param>
/// <param name="db">The database to run the query in</param>
/// <param name="view">The view to query</param>
/// <param name="options">The options to apply to the query</param>
public static CouchbaseLiteResponse QueryView(ICouchbaseListenerContext context, Database db, View view, QueryOptions options)
{
var result = view.QueryWithOptions(options);
object updateSeq = options.UpdateSeq ? (object)view.LastSequenceIndexed : null;
var mappedResult = new List<object>();
foreach (var row in result) {
row.Database = db;
var dict = row.AsJSONDictionary();
if (context.ContentOptions != DocumentContentOptions.None) {
var doc = dict.Get("doc").AsDictionary<string, object>();
if (doc != null) {
// Add content options:
RevisionInternal rev = new RevisionInternal(doc);
var status = new Status();
rev = DocumentMethods.ApplyOptions(context.ContentOptions, rev, context, db, status);
if (rev != null) {
dict["doc"] = rev.GetProperties();
}
}
}
mappedResult.Add(dict);
}
var body = new Body(new NonNullDictionary<string, object> {
{ "rows", mappedResult },
{ "total_rows", view.TotalRows },
{ "offset", options.Skip },
{ "update_seq", updateSeq }
});
var retVal = context.CreateResponse();
retVal.JsonBody = body;
return retVal;
}
public void WhenSerializing_ThenRoundrips()
{
var options = new QueryOptions
{
Content = { "foo", "bar" },
Tag = "wpf",
Max = 10,
Owner = new User
{
Id = 5,
Name = "kzu",
},
};
var json = new UsonSerializer().Serialize(options);
var value = new UsonSerializer().Deserialize<QueryOptions>(json);
Assert.Equal(options.Content.Count, value.Content.Count);
Assert.Equal(options.Tag, value.Tag);
Assert.Equal(options.Max, value.Max);
Assert.Equal(options.Owner.Id, value.Owner.Id);
Assert.Equal(options.Owner.Name, value.Owner.Name);
}
/// <summary>
/// List is used to get the most recent events an agent has received. This list can be optionally filtered by the name. This endpoint supports quasi-blocking queries. The index is not monotonic, nor does it provide provide LastContact or KnownLeader.
/// </summary>
/// <param name="name">The name of the event to filter for</param>
/// <param name="q">Customized query options</param>
/// <returns>An array of events</returns>
public QueryResult<UserEvent[]> List(string name, QueryOptions q)
{
return List(name, q, CancellationToken.None);
}
public void BoundStatement_QueryOptions_Are_Used()
{
var ps = GetPrepared();
var stmt = ps.Bind();
Assert.AreEqual(0, stmt.PageSize);
Assert.Null(stmt.ConsistencyLevel);
var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum).SetPageSize(100);
var session = GetInstance(queryOptions);
var request = (ExecuteRequest)session.GetRequest(stmt);
Assert.AreEqual(100, request.PageSize);
Assert.AreEqual(queryOptions.GetPageSize(), request.PageSize);
Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency);
Assert.AreEqual(ConsistencyLevel.Any, request.SerialConsistency);
}
public async Task<QueryResult<PreparedQueryDefinition[]>> Get(string queryID, QueryOptions q)
{
return await _client.Get<PreparedQueryDefinition[]>(string.Format("/v1/query/{0}", queryID), q).Execute().ConfigureAwait(false);
}
public async Task<QueryResult<PreparedQueryExecuteResponse>> Execute(string queryIDOrName, QueryOptions q)
{
return await _client.Get<PreparedQueryExecuteResponse>(string.Format("/v1/query/{0}/execute", queryIDOrName), q).Execute().ConfigureAwait(false);
}
private static extern int DnsQuery([MarshalAs(UnmanagedType.VBByRefStr)] ref string lpstrName, RecordType wType,
QueryOptions options, int pExtra, ref IntPtr ppQueryResultsSet, int pReserved);
private static extern int DnsQuery([MarshalAs(UnmanagedType.VBByRefStr)]ref string pszName, QueryTypes wType, QueryOptions options, int aipServers, ref IntPtr ppQueryResults, int pReserved);
/// <summary>
/// Acquire attempts to reserve a slot in the semaphore, blocking until success, interrupted via CancellationToken or if an error is encountered.
/// A provided CancellationToken can be used to abort the attempt.
/// There is no notification that the semaphore slot has been lost, but IsHeld may be set to False at any time due to session invalidation, communication errors, operator intervention, etc.
/// It is NOT safe to assume that the slot is held until Release() unless the Session is specifically created without any associated health checks.
/// By default Consul sessions prefer liveness over safety and an application must be able to handle the session being lost.
/// </summary>
/// <param name="ct">The cancellation token to cancel semaphore acquisition</param>
public CancellationToken Acquire(CancellationToken ct)
{
lock (_lock)
{
try
{
if (IsHeld)
{
// Check if we already hold the lock
throw new SemaphoreHeldException();
}
// Don't overwrite the CancellationTokenSource until AFTER we've tested for holding, since there might be tasks that are currently running for this lock.
if (_cts.IsCancellationRequested)
{
_cts.Dispose();
_cts = new CancellationTokenSource();
}
_cts = new CancellationTokenSource();
LockSession = Opts.Session;
// Check if we need to create a session first
if (string.IsNullOrEmpty(Opts.Session))
{
try
{
Opts.Session = CreateSession();
_sessionRenewTask = _client.Session.RenewPeriodic(Opts.SessionTTL, Opts.Session, WriteOptions.Empty, _cts.Token);
LockSession = Opts.Session;
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to create session", ex);
}
}
else
{
LockSession = Opts.Session;
}
var contender = _client.KV.Acquire(ContenderEntry(LockSession)).Response;
if (!contender)
{
throw new ApplicationException("Failed to make contender entry");
}
var qOpts = new QueryOptions()
{
WaitTime = DefaultSemaphoreWaitTime
};
while (!ct.IsCancellationRequested)
{
QueryResult<KVPair[]> pairs;
try
{
pairs = _client.KV.List(Opts.Prefix, qOpts);
}
catch (Exception ex)
{
throw new ApplicationException("Failed to read prefix", ex);
}
var lockPair = FindLock(pairs.Response);
if (lockPair.Flags != SemaphoreFlagValue)
{
throw new SemaphoreConflictException();
}
var semaphoreLock = DecodeLock(lockPair);
if (semaphoreLock.Limit != Opts.Limit)
{
throw new SemaphoreLimitConflictException(
string.Format("Semaphore limit conflict (lock: {0}, local: {1})", semaphoreLock.Limit,
Opts.Limit),
semaphoreLock.Limit, Opts.Limit);
}
PruneDeadHolders(semaphoreLock, pairs.Response);
if (semaphoreLock.Holders.Count >= semaphoreLock.Limit)
{
qOpts.WaitIndex = pairs.LastIndex;
continue;
}
semaphoreLock.Holders[LockSession] = true;
var newLock = EncodeLock(semaphoreLock, lockPair.ModifyIndex);
if (ct.IsCancellationRequested)
{
_cts.Cancel();
throw new TaskCanceledException();
}
// Handle the case of not getting the lock
if (!_client.KV.CAS(newLock).Response)
{
continue;
}
IsHeld = true;
_monitorTask = MonitorLock(LockSession);
return _cts.Token;
}
throw new SemaphoreNotHeldException("Unable to acquire the semaphore with Consul");
}
finally
{
if (ct.IsCancellationRequested || (!IsHeld && !string.IsNullOrEmpty(Opts.Session)))
{
_cts.Cancel();
_client.KV.Delete(ContenderEntry(LockSession).Key);
if (_sessionRenewTask != null)
{
try
{
_sessionRenewTask.Wait();
}
catch (AggregateException)
{
// Ignore AggregateExceptions from the tasks during Release, since if the Renew task died, the developer will be Super Confused if they see the exception during Release.
}
}
}
}
}
}
/// <summary>
/// List is used to get the most recent events an agent has received. This list can be optionally filtered by the name. This endpoint supports quasi-blocking queries. The index is not monotonic, nor does it provide provide LastContact or KnownLeader.
/// </summary>
/// <param name="name">The name of the event to filter for</param>
/// <param name="q">Customized query options</param>
/// <param name="ct">Cancellation token for long poll request. If set, OperationCanceledException will be thrown if the request is cancelled before completing</param>
/// <returns>An array of events</returns>
public QueryResult<UserEvent[]> List(string name, QueryOptions q, CancellationToken ct)
{
var req = _client.CreateQuery<UserEvent[]>("/v1/event/list", q);
if (!string.IsNullOrEmpty(name))
{
req.Params["name"] = name;
}
return req.Execute(ct);
}
/// <summary>
/// monitorLock is a long running routine to monitor a semaphore ownership
/// It sets IsHeld to false if we lose our slot.
/// </summary>
/// <param name="lockSession">The session ID to monitor</param>
private Task MonitorLock(string lockSession)
{
return Task.Run(() =>
{
try
{
var opts = new QueryOptions() { Consistency = ConsistencyMode.Consistent };
while (IsHeld && !_cts.Token.IsCancellationRequested)
{
var pairs = _client.KV.List(Opts.Prefix, opts);
if (pairs.Response != null)
{
var lockPair = FindLock(pairs.Response);
var semaphoreLock = DecodeLock(lockPair);
PruneDeadHolders(semaphoreLock, pairs.Response);
// Check to see if the current session holds a semaphore slot
if (semaphoreLock.Holders.ContainsKey(lockSession))
{
opts.WaitIndex = pairs.LastIndex;
}
else
{
// Slot is no longer held! Shut down everything.
IsHeld = false;
_cts.Cancel();
return;
}
}
// Failsafe in case the KV store is unavailable
else
{
IsHeld = false;
_cts.Cancel();
return;
}
}
}
finally
{
IsHeld = false;
}
});
}
//Do an all document request on the database (i.e. fetch all docs given some options)
private static CouchbaseLiteResponse DoAllDocs(ICouchbaseListenerContext context, Database db, QueryOptions options)
{
var iterator = db.GetAllDocs(options);
if (iterator == null) {
return context.CreateResponse(StatusCode.BadJson);
}
var response = context.CreateResponse();
var result = (from row in iterator
select row.AsJSONDictionary()).ToList();
response.JsonBody = new Body(new NonNullDictionary<string, object> {
{ "rows", result },
{ "total_rows", result.Count },
{ "offset", options.Skip },
{ "update_seq", options.UpdateSeq ? (object)db.GetLastSequenceNumber() : null }
});
return response;
}
public Task<QueryResult<PreparedQueryExecuteResponse>> Execute(string queryIDOrName, QueryOptions q)
{
return _client.Get<PreparedQueryExecuteResponse>(string.Format("/v1/query/{0}/execute", queryIDOrName), q).Execute();
}
