private void DownloadFile1()
{
ReadOnlyControlFile controlFile = new ReadOnlyControlFile(_inputfilename);
IPodcastInfo info = GetPodcastInfo(controlFile, 0);
DisplayMessage(string.Format("Reading a feed: {0}", info.Feed.Address));
IList <ISyncItem> allEpisodes = GetAllEpisodesInFeed(controlFile, info);
if (allEpisodes.Count < 1)
{
DisplayMessage("No episodes in the feed - dont forget the state.xml file is being used", DisplayLevel.Warning);
return;
}
IList <ISyncItem> firstEpisode = new List <ISyncItem>(1);
firstEpisode.Add(allEpisodes.First());
DisplayMessage(string.Format("Downloading Eposode: {0}", firstEpisode.First().EpisodeTitle));
ISyncItemToEpisodeDownloaderTaskConverter converter = _iocContainer.Resolve <ISyncItemToEpisodeDownloaderTaskConverter>();
IEpisodeDownloader[] downloadTasks = converter.ConvertItemsToTasks(firstEpisode, StatusUpdate, ProgressUpdate);
// run them in a task pool
ITaskPool taskPool = _iocContainer.Resolve <ITaskPool>();
taskPool.RunAllTasks(1, downloadTasks);
DisplayMessage(string.Format("Download Complete", allEpisodes.Count));
}
private static ITaskPool GetPool(string name)
{
ITaskPool pool = null;
_lock.EnterUpgradeableReadLock();
try
{
if (_pools.TryGetValue(name, out pool) == false)
{
_lock.EnterWriteLock();
try
{
if (_pools.TryGetValue(name, out pool) == false)
{
pool = _createPool(DefaultPoolSize);
_pools[name] = pool;
}
}
finally
{
_lock.ExitWriteLock();
}
}
}
finally
{
_lock.ExitUpgradeableReadLock();
}
return(pool);
}
public DownloadViewModel(
Application app,
ILogger logger,
IResourceProvider resProvider,
IApplicationControlFileProvider appControlFileProvider,
IFileSystemHelper fileSystemHelper,
IByteConverter byteConverter,
IEpisodeFinder podcastEpisodeFinder,
ISyncItemToEpisodeDownloaderTaskConverter converter,
ITaskPool taskPool,
ICrashReporter crashReporter,
IAnalyticsEngine analyticsEngine,
IStatusAndProgressMessageStore messageStore,
INetworkHelper networkHelper,
IUserSettings userSettings) : base(app)
{
ApplicationContext = app;
Logger = logger;
Logger.Debug(() => $"DownloadViewModel:ctor");
ResourceProvider = resProvider;
ApplicationControlFileProvider = appControlFileProvider;
FileSystemHelper = fileSystemHelper;
ByteConverter = byteConverter;
PodcastEpisodeFinder = podcastEpisodeFinder;
Converter = converter;
TaskPool = taskPool;
CrashReporter = crashReporter;
AnalyticsEngine = analyticsEngine;
MessageStore = messageStore;
NetworkHelper = networkHelper;
UserSettings = userSettings;
}
public TaskPoolHost(ILogger <TaskPoolHost> logger, ITaskPool taskPool, ITaskPoolOptions options)
{
_logger = logger;
_taskPool = taskPool ?? throw new ArgumentNullException(nameof(taskPool));
_options = options ?? throw new ArgumentNullException(nameof(options));
}
public CompositeOperation(ITaskPool taskPool,
IReadOnlyList <OperationGroup> groupedOperationsToExecute,
OperationInfo operationInfo)
{
_taskPool = taskPool;
_groupedOperationsToExecute = groupedOperationsToExecute;
Info = operationInfo;
}
static void Main(string[] args)
{
DisplayBanner();
if (args.Length < 1)
{
DisplayHelp();
return;
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Started - {0}", DateTime.Now.ToString());
Console.ResetColor();
_iocContainer = InitializeIocContainer();
_control = new ReadOnlyControlFile(args[0]);
_verbose = _control.GetDiagnosticOutput() == DiagnosticOutputLevel.Verbose;
_driveInfoProvider = _iocContainer.Resolve <IDriveInfoProvider>();
int numberOfConnections = _control.GetMaximumNumberOfConcurrentDownloads();
System.Net.ServicePointManager.DefaultConnectionLimit = numberOfConnections;
ResetCounters();
// find the episodes to download
var allEpisodes = new List <ISyncItem>(20);
var podcastEpisodeFinder = _iocContainer.Resolve <IEpisodeFinder>();
podcastEpisodeFinder.StatusUpdate += StatusUpdate;
foreach (var podcastInfo in _control.GetPodcasts())
{
var episodesInThisFeed = podcastEpisodeFinder.FindEpisodesToDownload(_control.GetSourceRoot(), _control.GetRetryWaitInSeconds(), podcastInfo, _control.GetDiagnosticRetainTemporaryFiles());
allEpisodes.AddRange(episodesInThisFeed);
}
_number_of_files_to_download = allEpisodes.Count;
_number_of_files_downloaded = 0;
if (_number_of_files_to_download > 0)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Downloading {0} episodes", _number_of_files_to_download);
Console.ResetColor();
// convert them to tasks
var converter = _iocContainer.Resolve <ISyncItemToEpisodeDownloaderTaskConverter>();
IEpisodeDownloader[] downloadTasks = converter.ConvertItemsToTasks(allEpisodes, StatusUpdate, ProgressUpdate);
// run them in a task pool
_taskPool = _iocContainer.Resolve <ITaskPool>();
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
_taskPool.RunAllTasks(numberOfConnections, downloadTasks);
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Done - {0}", DateTime.Now.ToString());
Console.ResetColor();
}
public void Setup()
{
ResetObservedResults();
MockApplication = A.Fake <Application>();
A.CallTo(() => MockApplication.PackageName).Returns("com.andrewandderek.podcastutilities");
MockLogger = A.Fake <ILogger>();
MockResourceProvider = A.Fake <IResourceProvider>();
MockFileSystemHelper = A.Fake <IFileSystemHelper>();
// there is 10MB free in the filesystem
A.CallTo(() => MockFileSystemHelper.GetAvailableFileSystemSizeInBytes(A <string> .Ignored)).Returns(1024 * 1024 * FREE_DISK_SPACE_MB);
MockApplicationControlFileProvider = A.Fake <IApplicationControlFileProvider>();
MockCrashReporter = A.Fake <ICrashReporter>();
MockAnalyticsEngine = A.Fake <IAnalyticsEngine>();
MockApplicationControlFileFactory = A.Fake <IApplicationControlFileFactory>();
MockPodcastEpisodeFinder = A.Fake <IEpisodeFinder>();
MockSyncItemToEpisodeDownloaderTaskConverter = A.Fake <ISyncItemToEpisodeDownloaderTaskConverter>();
MockTaskPool = A.Fake <ITaskPool>();
MockStatusAndProgressMessageStore = A.Fake <IStatusAndProgressMessageStore>();
MockNetworkHelper = A.Fake <INetworkHelper>();
A.CallTo(() => MockNetworkHelper.ActiveNetworkType).Returns(INetworkHelper.NetworkType.Wifi);
MockUserSettings = A.Fake <IUserSettings>();
ByteConverter = new ByteConverter();
SetupResources();
ViewModel = new DownloadViewModel(
MockApplication,
MockLogger,
MockResourceProvider,
MockApplicationControlFileProvider,
MockFileSystemHelper,
ByteConverter,
MockPodcastEpisodeFinder,
MockSyncItemToEpisodeDownloaderTaskConverter,
MockTaskPool,
MockCrashReporter,
MockAnalyticsEngine,
MockStatusAndProgressMessageStore,
MockNetworkHelper,
MockUserSettings
);
ViewModel.Observables.Title += SetTitle;
ViewModel.Observables.SetEmptyText += SetEmptyText;
ViewModel.Observables.StartProgress += StartProgress;
ViewModel.Observables.UpdateProgress += UpdateProgress;
ViewModel.Observables.EndProgress += EndProgress;
ViewModel.Observables.SetSyncItems += SetSyncItems;
ViewModel.Observables.DisplayMessage += DisplayMessage;
ViewModel.Observables.CellularPrompt += CellularPrompt;
ViewModel.Observables.StartDownloading += StartDownloading;
ViewModel.Observables.EndDownloading += EndDownloading;
ViewModel.Observables.UpdateItemProgress += UpdateItemProgress;
ViewModel.Observables.UpdateItemStatus += UpdateItemStatus;
ViewModel.Observables.ExitPrompt += ExitPrompt;
ViewModel.Observables.Exit += Exit;
}
public OperationsFactory(
ITaskPool taskPool,
IDirectoryService directoryService,
IFileService fileService,
IPathService pathService)
{
_taskPool = taskPool;
_directoryService = directoryService;
_fileService = fileService;
_pathService = pathService;
}
public OperationsTests()
{
var taskPoolMock = new Mock <ITaskPool>();
taskPoolMock
.Setup(m => m.ExecuteAsync(It.IsAny <Func <Task> >()))
.Returns <Func <Task> >(x => x());
_taskPool = taskPoolMock.Object;
var pathServiceMock = new Mock <IPathService>();
_pathService = pathServiceMock.Object;
}
private void InitializeTaskPool()
{
taskPool = new TaskPool(new TaskPoolManager());
taskPool.PropertyChanged += (sender, e) =>
{
if (e.PropertyName == "IsWorking")
{
IsSearching = taskPool.IsWorking;
ImgFilter.Visibility = IsSearching ? Visibility.Visible : Visibility.Hidden;
}
};
}
public static void AddPool(string name, ITaskPool pool)
{
_lock.EnterWriteLock();
try
{
if (_pools.ContainsKey(name) == false)
{
_pools[name] = pool;
}
else
{
throw new InvalidOperationException($"Pool with name={name} already exists.");
}
}
finally
{
_lock.ExitWriteLock();
}
}
public DownloadViewModel(
Application app,
ILogger logger,
IResourceProvider resProvider,
IEpisodeFinder podcastEpisodeFinder,
ISyncItemToEpisodeDownloaderTaskConverter converter,
ITaskPool taskPool,
IFileSystemHelper fileSystemHelper,
IByteConverter byteConverter) : base(app)
{
Logger = logger;
Logger.Debug(() => $"DownloadViewModel:ctor");
ResourceProvider = resProvider;
PodcastEpisodeFinder = podcastEpisodeFinder;
Converter = converter;
TaskPool = taskPool;
FileSystemHelper = fileSystemHelper;
ByteConverter = byteConverter;
}
private void Download()
{
AndroidApplication.Logger.Debug(() => $"MainActivity:Download");
OutputBuffer.Clear();
AddLineToOutput("Started");
DisplayOutput();
if (AndroidApplication.ControlFile == null || AllEpisodes.Count < 1)
{
AndroidApplication.Logger.Warning(() => $"MainActivity:Download - no control file or nothing to download");
AddLineToOutput("No control file or nothing to download");
DisplayOutput();
return;
}
//StartProgress();
ToastMessage("Started");
number_of_files_to_download = AllEpisodes.Count;
number_of_files_downloaded = 0;
if (number_of_files_to_download > 0)
{
// convert them to tasks
var converter = AndroidApplication.IocContainer.Resolve <ISyncItemToEpisodeDownloaderTaskConverter>();
IEpisodeDownloader[] downloadTasks = converter.ConvertItemsToTasks(AllEpisodes, StatusUpdate, ProgressUpdate);
foreach (var task in downloadTasks)
{
AndroidApplication.Logger.Warning(() => $"MainActivity:Download to: {task.SyncItem.DestinationPath}");
}
// run them in a task pool
TaskPool = AndroidApplication.IocContainer.Resolve <ITaskPool>();
TaskPool.RunAllTasks(AndroidApplication.ControlFile.GetMaximumNumberOfConcurrentDownloads(), downloadTasks);
}
AddLineToOutput("Done.");
ToastMessage("Done");
//EndProgress();
DisplayOutput();
}
protected FileAssembler(string fileName, long chunkCount)
: base(fileName, new FileSplitInfo(chunkCount), new ConcurrentFileDataHolder(fileName), new FileDataReader(fileName), new FileDataWriter(fileName))
{
_taskPool = PriorityTaskPool.Instance;
}
public SyncCompositeTaskConsumer(ITaskPool taskPool, SyncCompositeTaskQueue taskQueue)
{
this.taskQueue = taskQueue;
this.taskPool = taskPool;
}
public CompositeOperation(ITaskPool taskPool, IList <IOperation> operations)
{
_taskPool = taskPool;
_operations = operations;
}
public TaskEngine(IMatchView match, ITaskRunner taskRunner, IPathFinder pathFinder, bool isClient)
{
m_isClient = isClient;
m_match = match;
m_taskRunner = taskRunner;
m_pathFinder = pathFinder;
m_activeTasks = new List <TaskBase>();
m_idToActiveTask = new Dictionary <long, TaskBase>();
m_timeoutRequests = new List <PendingClientRequest>();
m_requests = new Dictionary <long, PendingClientRequest>();
m_mem = new TaskMemory();
m_expressions = new Dictionary <int, IExpression>
{
{ ExpressionCode.Value, new ValueExpression() },
{ ExpressionCode.Assign, new AssignmentExpression() },
{ ExpressionCode.Itertate, new IterateExpression() },
{ ExpressionCode.Get, new GetExpression() },
{ ExpressionCode.And, new AndExpression() },
{ ExpressionCode.Or, new OrExpression() },
{ ExpressionCode.Not, new NotExpression() },
{ ExpressionCode.Eq, new EqExpression() },
{ ExpressionCode.NotEq, new NotEqExpression() },
{ ExpressionCode.Lt, new LtExpression() },
{ ExpressionCode.Lte, new LteExpression() },
{ ExpressionCode.Gt, new GtExpression() },
{ ExpressionCode.Gte, new GteExpression() },
{ ExpressionCode.Add, new AddExpression() },
{ ExpressionCode.Sub, new SubExpression() },
{ ExpressionCode.UnitExists, new UnitExistsExpression() },
{ ExpressionCode.UnitState, new UnitStateExpression() },
{ ExpressionCode.UnitCoordinate, new UnitCoordinateExpression() },
{ ExpressionCode.UnitCanGrow, new UnitCanGrowImmediateExpression() },
{ ExpressionCode.UnitCanSplit4, new UnitCanSplit4ImmediateExpression() },
{ ExpressionCode.UnitCanConvert, new UnitCanConvertImmediateExpression() },
{ ExpressionCode.TaskStatusCode, new TaskStatusExpression() },
{ ExpressionCode.TaskSucceded, new TaskSuccededExpression() },
{ ExpressionCode.TaskFailed, new TaskFailedExpression() },
{ ExpressionCode.CmdSucceded, new CmdSuccededExpression() },
{ ExpressionCode.CmdHardFailed, new CmdHardFailedExpression() },
{ ExpressionCode.CmdResultCode, new CmdResultCodeExpression() },
};
const int taskPoolSize = 10;
m_taskPools = new Dictionary <TaskType, ITaskPool>
{
{ TaskType.Sequence, new TaskPool <SequentialTask>(taskPoolSize) },
{ TaskType.Repeat, new TaskPool <RepeatTask>(taskPoolSize) },
{ TaskType.Branch, new TaskPool <BranchTask>(taskPoolSize) },
{ TaskType.Procedure, new TaskPool <ProcedureTask>(taskPoolSize) },
{ TaskType.Break, new TaskPool <BreakTask>(taskPoolSize) },
{ TaskType.Continue, new TaskPool <ContinueTask>(taskPoolSize) },
{ TaskType.Return, new TaskPool <ReturnTask>(taskPoolSize) },
{ TaskType.Nop, new TaskPool <NopTask>(taskPoolSize) },
{ TaskType.EvalExpression, new TaskPool <EvaluateExpressionTask>(taskPoolSize) },
{ TaskType.FindPath, new TaskPool <FindPathTask>(taskPoolSize) },
{ TaskType.FindPathToRandomLocation, new TaskPool <FindPathToRandLocationPath>(taskPoolSize) },
{ TaskType.SearchForFood, new TaskPool <SearchAroundForFood>(taskPoolSize) },
{ TaskType.SearchForGrowLocation, new TaskPool <SearchAroundForGrowLocation>(taskPoolSize) },
{ TaskType.SearchForSplit4Location, new TaskPool <SearchAroundForSplit4Location>(taskPoolSize) },
//For testing purposes
{ TaskType.TEST_Mock, new TaskPool <MockTask>(taskPoolSize) },
{ TaskType.TEST_MockImmediate, new TaskPool <MockImmediateTask>(taskPoolSize) },
{ TaskType.TEST_Fail, new TaskPool <TestFailTask>(taskPoolSize) },
{ TaskType.TEST_Pass, new TaskPool <TestPassTask>(taskPoolSize) },
{ TaskType.TEST_Assert, new TaskPool <TestAssertTask>(taskPoolSize) },
{ TaskType.TEST_SearchForWall, new TaskPool <TestSearchAroundForWallTask>(taskPoolSize) },
{ TaskType.DEBUG_Log, new TaskPool <LogTask>(taskPoolSize) },
{ TaskType.DEBUG_LogWarning, new TaskPool <LogWarningTask>(taskPoolSize) },
{ TaskType.DEBUG_LogError, new TaskPool <LogErrorTask>(taskPoolSize) },
};
m_cmdExpressionTaskPool = new TaskPool <ExecuteCmdTaskWithExpression>(taskPoolSize);
m_cmdMoveTaskPool = new TaskPool <ExecuteMoveTask>(taskPoolSize);
m_cmdGenericTaskPool = new TaskPool <ExecuteCmdTask>(taskPoolSize);
}
public CompositeTaskExecutor(ITaskPool taskPool)
{
this.taskReporter = new TaskReporter(taskPool);
this.syncTaskQueue = new SyncCompositeTaskQueue();
new SyncCompositeTaskConsumer(taskPool, syncTaskQueue).Start();
}
public void Initialize()
{
taskPoolManger = new TaskPoolManager();
instance = new TaskPool(taskPoolManger);
}
public TaskReporter(ITaskPool taskPool)
{
this.taskPool = taskPool;
this.returnedDataSetPool = new List <IDataSet>();
}
public TaskBucket(ITaskPool taskPool, ITaskScheduler taskScheduler, ILogger <ITaskBucket> logger)
{
_taskPool = taskPool ?? throw new ArgumentNullException(nameof(taskPool));
_taskScheduler = taskScheduler ?? throw new ArgumentNullException(nameof(taskScheduler));
_logger = logger;
}
public TaskExecutor(ITaskPool taskPool)
{
_taskPool = taskPool;
}
