void ProcessFiles(string msg) { lock (_locker) if (_inBatch) { return; } //Open the folder and keep going until there are any files left //Skip any locked files try { if (LockPath(_inputFolder)) { Log.Debug("{0} ({1}\\{2})", msg, _inputFolder, _info.Filter); StartBatch(); FileSystemEnumerator fse = new FileSystemEnumerator(_inputFolder, _info.Filter ?? "*", includeSubDirs: false); int i = 0; foreach (FileInfo f in fse.Matches()) { if (!IsLocked(f.FullName)) { EnqueueFile(f.FullName, f.Name); ++i; } } Log.Debug("{0} - enqueued {1} files", msg, i); StopBatch(); UnlockPath(_inputFolder); } } catch (Exception e) { Log.Error("Exception processing files. ERROR: {0}", e.ToString().Replace("\n", " ")); } }
/// <summary> /// Finds all files within the CSData folder and loads them to memory /// </summary> /// <returns>Lazy loading coroutine, loading on demand</returns> private IEnumerator FindAllFiles() { string localPath = CSUtils.CSDataPath; Log($"Locating all files in CSData folder (@{localPath})"); //Locate data folder if (!Directory.Exists(localPath)) { Debug.LogWarning(DebugPrefix + "CSData folder could not be located. Creating new one."); Directory.CreateDirectory(localPath); yield break; //Created folder will be empty } //Enumerate through all files in all the folders starting at the root folder using (FileSystemEnumerator e = new FileSystemEnumerator(localPath, "*", true)) { //Loop through all "normal" files foreach (FileInfo file in e.Matches().Where(f => f.Attributes == FileAttributes.Normal && !string.IsNullOrEmpty(f.Extension))) { this.loadingbar.SetLabel("Locating file " + file.FullName); List <FileInfo> files; string jsonExt = Path.GetExtension(file.Name); //If there is a secondary extension, assume it's a potential Json file if (!string.IsNullOrEmpty(jsonExt)) { Dictionary <string, List <FileInfo> > jsonFiles; if (!this.jsonFilesByExt.TryGetValue(file.Extension, out jsonFiles)) { jsonFiles = new Dictionary <string, List <FileInfo> >(); this.jsonFilesByExt.Add(file.Extension, jsonFiles); } if (!jsonFiles.TryGetValue(jsonExt, out files)) { files = new List <FileInfo>(); jsonFiles.Add(jsonExt, files); } files.Add(file); } //If .dll file if (file.Extension == ".dll") { this.dlls.Add(file); } //Add to normal extension dict if (!this.filesByExt.TryGetValue(file.Extension, out files)) { files = new List <FileInfo>(); this.filesByExt.Add(file.Extension, files); } files.Add(file); this.allFiles.Add(file); Log("Located " + file.FullName); yield return(null); } } }
private Glob(string text, SegmentSequence[] segments) { this.text = text; this.segments = segments; this.regexCache = new Lazy<Regex>(MakeRegex); this.Enumerator = MakeEnumerator(); }
protected Glob(string text) { _TryParse(text, out segments); Glob g = Glob.Parse(text); this.text = text; this.regexCache = new Lazy<Regex>(MakeRegex); this.Enumerator = MakeEnumerator(); }
public void TestMethod1() { var currentDirectory = Path.Combine(Directory.GetCurrentDirectory(), "assets"); var fileSystemEnumerator = new FileSystemEnumerator(currentDirectory); var mySink = new FileSystemEventSink(); fileSystemEnumerator.RegisterEventSink(mySink); fileSystemEnumerator.Start(); }
/// <summary> /// ProcessSolicit /// </summary> public void ProcessSolicit(string requestId) { IDocumentManager documentManager; IRequestManager requestManager; AppendAuditLogEvent("Enter SolicitFilesFromFolder.ProcessSolicit({0})", requestId); GetServiceImplementation(out requestManager); GetServiceImplementation(out documentManager); string sourceFolderPath; if (!ConfigurationArguments.TryGetValue(SOURCE_FOLDER_PATH, out sourceFolderPath)) { throw new ArgumentException("SOURCE_FOLDER_PATH configuration key not set"); } if (!Directory.Exists(sourceFolderPath)) { throw new DirectoryNotFoundException(string.Format("SOURCE_FOLDER_PATH does not exist: {0}", sourceFolderPath)); } DataRequest dataRequest = requestManager.GetDataRequest(requestId); int docCount = 1; DateTime docsNewerThan = DateTime.MinValue; string stateId = null; if (dataRequest.Parameters.IsByName) { TryGetParameterByName(dataRequest, PARAM_STATE_ID, ref stateId); TryGetParameterByName(dataRequest, PARAM_DOCUMENT_COUNT, ref docCount); TryGetParameterByName(dataRequest, PARAM_DOCUMENTS_NEWER_THAN, ref docsNewerThan); } else { TryGetParameterByIndex(dataRequest, 0, ref stateId); TryGetParameterByIndex(dataRequest, 1, ref docCount); TryGetParameterByIndex(dataRequest, 2, ref docsNewerThan); } if (!string.IsNullOrEmpty(stateId)) { sourceFolderPath = Path.Combine(sourceFolderPath, stateId); if (!Directory.Exists(sourceFolderPath)) { throw new DirectoryNotFoundException(string.Format("State folder path does not exist: {0}", stateId)); } } if (docCount < 0) { throw new ArgumentException("Invalid document count specified: {0}", docCount.ToString()); } if (docsNewerThan > DateTime.Now.AddHours(2)) { throw new ArgumentException("Invalid documents-newer-than date specified: {0}", docsNewerThan.ToString()); } AppendAuditLogEvent("PARAM_DOCUMENT_COUNT ({0}), PARAM_DOCUMENTS_NEWER_THAN ({1})", docCount.ToString(), docsNewerThan.ToString()); List <KeyValuePair <string, DateTime> > docPaths = new List <KeyValuePair <string, DateTime> >(); using (FileSystemEnumerator enumerator = new FileSystemEnumerator(sourceFolderPath, "*", false, FileSystemEnumerator.EReturnTypes.eReturnFiles)) { foreach (string path in enumerator) { // Check date DateTime fileTime = File.GetLastWriteTime(path); if (fileTime > docsNewerThan) { docPaths.Add(new KeyValuePair <string, DateTime>(path, fileTime)); } } if (docPaths.Count > 0) { docPaths.Sort(delegate(KeyValuePair <string, DateTime> x, KeyValuePair <string, DateTime> y) { return(y.Value.CompareTo(x.Value)); }); if (docPaths.Count > docCount) { if (docCount > 0) { // Only return the # requested docPaths.RemoveRange(docCount, docPaths.Count - docCount); } } } } if (docPaths.Count > 0) { AppendAuditLogEvent("Found {0} document(s) to add to solicit request", docPaths.Count.ToString()); documentManager.AddDocument(dataRequest.TransactionId, CommonTransactionStatusCode.Processed, string.Empty, GetSolictZipFile(docPaths)); } else { AppendAuditLogEvent("Didn't find any documents to add to solicit request"); } AppendAuditLogEvent("Exit SolicitFilesFromFolder.ProcessSolicit({0})", requestId); }
public FileSystemTreeViewItemViewModel(DirectoryInfo folder) : this(null, folder, _ => FileSystemEnumerator.EnumerateChildren(folder)) { }
public override IEnumerable<Item> Enumerate( IEnumerable<Item> items, FileSystemEnumerator enumerator) { return items.Where(t => t.Item1.Length == 1 && (t.Item1[0] == Path.DirectorySeparatorChar || t.Item1[0] == Path.AltDirectorySeparatorChar)); }
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator) { return new [] { new Item(text, FileSystemEntity.File) }; }
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator) { Queue<Item> results = new Queue<Item>(items.OnlyDirectories()); while (results.Count > 0) { Item item = results.Dequeue(); yield return item; IEnumerable<Item> descendents = enumerator(FileSystemEntity.Directory, item.Item1); foreach (Item d in descendents) results.Enqueue(d); } }
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator) { var result = items.SelectMany(t => enumerator.Invoke(FileSystemEntity.FileOrDirectory, t.Item1)).Where(t => this.regex.IsMatch(t.Item1)); return result; }
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator) { foreach (Segment s in this.segments) { items = s.Enumerate(items, enumerator); } return items; }
public override IEnumerable<Item> Enumerate( IEnumerable<Item> items, FileSystemEnumerator enumerator) { string deviceName = (device + ":" + Path.DirectorySeparatorChar); return items.Concat(new [] { new Item(deviceName, FileSystemEntity.Directory) }); // return items.Where(t => string.Equals(t.Item1, device + ":", StringComparison.OrdinalIgnoreCase)); }
public override IEnumerable<Item> Enumerate( IEnumerable<Item> items, FileSystemEnumerator enumerator) { return items.SelectMany(t => enumerator.Invoke(FileSystemEntity.Directory, t.Item1)); }
public abstract IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator);
internal static IEnumerable<string> FilterDirectories(Glob glob, IEnumerable<string> directories, FileSystemEntity resultType, FileSystemEnumerator enumerator) { IEnumerable<Item> items = Enumerable.Empty<Item>(); IEnumerable<Item> subItemsStart = directories.Select( t => new Item(ExpandEnvironmentVariables(t), FileSystemEntity.Directory)).ToArray(); foreach (SegmentSequence sub in glob.segments) { IEnumerable<Item> subItems = subItemsStart; subItems = sub.Enumerate(subItems, enumerator); items = items.Concat(subItems); } // TODO Should inform the last segment of the result type rather than filter here return items .Where(t => t.Item2 == resultType) .Select(t => t.Item1) .Distinct(); }