public IEnumerable <Common.Models.DTO.Indexer> Indexers([FromQuery(Name = "configured")] bool configured)
{
var dto = IndexerService.GetAllIndexers().Select(i => new Common.Models.DTO.Indexer(i));
dto = configured ? dto.Where(i => i.configured) : dto;
return(dto);
}
public async Task <IActionResult> Test()
{
JToken jsonReply = new JObject();
try
{
await IndexerService.TestIndexer(CurrentIndexer.Id);
CurrentIndexer.LastError = null;
return(NoContent());
}
catch (Exception ex)
{
var msg = ex.Message;
if (ex.InnerException != null)
{
msg += ": " + ex.InnerException.Message;
}
if (CurrentIndexer != null)
{
CurrentIndexer.LastError = msg;
}
throw;
}
}
public async Task UpdateConfig([FromBody] Common.Models.DTO.ConfigItem[] config)
{
try
{
// HACK
var jsonString = JsonConvert.SerializeObject(config);
var json = JToken.Parse(jsonString);
var configurationResult = await CurrentIndexer.ApplyConfiguration(json);
if (configurationResult == IndexerConfigurationStatus.RequiresTesting)
{
await IndexerService.TestIndexer(CurrentIndexer.ID);
}
}
catch
{
var baseIndexer = CurrentIndexer as BaseIndexer;
if (null != baseIndexer)
{
baseIndexer.ResetBaseConfig();
}
throw;
}
}
public async Task <IActionResult> UpdateConfig([FromBody] Common.Models.DTO.ConfigItem[] config)
{
// invalidate cache for this indexer
cacheService.CleanIndexerCache(CurrentIndexer);
try
{
// HACK
var jsonString = JsonConvert.SerializeObject(config);
var json = JToken.Parse(jsonString);
var configurationResult = await CurrentIndexer.ApplyConfiguration(json);
if (configurationResult == IndexerConfigurationStatus.RequiresTesting)
{
await IndexerService.TestIndexer(CurrentIndexer.Id);
}
return(new NoContentResult());
}
catch
{
var baseIndexer = CurrentIndexer as BaseIndexer;
if (null != baseIndexer)
{
baseIndexer.ResetBaseConfig();
}
throw;
}
}
public void Setup()
{
_mockHelper = new Mock <IGenericIndexerHelper <Indexer.Core.Models.Provider.Provider> >();
_mockSettings =
Mock.Of <IIndexSettings <Indexer.Core.Models.Provider.Provider> >(
x => x.IndexesAlias == "testproviderindexesalias");
_sut = new IndexerService <Indexer.Core.Models.Provider.Provider>(_mockSettings, _mockHelper.Object, Mock.Of <ILog>());
}
public SolrMetadataIndexer(IGeoNorge geoNorge, Indexer indexer, IndexerApplication indexerApp, IndexerService indexerService, IndexDocumentCreator indexDocumentCreator, IErrorService errorService, IndexerAll indexerAll)
{
_geoNorge = geoNorge;
_indexer = indexer;
_indexerApplication = indexerApp;
_indexerService = indexerService;
_indexDocumentCreator = indexDocumentCreator;
_errorService = errorService;
_indexerAll = indexerAll;
}
public void and_returns_correct_events()
{
var bus = new Bus();
var ar = CombGuid.Generate();
Consumes <AssociatedIndexingPending> .All s = new IndexerService(bus, Path.Combine(Environment.CurrentDirectory, _Tmp, _BlobId.ToString()));
s.Consume(new AssociatedIndexingPending(DocumentState.AssociatedIndexingPending, _BlobId, ar, 2));
bus.Published.Should().Be.InstanceOf <DocumentIndexed>();
((DocumentIndexed)bus.Published).AggregateId.Equals(ar).Should().Be.True();
}
public async Task <Models.DTO.ManualSearchResult> Results([FromUri] Models.DTO.ApiSearch request)
{
var trackers = IndexerService.GetAllIndexers().Where(t => t.IsConfigured);
if (CurrentIndexer.ID != "all")
{
trackers = trackers.Where(t => t.ID == CurrentIndexer.ID).ToList();
}
trackers = trackers.Where(t => t.IsConfigured && t.CanHandleQuery(CurrentQuery));
var tasks = trackers.ToList().Select(t => t.ResultsForQuery(CurrentQuery)).ToList();
var aggregateTask = Task.WhenAll(tasks);
await aggregateTask;
var results = tasks.Where(t => t.Status == TaskStatus.RanToCompletion).Where(t => t.Result.Count() > 0).SelectMany(t =>
{
var searchResults = t.Result;
var indexer = searchResults.First().Origin;
cacheService.CacheRssResults(indexer, searchResults);
return(searchResults.Select(result =>
{
var item = AutoMapper.Mapper.Map <TrackerCacheResult>(result);
item.Tracker = indexer.DisplayName;
item.TrackerId = indexer.ID;
item.Peers = item.Peers - item.Seeders; // Use peers as leechers
return item;
}));
}).OrderByDescending(d => d.PublishDate).ToList();
ConfigureCacheResults(results);
var manualResult = new Models.DTO.ManualSearchResult()
{
Results = results,
Indexers = trackers.Select(t => t.DisplayName).ToList()
};
if (manualResult.Indexers.Count() == 0)
{
manualResult.Indexers = new List <string>()
{
"None"
}
}
;
logger.Info(string.Format("Manual search for \"{0}\" on {1} with {2} results.", CurrentQuery.SanitizedSearchTerm, string.Join(", ", manualResult.Indexers), manualResult.Results.Count()));
return(manualResult);
}
public static async Task Run([BlobTrigger("library-storage/unsorted/{name}", Connection = "AzureWebJobsDocumentLibStorage")] ICloudBlob blob, string name, ILogger log)
{
try
{
var indexerService = new IndexerService();
await indexerService.IndexSingleDocumentAsync(blob);
log.LogInformation($"Processed blob\n Name:{name} \n Size: Bytes");
}
catch (Exception ex)
{
log.LogError(ex.Message);
}
}
public void Delete() => IndexerService.DeleteIndexer(CurrentIndexer.Id);
public async Task <Models.DTO.ManualSearchResult> Results([FromUri] Models.DTO.ApiSearch request)
{
var manualResult = new ManualSearchResult();
var trackers = IndexerService.GetAllIndexers().Where(t => t.IsConfigured);
if (request.Tracker != null)
{
trackers = trackers.Where(t => request.Tracker.Contains(t.ID));
}
trackers = trackers.Where(t => t.CanHandleQuery(CurrentQuery));
var tasks = trackers.ToList().Select(t => t.ResultsForQuery(CurrentQuery)).ToList();
try
{
var aggregateTask = Task.WhenAll(tasks);
await aggregateTask;
}
catch (AggregateException aex)
{
foreach (var ex in aex.InnerExceptions)
{
logger.Error(ex);
}
}
catch (Exception ex)
{
logger.Error(ex);
}
manualResult.Indexers = tasks.Select(t =>
{
var resultIndexer = new ManualSearchResultIndexer();
IIndexer indexer = null;
if (t.Status == TaskStatus.RanToCompletion)
{
resultIndexer.Status = ManualSearchResultIndexerStatus.OK;
resultIndexer.Results = t.Result.Releases.Count();
resultIndexer.Error = null;
indexer = t.Result.Indexer;
}
else if (t.Exception.InnerException is IndexerException)
{
resultIndexer.Status = ManualSearchResultIndexerStatus.Error;
resultIndexer.Results = 0;
resultIndexer.Error = ((IndexerException)t.Exception.InnerException).ToString();
indexer = ((IndexerException)t.Exception.InnerException).Indexer;
}
else
{
resultIndexer.Status = ManualSearchResultIndexerStatus.Unknown;
resultIndexer.Results = 0;
resultIndexer.Error = null;
}
if (indexer != null)
{
resultIndexer.ID = indexer.ID;
resultIndexer.Name = indexer.DisplayName;
}
return(resultIndexer);
}).ToList();
manualResult.Results = tasks.Where(t => t.Status == TaskStatus.RanToCompletion).Where(t => t.Result.Releases.Count() > 0).SelectMany(t =>
{
var searchResults = t.Result.Releases;
var indexer = t.Result.Indexer;
cacheService.CacheRssResults(indexer, searchResults);
return(searchResults.Select(result =>
{
var item = AutoMapper.Mapper.Map <TrackerCacheResult>(result);
item.Tracker = indexer.DisplayName;
item.TrackerId = indexer.ID;
item.Peers = item.Peers - item.Seeders; // Use peers as leechers
return item;
}));
}).OrderByDescending(d => d.PublishDate).ToList();
ConfigureCacheResults(manualResult.Results);
logger.Info(string.Format("Manual search for \"{0}\" on {1} with {2} results.", CurrentQuery.SanitizedSearchTerm, string.Join(", ", manualResult.Indexers.Select(i => i.ID)), manualResult.Results.Count()));
return(manualResult);
}
public void Delete()
{
IndexerService.DeleteIndexer(CurrentIndexer.ID);
}
public IEnumerable <Common.Models.DTO.Indexer> Indexers()
{
var dto = IndexerService.GetAllIndexers().Select(i => new Common.Models.DTO.Indexer(i));
return(dto);
}
public void StartPoint(string name, string version, string frameworkFilter)
{
var indexer = new IndexerService(_log);
indexer.GetPackage(name, version, frameworkFilter);
}
