public void Init()
{
// NoteL IoC should not be necessary for unit testing
// Ref: http://msdn.microsoft.com/en-us/magazine/cc163358.aspx
_fileSelector = FileSelector.Instance; //IoC.Get<IFileSelector>();
}
public ConnectionDescriptionViewModel(
ConnectionDescription source,
ConnectionGroupViewModel parent,
KnownConnections knownConnections,
IFileSelector fileSelector,
ConnectionParameterViewModelFactory connectionParameterViewModelFactory)
{
Parent = parent;
_knownConnections = knownConnections;
_fileSelector = fileSelector;
_autoCheckTimer = new Timer(1000);
_autoCheckTimer.Elapsed += AutoCheckTimer_Elapsed;
_uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
_networkService = new NetworkService();
_connectionParameterViewModelFactory = connectionParameterViewModelFactory;
PingAccessibilityIconUri = new Uri("pack://application:,,,/Images/gray-icon.png");
PortAccessibilityIconUri = new Uri("pack://application:,,,/Images/gray-icon.png");
InitFromSource(source);
ConnectionTypes = _knownConnections._knownConnectionProfiles.Keys.Except(new[] { "NetCat" }).ToList();
SelectedConnectionType = Source.ConnectionTypeName;
}
public CommandHandler()
{
sender = DependencyResolver.Get <ISender>();
disconnector = DependencyResolver.Get <IDisconnector>();
fileSelector = DependencyResolver.Get <IFileSelector>();
self = this as ICommandHandler;
}
public void Init()
{
// NoteL IoC should not be necessary for unit testing
// Ref: http://msdn.microsoft.com/en-us/magazine/cc163358.aspx
_fileSelector = FileSelector.Instance; //IoC.Get<IFileSelector>();
}
public AssemblyBase Deserialize(IFileSelector selector)
{
using (FileStream reader = new FileStream(selector.FileToOpen(), FileMode.Open))
{
return(DataTransferGraph.AssemblyBase((AssemblyModel)serializer.ReadObject(reader)));
}
}
/// <summary>
/// <see cref="IFileObject.FindFiles"/>
/// </summary>
public IFileObject[] FindFiles(IFileSelector selector)
{
if (Type != FileType.Folder)
{
throw new FileSystemException(String.Format("Cannot search files in non-folder: {0}", Name)); // TODO: more structured exception
}
IFileObject[] children = GetChildren();
ArrayList resultList = new ArrayList(children.Length);
foreach (IFileObject file in children)
{
if (selector.IncludeFile(file))
{
resultList.Add(file);
}
if (file.Type == FileType.Folder)
{
if (selector.TraverseDescendents(file))
{
IFileObject[] foundFiles = file.FindFiles(selector);
resultList.AddRange(foundFiles);
}
}
}
return((IFileObject[])resultList.ToArray(typeof(IFileObject)));
}
public MainViewModel(IMediaEngineFacade engine,
ControlPanelViewModel controlViewModel,
IFileSelector fileSelector,
IDialogService dialogService,
ISettingsProvider settingsProvider,
IImageCreaterFactory imageCreaterFactory,
IDisplayService displayService,
IFailedStreamsContainer failedStreamsContainer,
ICursorManager cursorManager)
{
_engine = engine;
_controlViewModel = controlViewModel;
_fileSelector = fileSelector;
_dialogService = dialogService;
_settingsProvider = settingsProvider;
_imageCreaterFactory = imageCreaterFactory;
_displayService = displayService;
_failedStreamsContainer = failedStreamsContainer;
_cursorManager = cursorManager;
_settingsProvider.SettingChanged += _settingsProvider_SettingChanged;
ReadSettings();
Messenger.Default.Register <PropertyChangedMessageBase>(this, true, OnPropertyChanged);
Messenger.Default.Register <EventMessage>(this, true, OnEventMessage);
Messenger.Default.Register <PlayNewFileMessage>(this, true, OnPlayNewFile);
Messenger.Default.Register <PlayDiscMessage>(this, true, OnPlayDisc);
PackUpCommandBag();
}
private static int Search(SearchOptions options)
{
InitSearch(options);
SearchConfiguration config = LoadConfiguration();
string path = Directory.GetCurrentDirectory();
IFileSelector fileSelector = null;
if (options.FileFilter != null && options.FileFilterName == null)
{
fileSelector = ExtensibleFileSelectorBuilder.NewFileSelector()
.WithoutExcludedExtensions()
.WithExcludedPaths(config.ExcludedPaths)
.WithRegexFilter(options.FileFilter)
.WithoutExclusionRegex()
.WithMaxSize(config.MaxFileSize)
.Build();
}
else if (options.FileFilter == null && options.FileFilterName != null)
{
FileFilter fileFilter = config.FileFilters.First(filter =>
filter.Name.Equals(options.FileFilterName, StringComparison.InvariantCultureIgnoreCase));
if (fileFilter == null)
{
throw new ArgumentException($"File filter named '{options.FileFilterName}' does not exist. Please edit '{ConfigFileName}'.");
}
fileSelector = ExtensibleFileSelectorBuilder.NewFileSelector()
.WithoutExcludedExtensions()
.WithExcludedPaths(config.ExcludedPaths)
.WithRegexFilter(fileFilter.Regex)
.WithExclusionRegex(fileFilter.Exclusion)
.WithMaxSize(config.MaxFileSize)
.Build();
}
else
{
fileSelector = ExtensibleFileSelectorBuilder.NewFileSelector()
.WithExcludedExtensions(config.ExcludedExtensions)
.WithExcludedPaths(config.ExcludedPaths)
.WithoutRegexFilter()
.WithoutExclusionRegex()
.WithoutMaxSize()
.Build();
}
IContentSelector contentSelector = new RegexContentSelector(options.Query, options.CaseSensitive);
var flashSearcher = new FlashSearcher();
foreach (var result in flashSearcher.SearchContentInFolder(path, fileSelector, contentSelector))
{
_console.PrintSearchResult(result);
}
return(0);
}
public void Save(IFileSelector selector)
{
if (Metadata == null)
{
throw new InvalidOperationException("No metadata to save");
}
serializer.GetImport().Serialize(selector, DataTransferGraph.AssemblyBase(Metadata));
}
public void Serialize(IFileSelector selector, AssemblyBase ab)
{
AssemblyModel assemblyModel = new AssemblyModel(ab);
string path = selector.FileToSave("XML file (.xml) | *.xml");
using (FileStream writer = new FileStream(path, FileMode.OpenOrCreate))
{
serializer.WriteObject(writer, assemblyModel);
}
}
public FileSelectorPresenter(IFileSelector Panel, Model Model)
{
this.Panel = Panel;
this.Model = Model;
this.Panel.LoadDrive += ListDrives;
this.Panel.SelectDrive += SelectDrive;
this.Panel.SelectDrive += GetContent;
this.Panel.SelectDirectory += UpdatePath;
}
public void Serialize(IFileSelector supplier, AssemblyBase target)
{
System.Data.Entity.Database.SetInitializer(new DropCreateDatabaseAlways <DatabaseContext>());
DatabaseAssembly serializationModel = new DatabaseAssembly(target);
using (var ctx = new DatabaseContext())
{
ctx.AssemblyModel.Add(serializationModel);
ctx.SaveChanges();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
/// <param name="graphProvider">The <see cref="IGraphProvider"/>.</param>
/// <param name="fileSelector">The <see cref="IFileSelector"/>.</param>
/// <param name="messageHandler">The <see cref="IMessageHandler"/>.</param>
public MainWindowViewModel(IGraphProvider graphProvider, IFileSelector fileSelector, IMessageHandler messageHandler)
{
this.GraphViewModel = graphProvider ?? throw new ArgumentNullException("graphProvider");
this.FileSelector = fileSelector ?? throw new ArgumentNullException("fileSelector");
this.MessageHandler = messageHandler ?? throw new ArgumentNullException("messageHandler");
this.LoadGraphCommand = new RelayCommand(param => this.LoadGraph());
this.SaveGraphCommand = new RelayCommand(param => this.SaveGraph());
this.ExitCommand = new RelayCommand(param => App.Current.Shutdown());
this.AlgorithmMenuItems = AlgorithmsMenuBuilder.GetMenuItems(this.GraphViewModel, messageHandler);
}
public IEnumerable <FsFile> GetFiles(Dir dir, IFileSelector fileSelector)
{
var directory = FindDirectory(dir.FullName);
if (directory == null)
{
return new FsFile[] { }
}
;
return(fileSelector.SelectFiles(dir.FullName));
}
public MainForm(IApp app,
IFileSelector fileSelector,
IFileReader fileReader,
IMigrationDGVFactory migrationDGVFactory)
{
_app = app;
_fileSelector = fileSelector;
_fileReader = fileReader;
_migrationDGVFactory = migrationDGVFactory;
InitializeComponent();
dgv_Repos.ReadOnly = true;
}
public AssemblyBase Deserialize(IFileSelector supplier)
{
using (var ctx = new DatabaseContext())
{
ctx.AssemblyModel.Load();
ctx.NamespaceModel.Load();
ctx.TypeModel.Load();
ctx.MethodModel.Load();
ctx.FieldModel.Load();
ctx.PropertyModel.Load();
ctx.ParameterModel.Load();
return(DataTransferGraph.AssemblyBase(Load(ctx)));
}
}
public int CountFilesRecursively(Dir dir, IFileSelector selector)
{
if (dir == null)
{
throw new NullReferenceException("Illegal null-reference dir");
}
if (!Directory.Exists(dir.FullName))
{
return(0);
}
int result = 0;
Stack <DirectoryInfo> stack = new Stack <DirectoryInfo>();
stack.Push(new DirectoryInfo(dir.FullName));
while (stack.Count > 0)
{
DirectoryInfo top = stack.Pop();
try
{
var subDirs = top.GetDirectories();
foreach (var sd in subDirs)
{
stack.Push(sd);
}
result += selector.SelectFiles(top.FullName).Count();
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
return(result);
}
private void SearchContentInFolder(DirectoryInfo directory, IFileSelector fileSelector, IContentSelector contentSelector)
{
_forceCancellationTokenSource.Token.ThrowIfCancellationRequested();
if (_cancellationTokenSource.IsCancellationRequested)
{
return;
}
List <Task> tasks = new List <Task>();
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
{
tasks.Add(Task.Run(() => SearchContentInFolder(subDirectory, fileSelector, contentSelector)));
}
foreach (FileInfo file in directory.GetFiles())
{
if (_cancellationTokenSource.IsCancellationRequested)
{
return;
}
if (!fileSelector.IsFileValid(file))
{
continue;
}
foreach (SearchResult result in SearchContentInFile(file, contentSelector))
{
_results.Enqueue(result);
}
}
foreach (Task task in tasks)
{
task.Wait();
}
}
private void IndexDirectory(DirectoryInfo directory, IFileSelector fileSelector)
{
if (!fileSelector.IsDirectoryValid(directory))
{
return;
}
try
{
foreach (DirectoryInfo childDir in directory.GetDirectories())
{
if (_cancel)
{
return;
}
IndexDirectory(childDir, fileSelector);
}
foreach (FileInfo file in directory.GetFiles())
{
if (!fileSelector.IsFileValid(file))
{
continue;
}
if (_cancel)
{
return;
}
_indexableFiles.Enqueue(file);
++TotalFilesFound;
}
}
catch (Exception)
{
// TODO: Add better handling of error and logging. Maybe add NLog support ?
Console.WriteLine("Error while indexing directory: {0}", directory.FullName);
}
}
public void Load(IFileSelector selector)
{
Metadata = new AssemblyMetadata(serializer.GetImport().Deserialize(selector));
}
public IEnumerable <SearchResult> SearchContentInFolder(string directoryPath, IFileSelector fileSelector, IContentSelector contentSelector)
{
DirectoryInfo directory = new DirectoryInfo(directoryPath);
if (!directory.Exists)
{
_completed = true;
return(Enumerable.Empty <SearchResult>());
}
_cancellationTokenSource = new CancellationTokenSource();
_forceCancellationTokenSource = new CancellationTokenSource();
_completed = false;
Task.Run(() =>
{
_forceCancellationTokenSource.Token.ThrowIfCancellationRequested();
SearchContentInFolder(directory, fileSelector, contentSelector);
_completed = true;
});
return(this);
}
public DataService(IUnityContainer container, IScanner scanner, IFileSystem fileSystem, ITagsAccumulator tagsAccumulator, IFileSelector fileSelector)
{
this.container = container;
this.scanner = scanner;
this.fileSystem = fileSystem;
this.tagsAccumulator = tagsAccumulator;
this.fileSelector = fileSelector;
}
public int CountFilesRecursively(Dir dir, IFileSelector fileSelector)
{
var allFiles = EnumerateFiles();
return(allFiles.Count());
}
public IEnumerable <FsFile> GetFiles(Dir dir, IFileSelector selector)
{
return(selector.SelectFiles(dir.FullName));
}
public IEnumerable <SearchResult> SearchContentInFolder(string directoryPath, IFileSelector fileSelector, LuceneContentSelector luceneQuery)
{
_cancel = false;
if (!Directory.Exists(directoryPath))
{
throw new DirectoryNotFoundException($"Unable to find directory {directoryPath}");
}
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
Searcher searcher = new IndexSearcher(Lucene.Net.Store.FSDirectory.Open(_indexDirectory));
QueryParser queryParser = new QueryParser(Version.LUCENE_30, "LineContent", analyzer);
queryParser.AllowLeadingWildcard = true;
Query query = queryParser.Parse(luceneQuery.LuceneQuery);
TopDocs docs = searcher.Search(query, MaxSearchResults);
foreach (var topDoc in docs.ScoreDocs)
{
if (_cancel)
{
yield break;
}
Document doc = searcher.Doc(topDoc.Doc);
FileInfo file = new FileInfo(doc.GetField("Path").StringValue);
if (!file.FullName.StartsWith(directoryPath, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!fileSelector.IsFileValid(file) || !fileSelector.IsDirectoryValid(file.Directory))
{
continue;
}
string lineContent = doc.GetField("LineContent").StringValue;
List <MatchPosition> matches = luceneQuery.GetMatches(lineContent).ToList();
if (matches.Count == 0)
{
continue;
}
yield return(new SearchResult(
file,
Int32.Parse(doc.GetField("LineNumber").StringValue),
lineContent,
long.Parse(doc.GetField("LastWrite").StringValue),
matches));
}
}
public int CountFilesRecursively(Dir dir, IFileSelector fileSelector)
{
return(fs.CountFilesRecursively(dir, fileSelector));
}
public IEnumerable <FsFile> GetFiles(Dir dir, IFileSelector fileSelector)
{
return(fs.GetFiles(dir, fileSelector));
}
public MainViewModel(IFileSelector fileSelector, ISurplusCalculator surplusCalculator)
{
_fileSelector = fileSelector;
_surplusCalculator = surplusCalculator;
}
public void IndexContentInFolder(string directoryPath, IFileSelector fileSelector)
{
if (!Directory.Exists(directoryPath))
{
throw new DirectoryNotFoundException($"Unable to find directory {directoryPath}");
}
_indexableFiles = new ConcurrentQueue <FileInfo>();
FilesIndexed = 0;
TotalFilesFound = 0;
_ioCompleted = false;
CancellationTokenSource cancelIndexingTokenSource = new CancellationTokenSource();
CancellationToken cancelIndexingToken = cancelIndexingTokenSource.Token;
using (IndexWriter indexWriter = new IndexWriter(
new SimpleFSDirectory(_indexDirectory),
new StandardAnalyzer(Version.LUCENE_30),
false,
IndexWriter.MaxFieldLength.UNLIMITED))
using (Searcher searcher = new IndexSearcher(indexWriter.Directory))
{
Task indexDirectoryTask = Task.Run(() =>
{
cancelIndexingToken.ThrowIfCancellationRequested();
IndexDirectory(new DirectoryInfo(directoryPath), fileSelector);
}, cancelIndexingToken);
HashSet <string> allKnownPaths = new HashSet <string>();
TopDocs allTopDocs = searcher.Search(new MatchAllDocsQuery(), MaxSearchResults);
foreach (ScoreDoc scoreDoc in allTopDocs.ScoreDocs)
{
if (_cancel)
{
break;
}
Document doc = searcher.Doc(scoreDoc.Doc);
String path = doc.GetField("Path").StringValue;
if (allKnownPaths.Contains(path))
{
continue;
}
FileInfo fileInfo = new FileInfo(path);
if (!fileSelector.IsFileValid(fileInfo) || !fileSelector.IsDirectoryValid(fileInfo.Directory))
{
continue;
}
long lastWrite = long.Parse(doc.GetField("LastWrite").StringValue);
if (fileInfo.Exists)
{
IndexFile(indexWriter, searcher, fileInfo, lastWrite);
allKnownPaths.Add(path);
}
else
{
var query = new PhraseQuery();
query.Add(new Term("Path", path));
indexWriter.DeleteDocuments(query);
}
++FilesIndexed;
}
// How many indexers to spawn at first
int initialIndexersCount = 2;
// How much files must be queued before spawning help
int indexersScalingFactor = 1000;
// Max amount of indexers
int maxIndexersCount = 5;
List <Thread> threads = new List <Thread>();
for (int i = 0; i < initialIndexersCount; i++)
{
Thread t = new Thread(() => IndexLoop(indexWriter, searcher, allKnownPaths));
t.Start();
threads.Add(t);
}
while (true)
{
if (_cancel)
{
cancelIndexingTokenSource.Cancel();
_ioCompleted = true;
break;
}
if (indexDirectoryTask.IsCompleted)
{
_ioCompleted = true;
break;
}
if (threads.Count < maxIndexersCount && _indexableFiles.Count / threads.Count >= indexersScalingFactor)
{
Thread t = new Thread(() => IndexLoop(indexWriter, searcher, allKnownPaths));
t.Start();
threads.Add(t);
}
Thread.Sleep(100);
}
foreach (Thread thread in threads)
{
thread.Join();
}
}
}
public GeneralSettingsViewModel(ISettingsProvider settingsProvider, IFileSelector fileSelector)
{
_settingsProvider = settingsProvider;
_fileSelector = fileSelector;
Load();
}
public IFileObject[] FindFiles(IFileSelector selector)
{
return(null);
}
