public void Fill(Dictionary <LookupToken, IEnumerable> lookups, IRetriever retriever)
{
using (HeavyProfiler.Log("SQL", () => Command.Sql))
using (DbDataReader reader = Executor.UnsafeExecuteDataReader(Command))
{
ProjectionRowEnumerator <KeyValuePair <K, V> > enumerator = new ProjectionRowEnumerator <KeyValuePair <K, V> >(reader, ProjectorExpression, lookups, retriever);
IEnumerable <KeyValuePair <K, V> > enumerabe = new ProjectionRowEnumerable <KeyValuePair <K, V> >(enumerator);
try
{
var lookUp = enumerabe.ToLookup(a => a.Key, a => a.Value);
lookups.Add(Token, lookUp);
}
catch (Exception ex)
{
FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex);
fieldEx.Command = Command;
fieldEx.Row = enumerator.Row;
fieldEx.Projector = ProjectorExpression;
throw fieldEx;
}
}
}
/// <summary>
/// Creates a new cache based on the given {@link Retriever} and with given maximum size.
/// </summary>
/// <param name="retriever">object which can retrieve values for keys</param>
/// <param name="maxEntries">maximum number of entries the cache will store before evicting some</param>
public Cache(IRetriever <K, V> retriever, int maxEntries)
{
//Preconditions.checkArgument(retriever != null, "retriever is null");
//Preconditions.checkArgument(maxEntries >= 1, "maxEntries must be at least 1");
cache = new Dictionary <K, V>(11);
this.retriever = retriever;
}
public MList <T> GetMList(PrimaryKey id, IRetriever retriever)
{
Interlocked.Increment(ref hits);
MList <T> result;
var dic = relationalRows.Value.TryGetC(id);
if (dic == null)
{
result = new MList <T>();
}
else
{
result = new MList <T>(dic.Count);
var innerList = ((IMListPrivate <T>)result).InnerList;
foreach (var obj in dic.Values)
{
innerList.Add(activator(obj, retriever));
}
((IMListPrivate)result).ExecutePostRetrieving();
}
CachedTableConstructor.resetModifiedAction(retriever, result);
return(result);
}
public async Task FillAsync(Dictionary <LookupToken, IEnumerable> lookups, IRetriever retriever, CancellationToken token)
{
using (HeavyProfiler.Log("SQL", () => Command.Sql))
using (DbDataReader reader = await Executor.UnsafeExecuteDataReaderAsync(Command, token: token))
{
ProjectionRowEnumerator <KeyValuePair <K, V> > enumerator = new ProjectionRowEnumerator <KeyValuePair <K, V> >(reader, ProjectorExpression, lookups, retriever, token);
IEnumerable <KeyValuePair <K, V> > enumerabe = new ProjectionRowEnumerable <KeyValuePair <K, V> >(enumerator);
try
{
var lookUp = enumerabe.ToLookup(a => a.Key, a => a.Value);
lookups.Add(Token, lookUp);
}
catch (Exception ex) when(!(ex is OperationCanceledException))
{
FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex);
fieldEx.Command = Command;
fieldEx.Row = enumerator.Row;
fieldEx.Projector = ProjectorExpression;
throw fieldEx;
}
}
}
/// <summary>
/// Download metar asynchronously.
/// </summary>
/// <param name="icao">Icao code of airport/station.</param>
/// <param name="retriever">Metar retrievere used to decode metar from source stream</param>
/// <param name="downloadCompletedDelegate">Delegate function raised when download is completed or error occured.</param>
/// <exception cref="DownloadException">
/// Raised when any error occurs.
/// </exception>
public static void DownloadAsync(string icao, IRetriever retriever,
DownloadCompletedDelegate downloadCompletedDelegate)
{
Downloader d = new Downloader(retriever);
d.DownloadAsync(icao, downloadCompletedDelegate);
}
public SearchEngine(SearchEngineConfig config)
{
mConfig = config;
mQueryParser = new SimpleQueryParser(new QueryParserConfig
{
TextSegmenter = config.TextSegmenter,
});
mRetriever = new InexactTopKRetriever(new RetrieverConfig
{
PostingListStore = config.PostingListStore,
UrlFileStore = config.UrlFileStore,
InvertedIndexStore = config.InvertedIndexStore,
}, ResultSize);
var rankerConfig = new RankerConfig
{
PostingListStore = config.PostingListStore,
UrlFileStore = config.UrlFileStore,
InvertedIndexStore = config.InvertedIndexStore,
};
mRanker = new IntegratedRanker(rankerConfig);
mProRanker = new QueryTermProximityRanker(rankerConfig);
mLogger = new RuntimeLogger(Path.Combine(config.LogDirectory, "SearchEngine.Log"), true);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="retryRetriever"></param>
/// <param name="retryPolicyExceptionHandler"></param>
public RetryPolicyMiddleware(
IRetriever retryRetriever,
IRetryPolicyExceptionHandler retryPolicyExceptionHandler)
{
_retryRetriever = retryRetriever;
_retryPolicyExceptionHandler = retryPolicyExceptionHandler;
}
public Lite <T> GetLite(PrimaryKey id, IRetriever retriever)
{
Interlocked.Increment(ref hits);
var lite = (LiteImp <T>)Lite.Create <T>(id, toStrings.Value[id]);
return(retriever.ModifiablePostRetrieving(lite) !);
}
/// <summary>
/// Download metar synchronously.
/// </summary>
/// <param name="icao">Icao code of airport/station.</param>
/// <param name="retriever">Metar retrievere used to decode metar from source stream</param>
/// <returns>Metar as string.</returns>
/// <exception cref="DownloadException">
/// Raised when any error occurs.
/// </exception>
public static string Download(string icao, IRetriever retriever)
{
Downloader d = new Downloader(retriever);
string ret = d.Download(icao);
return(ret);
}
public async Task Run(IRetriever <TIn, TOut> retriever, HttpContext context)
{
var input = await _parseModel(context);
var response = await _middleware.Run(() => retriever.Retrieve(input));
await _parseResponse(context, response);
}
public Scheduler()
{
this.CanPauseAndContinue = true;
_handlers = new HashSet <IHandler>();
_schedules = new ConcurrentDictionary <ITrigger, ScheduleToken>(TriggerComparer.Instance);
_triggers = new TriggerCollection(_schedules);
_retriever = new Retriever();
}
public Scheduler(string name = null) : base(name)
{
this.CanPauseAndContinue = true;
_sequence = 1;
_retriever = new Retriever();
_schedules = new ConcurrentDictionary <long, ScheduleToken>();
_schedulars = new ConcurrentDictionary <ITrigger, SchedularToken>();
}
internal void ReleaseRetriever(IRetriever retriever)
{
if (this.retriever == null || this.retriever != retriever)
{
throw new InvalidOperationException("Inconsistent state of the retriever");
}
this.retriever = retriever.Parent;
}
public ReasoningCycle AddRetriever(IRetriever caseRetriever)
{
if (caseRetriever == null)
{
throw new ArgumentNullException(nameof(caseRetriever));
}
Retrievers.Add(caseRetriever);
return(this);
}
public override List <T> RequestByBackReference <R>(IRetriever retriever, Expression <Func <T, Lite <R>?> > backReference, Lite <R> lite)
{
// throw new InvalidOperationException(); /*CSBUG https://github.com/dotnet/roslyn/issues/33276*/
var dic = this.cachedTable.GetBackReferenceDictionary(backReference);
var ids = dic.TryGetC(lite.Id).EmptyIfNull();
return(ids.Select(id => retriever.Complete <T>(id, e => this.Complete(e, retriever)) !).ToList());
}
public Downloader(IRetriever retriever)
{
if (retriever == null)
{
throw new ArgumentNullException(nameof(retriever));
}
_retriever = retriever;
}
public object Execute()
{
using (new EntityCache())
using (Transaction tr = new Transaction())
{
object result;
using (IRetriever retriever = EntityCache.NewRetriever())
{
if (EagerProjections.Any() || LazyChildProjections.Any())
{
lookups = new Dictionary <LookupToken, IEnumerable>();
}
foreach (var chils in EagerProjections)
{
chils.Fill(lookups, retriever);
}
using (HeavyProfiler.Log("SQL", () => MainCommand.PlainSql()))
using (DbDataReader reader = Executor.UnsafeExecuteDataReader(MainCommand))
{
ProjectionRowEnumerator <T> enumerator = new ProjectionRowEnumerator <T>(reader, ProjectorExpression, lookups, retriever);
IEnumerable <T> enumerable = new ProjectionRowEnumerable <T>(enumerator);
try
{
if (Unique == null)
{
result = enumerable.ToList();
}
else
{
result = UniqueMethod(enumerable, Unique.Value);
}
}
catch (Exception ex)
{
FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex);
fieldEx.Command = MainCommand;
fieldEx.Row = enumerator.Row;
fieldEx.Projector = ProjectorExpression;
throw fieldEx;
}
}
foreach (var chils in LazyChildProjections)
{
chils.Fill(lookups, retriever);
}
}
return(tr.Commit(result));
}
}
/// <summary>
/// Constructor
/// </summary>
public DomainEventMediator(
IServiceScopeFactory serviceScopeFactory,
IDomainEventJsonDeserializer deserializer,
ICustomLogger <InMemoryDomainEventsConsumer> logger,
IRetriever retriever)
{
_serviceScopeFactory = serviceScopeFactory;
_deserializer = deserializer;
_logger = logger;
_retriever = retriever;
}
public IRetriever NewRetriever()
{
if (retriever == null)
{
retriever = new RealRetriever(this);
}
else
{
retriever = new ChildRetriever(retriever, this);
}
return(retriever);
}
public void Complete(T entity, IRetriever retriever)
{
Interlocked.Increment(ref hits);
var origin = this.GetRows().TryGetC(entity.Id);
if (origin == null)
{
throw new EntityNotFoundException(typeof(T), entity.Id);
}
completer(origin, retriever, entity);
}
/// <summary>
/// Main constructor for ConfigRetriever
/// </summary>
/// <param name="retriever"><see cref="IRetriever"/>
/// Interface for retrieve data from configuration system.
/// Usualy <see cref="GH.DD.ConfigRetriever.Retrievers.ConsulRetriever"/>
/// for retrieve from Consul</param>
public ConfigRetriever(IRetriever retriever, ILogger logger = null)
{
_retriever = retriever ?? throw new ArgumentNullException(nameof(retriever));
_walker = new ConfigWalker <TItem>();
_convertProvider = new ConvertProvider();
_configMapper = new ConfigMapper <TItem>();
_logger = logger;
if (logger == null)
{
_logger = _defaultLogger;
}
}
private static async Task TryRunPipeline <TIn, TOut>(
IServiceProvider sp,
PipelineInstructions <TIn, TOut> instructions,
IRetriever <TIn, TOut> retriever,
HttpContext context)
{
var(pipeline, ok) = instructions.TryGetPipeline <TIn, TOut>(sp);
if (!ok)
{
throw new Exception("Could not create pipeline");
}
await pipeline.Run(retriever, context);
}
private static async Task <(bool Success, string Result)> TryGetPublicAsync(IRetriever retriever, CancellationToken cancellationToken)
{
try
{
HttpResponseMessage response = await Client.GetAsync(retriever.Uri, cancellationToken).ConfigureAwait(false);
string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
return(true, retriever.Parse(content));
}
catch
{
return(false, null !);
}
}
public CachingRecommender(IRecommender recommender)
{
//Preconditions.checkArgument(recommender != null, "recommender is null");
this.recommender = recommender;
maxHowMany = new int[] { 1 };
// Use "num users" as an upper limit on cache size. Rough guess.
int numUsers = recommender.GetDataModel().GetNumUsers();
recommendationsRetriever = new RecommendationRetriever(this);
recommendationCache = new Cache <long, Recommendations>(recommendationsRetriever, numUsers);
estimatedPrefCache = new Cache <Tuple <long, long>, float>(new EstimatedPrefRetriever(this), numUsers);
refreshHelper = new RefreshHelper(() => {
clear();
});
refreshHelper.AddDependency(recommender);
}
void SetInMemory(T entity, IRetriever retriever)
{
if (!ShouldSet())
{
return;
}
if (ValueFunction == null)
{
throw new InvalidOperationException($"ValueFunction should be set in AdditionalBinding {PropertyRoute} because {PropertyRoute.Type} is Cached");
}
var setValue = _setter ?? (_setter = CreateSetter());
setValue(entity, retriever);
}
public object ReadObject(string name)
{
DateTime current = DateTime.Now;
DataRow row = TrySelectRowWithKeys(name);
IRetriever retriever = PlugInFactoryManager.CreateInstance <IRetriever>(
WeDataObjectPlugInFactory.REG_NAME, name);
WeixinResult result;
if (row == null)
{
result = retriever.RetrieveData();
if (!result.IsError)
{
row = NewRow();
row.BeginEdit();
row["DataKey"] = row["DataPlug"] = name;
row["Data"] = result.WriteJson();
row["CreateDate"] = current;
row["ValidDate"] = current.AddDays(3);
row.EndEdit();
SetCommands(AdapterCommand.Insert);
UpdateDatabase();
}
}
else
{
if (row["ValidDate"].Value <DateTime>() >= current)
{
result = retriever.ReadData(row["Data"].ToString());
}
else
{
result = retriever.RetrieveData();
if (!result.IsError)
{
row.BeginEdit();
row["Data"] = result.WriteJson();
row["ValidDate"] = current.AddDays(3);
row.EndEdit();
SetCommands(AdapterCommand.Update);
UpdateDatabase();
}
}
}
return(result);
}
private static (bool Success, string Result) TryGetPublic(IRetriever retriever)
{
try
{
HttpWebRequest request = WebRequest.CreateHttp(retriever.Uri);
using HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using Stream stream = response.GetResponseStream();
using StreamReader reader = new StreamReader(stream);
string content = reader.ReadToEnd();
return(true, retriever.Parse(content));
}
catch
{
return(false, null !);
}
}
public async Task FillAsync(Dictionary <LookupToken, IEnumerable> lookups, IRetriever retriever, CancellationToken token)
{
Dictionary <K, MList <V> > requests = (Dictionary <K, MList <V> >)lookups.TryGetC(Token);
if (requests == null)
{
return;
}
using (HeavyProfiler.Log("SQL", () => Command.Sql))
using (DbDataReader reader = await Executor.UnsafeExecuteDataReaderAsync(Command, token: token))
{
ProjectionRowEnumerator <KeyValuePair <K, MList <V> .RowIdElement> > enumerator = new ProjectionRowEnumerator <KeyValuePair <K, MList <V> .RowIdElement> >(reader, ProjectorExpression, lookups, retriever, token);
IEnumerable <KeyValuePair <K, MList <V> .RowIdElement> > enumerabe = new ProjectionRowEnumerable <KeyValuePair <K, MList <V> .RowIdElement> >(enumerator);
try
{
var lookUp = enumerabe.ToLookup(a => a.Key, a => a.Value);
foreach (var kvp in requests)
{
var results = lookUp[kvp.Key];
((IMListPrivate <V>)kvp.Value).InnerList.AddRange(results);
((IMListPrivate <V>)kvp.Value).InnerListModified(results.Select(a => a.Element).ToList(), null);
retriever.ModifiablePostRetrieving(kvp.Value);
}
}
catch (Exception ex) when(!(ex is OperationCanceledException))
{
FieldReaderException fieldEx = enumerator.Reader.CreateFieldReaderException(ex);
fieldEx.Command = Command;
fieldEx.Row = enumerator.Row;
fieldEx.Projector = ProjectorExpression;
throw fieldEx;
}
}
}
public BaseHandlerModule(IRetriever readonlyRepository, IMessageHandlerFactory messageHandlerFactory, IPersistStuff persister)
{
_messageHandlerFactory = messageHandlerFactory;
_persister = persister;
this.RequiresHttps(true, null);
Get["/{environment?dev}/{provider}"] = parameters =>
{
try
{
var model = readonlyRepository.Get((string)parameters.environment, (string)parameters.provider);
var viewModel = new ViewModel
{
ConfigureModel = model,
};
return(View[viewModel]);
}
catch (Exception ex)
{
return(ErrorResponse.FromException(ex).WithStatusCode(500));
}
};
Post["/{environment?dev}/{provider}"] = parameters =>
{
var configureModel = readonlyRepository.Get(parameters.environment, parameters.provider) as ConfigureModel;
string contents = Respond(Request.Body, configureModel, parameters.provider);
var byteArray = Encoding.UTF8.GetBytes(contents);
var stream = new MemoryStream(byteArray);
return(Response.FromStream(stream, "text/xml; charset=utf-8"));
};
Post["/{environment?dev}/{provider}/Update"] = parameters =>
{
UpdateConfiguration(parameters.provider, parameters.environment);
return(Response.AsRedirect($"/{(string) parameters.environment}/{(string) parameters.provider}"));
};
}
public void Complete(T entity, IRetriever retriever)
{
Interlocked.Increment(ref hits);
var origin = this.GetRows().TryGetC(entity.Id);
if (origin == null)
{
throw new EntityNotFoundException(typeof(T), entity.Id);
}
completer(origin, retriever, entity);
var additional = Schema.Current.GetAdditionalBindings(typeof(T));
if (additional != null)
{
foreach (var ab in additional)
{
ab.SetInMemory(entity, retriever);
}
}
}
public TvrageClient(IRetriever retriever)
: base(retriever)
{
_mapper = new TvrageMapper();
}
public ClientBase(IRetriever retriever)
{
this.Retriever = retriever;
Initialise();
}
