public static Exists ( string path ) : bool | ||
path | string | |
Результат | bool |
/// <summary> /// Checks whether a certain sub-directory exists. /// </summary> /// <param name="path">The path of the directory.</param> /// <returns> /// <see langword="true" /> if the directory exists, <see langword="false" /> otherwise. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="path" /> is <see langword="null" /> (<see langword="Nothing" /> /// in Visual Basic). /// </exception> public bool Exists(string path) { _ = Requires.NotNullOrWhiteSpace( path, nameof(path)); return(FSDir.Exists(path)); }
public bool SetWorkshopItemContentFolder(ulong updateHandle, string contentFolder) { if (!Directory.Exists(contentFolder)) { throw new ArgumentException("content folder doesn't exist"); } return(Steam.SetItemContent(updateHandle, Path.GetFullPath(contentFolder))); }
// This method decides what action to take based on the type of // file we are looking at public static void doFile(FileInfo f) { // If this is a directory, walk each file/dir in that directory if (Directory.Exists(f.FullName)) { string[] files = Directory.GetFileSystemEntries(f.FullName); for (int i = 0; i < files.Length; i++) { doFile(new FileInfo(f.FullName + "\\" + files[i])); } } else if ((f.Name.Length > 5) && f.Name.Substring(f.Name.Length - 5).Equals(".java")) { Console.Error.WriteLine(" " + f.FullName); parseFile(f.Name, new FileStream(f.FullName, FileMode.Open, FileAccess.Read)); } }
private void PopulatePluginAssemblies() { var list = this.GetNode(@"Panel/ItemList") as Godot.ItemList; if (Directory.Exists(PluginsDirectoryName)) { var allFiles = Directory.GetFiles(PluginsDirectoryName, "*.dll"); foreach (var fileName in allFiles) { var assembly = Assembly.LoadFile(fileName); var data = new PluginData(fileName); data.Monsters = new List <AbstractMonster>(); var monsters = assembly.GetTypes().Where(t => t.BaseType == typeof(AbstractMonster)); foreach (var monsterType in monsters) { var instance = (AbstractMonster)monsterType.GetConstructor(new Type[0]).Invoke(new object[0]); data.Monsters.Add(instance); } data.LevelGenerators = new List <ILevelGenerator>(); var generators = assembly.GetTypes().Where(t => t.GetInterfaces().Any(i => i.Name.Contains("ILevelGenerator"))); foreach (var generatorType in generators) { var instance = (ILevelGenerator)generatorType.GetConstructor(new Type[0]).Invoke(new object[0]); data.LevelGenerators.Add(instance); } list.AddItem(fileName); pluginData.Add(data); } } else { list.AddItem("Plugins directory doesn't exist."); } }
/// <summary> /// This initializes the provider registry with the list of package providers. /// (currently a hardcoded list, soon, registry driven) /// </summary> /// <param name="request"></param> internal void LoadProviders(IHostApi request) { if (request == null) { throw new ArgumentNullException("request"); } var providerAssemblies = (_initialized ? Enumerable.Empty <string>() : _defaultProviders) .Concat(GetProvidersFromRegistry(Registry.LocalMachine, "SOFTWARE\\MICROSOFT\\PACKAGEMANAGEMENT")) .Concat(GetProvidersFromRegistry(Registry.CurrentUser, "SOFTWARE\\MICROSOFT\\PACKAGEMANAGEMENT")) .Concat(AutoloadedAssemblyLocations.SelectMany(location => { if (Directory.Exists(location)) { return(Directory.EnumerateFiles(location).Where(each => (each.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) || each.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)))); } return(Enumerable.Empty <string>()); })); #if DEEP_DEBUG providerAssemblies = providerAssemblies.ToArray(); foreach (var each in providerAssemblies) { request.Debug("possible assembly: {0}".format(each)); } #endif // find modules that have manifests // todo: expand this out to validate the assembly is ok for this instance of PackageManagement. providerAssemblies = providerAssemblies.Where(each => Manifest.LoadFrom(each).Any(manifest => Swidtag.IsSwidtag(manifest) && new Swidtag(manifest).IsApplicable(new Hashtable()))); // add inbox assemblies (don't require manifests, because they are versioned with the core) #if !COMMUNITY_BUILD // todo: these should just be strong-named references. for now, just load them from the same directory. providerAssemblies = providerAssemblies.Concat(new[] { Path.Combine(BaseDir, "Microsoft.PackageManagement.MetaProvider.PowerShell.dll"), Path.Combine(BaseDir, "Microsoft.PackageManagement.ArchiverProviders.dll"), Path.Combine(BaseDir, "Microsoft.PackageManagement.CoreProviders.dll"), Path.Combine(BaseDir, "Microsoft.PackageManagement.MsuProvider.dll"), #if !CORE_CLR // can't load these providers here. Path.Combine(BaseDir, "Microsoft.PackageManagement.MsiProvider.dll"), #endif }); #endif #if DEEP_DEBUG providerAssemblies = providerAssemblies.ToArray(); foreach (var each in providerAssemblies) { request.Debug("possible assembly with manifest: {0}".format(each)); } #endif providerAssemblies = providerAssemblies.OrderByDescending(each => { try { // try to get a version from the file first return((ulong)(FourPartVersion)FileVersionInfo.GetVersionInfo(each)); } catch { // otherwise we can't make a distinction. return((ulong)0); } }); providerAssemblies = providerAssemblies.Distinct(new PathEqualityComparer(PathCompareOption.FileWithoutExtension)); // there is no trouble with loading providers concurrently. #if DEEP_DEBUG providerAssemblies.SerialForEach(providerAssemblyName => { #else providerAssemblies.ParallelForEach(providerAssemblyName => { #endif TryToLoadProviderAssembly(providerAssemblyName, request); }); #if DEEP_DEBUG WaitForDebugger(); #endif }
private static string[] CollectPathsFromToolbox(string toolboxRiderRootPath, string dirName, string searchPattern, bool isMac) { if (!Directory.Exists(toolboxRiderRootPath)) { return(new string[0]); } var channelDirs = Directory.GetDirectories(toolboxRiderRootPath); var paths = channelDirs.SelectMany(channelDir => { try { // use history.json - last entry stands for the active build https://jetbrains.slack.com/archives/C07KNP99D/p1547807024066500?thread_ts=1547731708.057700&cid=C07KNP99D var historyFile = Path.Combine(channelDir, ".history.json"); if (File.Exists(historyFile)) { var json = File.ReadAllText(historyFile); var build = ToolboxHistory.GetLatestBuildFromJson(json); if (build != null) { var buildDir = Path.Combine(channelDir, build); var executablePaths = GetExecutablePaths(dirName, searchPattern, isMac, buildDir); if (executablePaths.Any()) { return(executablePaths); } } } var channelFile = Path.Combine(channelDir, ".channel.settings.json"); if (File.Exists(channelFile)) { var json = File.ReadAllText(channelFile).Replace("active-application", "active_application"); var build = ToolboxInstallData.GetLatestBuildFromJson(json); if (build != null) { var buildDir = Path.Combine(channelDir, build); var executablePaths = GetExecutablePaths(dirName, searchPattern, isMac, buildDir); if (executablePaths.Any()) { return(executablePaths); } } } // changes in toolbox json files format may brake the logic above, so return all found Rider installations return(Directory.GetDirectories(channelDir) .SelectMany(buildDir => GetExecutablePaths(dirName, searchPattern, isMac, buildDir))); } catch (Exception e) { // do not write to Debug.Log, just log it. Logger.Warn($"Failed to get RiderPath from {channelDir}", e); } return(new string[0]); }) .Where(c => !string.IsNullOrEmpty(c)) .ToArray(); return(paths); }
public Users(string dbUrl, string storageDir, string masterPassword) : base(dbUrl) { this.dbUrl = dbUrl; this.masterPassword = masterPassword; var avatarDir = Path.Combine(storageDir, "avatar"); if (!Dir.Exists(avatarDir)) { Dir.CreateDirectory(avatarDir); } // API only available to authenticated users BeforeAsync = async(p, c) => await c.EnsureIsAuthenticatedAsync(); // register a type Types["uid"] = (val) => (Regex.IsMatch(val, "^[A-Z0-9]+$")) ? val : null; GetAsync["/"] = async(p, c) => { await RunBeforeAsync(null, c); var authUser = await c.GetAuthenticatedUserAsync(); SqlFilter filterAuth; if (authUser.IsUser && c.Request.QueryString.ContainsKey("restrict")) { filterAuth = User.GenerateFilterAuthUser(authUser); } else { filterAuth = (new User()).FilterAuthUser(authUser); } using (DB db = await DB.CreateAsync(dbUrl)) { var result = await Model.SearchAsync <User>(db, c, filterAuth); foreach (var item in result.Data) { await item.EnsureRightAsync(c, Right.Read, null); } c.Response.Content = result.ToJson(c); } c.Response.StatusCode = 200; }; GetAsync["/current"] = async(p, c) => { var user = await c.GetAuthenticatedUserAsync(); if ((user == null) || !user.IsUser) { c.Response.StatusCode = 401; } else { c.Response.StatusCode = 302; c.Response.Headers["location"] = user.user.id; } }; GetAsync["/current/isauthenticated"] = async(p, c) => { var user = await c.GetAuthenticatedUserAsync(); if (user == null) { c.Response.StatusCode = 403; } else { c.Response.StatusCode = 200; } }; PostAsync["/{uid:uid}/upload/avatar"] = async(p, c) => { var uid = (string)p["uid"]; var oldUser = new User { id = uid }; using (var db = await DB.CreateAsync(dbUrl)) { if (!await oldUser.LoadAsync(db, true)) { oldUser = null; } } //var oldUser = await GetUserAsync(uid); if (oldUser == null) { return; } await c.EnsureHasRightsOnUserAsync(oldUser, true, true, false); var reader = c.Request.ReadAsMultipart(); MultipartPart part; while ((part = await reader.ReadPartAsync()) != null) { if (part.Headers.ContainsKey("content-disposition") && part.Headers.ContainsKey("content-type")) { if ((part.Headers["content-type"] != "image/jpeg") && (part.Headers["content-type"] != "image/png") && (part.Headers["content-type"] != "image/svg+xml")) { continue; } var disposition = ContentDisposition.Decode(part.Headers["content-disposition"]); if (disposition.ContainsKey("name") && (disposition["name"] == "image")) { var dir = DirExt.CreateRecursive(Path.Combine( avatarDir, uid[0].ToString(), uid[1].ToString(), uid[2].ToString())); var ext = ".jpg"; var format = "jpeg"; //if ((part.Headers["content-type"] == "image/png") || (part.Headers["content-type"] == "image/svg+xml")) //{ // ext = ".png"; // format = "png"; //} var name = StringExt.RandomString(16) + "_" + uid + ext; // crop / resize / convert the image using ImageMagick var startInfo = new ProcessStartInfo("/usr/bin/convert", "- -auto-orient -strip -set option:distort:viewport \"%[fx:min(w,h)]x%[fx:min(w,h)]+%[fx:max((w-h)/2,0)]+%[fx:max((h-w)/2,0)]\" -distort SRT 0 +repage -quality 80 -resize 256x256 " + format + ":" + Path.Combine(dir.FullName, name)); startInfo.RedirectStandardOutput = false; startInfo.RedirectStandardInput = true; startInfo.UseShellExecute = false; var process = new Process(); process.StartInfo = startInfo; process.Start(); // read the file stream and send it to ImageMagick await part.Stream.CopyToAsync(process.StandardInput.BaseStream); process.StandardInput.Close(); process.WaitForExit(); process.Dispose(); c.Response.StatusCode = 200; var userDiff = new User { id = uid, avatar = name }; using (DB db = await DB.CreateAsync(dbUrl)) { await userDiff.UpdateAsync(db); await userDiff.LoadAsync(db, true); } c.Response.Content = userDiff; if ((oldUser.avatar != null) && (oldUser.avatar != "empty")) { var oldFile = Path.Combine(avatarDir, uid[0].ToString(), uid[1].ToString(), uid[2].ToString(), Path.GetFileName(oldUser.avatar)); if (File.Exists(oldFile)) { File.Delete(oldFile); } } } } } }; GetAsync["/{uid:uid}/avatar"] = async(p, c) => { var uid = (string)p["uid"]; var user = new User { id = uid }; using (var db = await DB.CreateAsync(dbUrl)) { if (!await user.LoadAsync(db, true)) { user = null; } } if (user == null) { return; } string avatarPath; if ((user.avatar == null) || (user.avatar == "empty")) { if (user.gender == null) { avatarPath = "/avatar/avatar_neutre.svg"; } else if (user.gender == Gender.M) { avatarPath = "/avatar/avatar_masculin.svg"; } else { avatarPath = "/avatar/avatar_feminin.svg"; } } else { avatarPath = "/api/avatar/user/" + uid.Substring(0, 1) + "/" + uid.Substring(1, 1) + "/" + uid.Substring(2, 1) + "/" + user.avatar; } c.Response.StatusCode = 302; c.Response.Headers["location"] = avatarPath; }; }
private void process(object o) { try { while (true) { DownloadRequest currentItem = null; bool QueueEmpty = false; lock (sync) QueueEmpty = queue.Count == 0; if (QueueEmpty && null != OnWorkerFinished) { OnWorkerFinished(this, EventArgs.Empty); } lock (sync) { if (queue.Count > 0) { currentItem = queue.Dequeue(); } if (null == currentItem) { isComplete = true; return; } } currentItem.State = DownloadRequestState.Downloading; if (currentItem.IsFolder) { length = 0; position = 0; status = "Downloading folder info for " + currentItem.FullPath; //Item is a folder - Just get the folder items and add them to the queue. var verb = new BrowseVerb(null); verb.Path = currentItem.FullPath; //Always get the latest info. verb.NoCache = true; var client = new Client(null); if (client.Execute(verb, remoteNode)) { currentItem.State = DownloadRequestState.Downloaded; var newItems = new List <DownloadRequest>(); foreach (BrowsingFile item in verb.Results) { newItems.Add(new DownloadRequest { Added = DateTime.Now, ClientID = remoteNode.ID, FullPath = currentItem.FullPath + "/" + item.Name, IsFolder = item.IsFolder, LocalPath = currentItem.LocalPath + "\\" + currentItem.FileName, NextTryTime = 0, Nickname = remoteNode.Nickname, Size = item.Size, State = DownloadRequestState.None }); } model.DownloadQueue.List.AddRange(newItems); } else { currentItem.State = DownloadRequestState.Error; currentItem.NextTryTime = Environment.TickCount + Model.DOWNLOAD_RETRY_TIME; } } else { MemoryBuffer buffer = bufferService.GetBuffer(); buffer.SetDataLocation(0, buffer.Data.Length); //Item is a file - download it try { length = currentItem.Size; position = 0; status = currentItem.Nickname + " - " + currentItem.FileName + " - Connecting.."; currentItem.State = DownloadRequestState.Downloading; string mainPath = string.Empty; string mainFolder = string.Empty; string incompletePath = string.Empty; ; string incompleteFolder = string.Empty; //Build paths var mainsb = new StringBuilder(); mainsb.Append(model.DownloadFolder); if (!string.IsNullOrEmpty(currentItem.LocalPath)) { mainsb.Append("\\"); mainsb.Append(currentItem.LocalPath); } mainFolder = mainsb.ToString(); mainsb.Append("\\"); mainsb.Append(currentItem.FileName); mainPath = mainsb.ToString(); var incompletesb = new StringBuilder(); incompletesb.Append(model.IncompleteFolder); if (!string.IsNullOrEmpty(currentItem.LocalPath)) { incompletesb.Append("\\"); incompletesb.Append(currentItem.LocalPath); } incompleteFolder = incompletesb.ToString(); incompletesb.Append("\\"); incompletesb.Append(currentItem.FileName); incompletePath = incompletesb.ToString(); FileStream fileStream = null; //Check to see if the file already exists. if (File.Exists(mainPath)) { //File exists in the download directory. fileStream = File.Open(mainPath, FileMode.Open, FileAccess.Write, FileShare.None); incompletePath = mainPath; } else { if (!Directory.Exists(incompleteFolder)) { Directory.CreateDirectory(incompleteFolder); } //Else resume or just create fileStream = File.Open(incompletePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None); } var req = (HttpWebRequest) WebRequest.Create(Multiplexor.Encode(getDownloadUrl(), "GET", currentItem.FullPath)); req.UserAgent = Model.AppVersion; req.Headers.Add("FAP-SOURCE", model.LocalNode.ID); // req.Timeout = 300000; // req.ReadWriteTimeout = 3000000; //If we are resuming then add range long resumePoint = 0; if (fileStream.Length != 0) { //Yes Micrsoft if you read this... OH WHY IS ADDRANGE ONLY AN INT?? We live in an age where we might actually download more than 2gb //req.AddRange(fileStream.Length); //Hack MethodInfo method = typeof(WebHeaderCollection).GetMethod("AddWithoutValidate", BindingFlags.Instance | BindingFlags.NonPublic); string key = "Range"; string val = string.Format("bytes={0}", fileStream.Length); method.Invoke(req.Headers, new object[] { key, val }); position = fileStream.Length; resumePoint = fileStream.Length; //Seek to the end of the file fileStream.Seek(fileStream.Length, SeekOrigin.Begin); } var resp = (HttpWebResponse)req.GetResponse(); if (resp.StatusCode == HttpStatusCode.OK) { using (Stream responseStream = resp.GetResponseStream()) { var tokenizer = new StreamTokenizer(Encoding.ASCII, "|"); var utilisedBuffers = new List <MemoryBuffer>(); try { bool streamIncomplete = true; while (streamIncomplete) { MemoryBuffer tokenBuffer = bufferService.GetSmallBuffer(); //utilisedBuffers.Add(tokenBuffer); //Receive data tokenBuffer.SetDataLocation(0, responseStream.Read(tokenBuffer.Data, 0, tokenBuffer.DataSize)); tokenizer.ReceiveData(tokenBuffer); if (tokenizer.ContainsCommand()) { string data = tokenizer.GetCommand(); int queuePosition = int.Parse(data); if (queuePosition == 0) { if (tokenizer.Buffers.Count > 0) { LogManager.GetLogger("faplog").Warn( "Queue info overlaps with file data. File: {0}", currentItem.FileName); //Due to the way chunks are delivered we should never get here //Just incase write left over data foreach (MemoryBuffer buff in tokenizer.Buffers) { fileStream.Write(buff.Data, 0, buff.DataSize); } } status = currentItem.Nickname + " - " + currentItem.FileName + " - " + Utility.FormatBytes(currentItem.Size); DateTime start = DateTime.Now; while (true) { //Receive file int read = responseStream.Read(buffer.Data, 0, buffer.Data.Length); if (read == 0) { streamIncomplete = false; break; } else { fileStream.Write(buffer.Data, 0, read); position += read; netSpeed.PutData(read); } } //Add log of transfer double seconds = (DateTime.Now - start).TotalSeconds; var rxlog = new TransferLog(); rxlog.Added = currentItem.Added; rxlog.Completed = DateTime.Now; rxlog.Filename = currentItem.FileName; rxlog.Nickname = currentItem.Nickname; rxlog.Path = currentItem.FolderPath; rxlog.Size = currentItem.Size - resumePoint; if (0 != seconds) { rxlog.Speed = (int)(rxlog.Size / seconds); } model.CompletedDownloads.Add(rxlog); } else { //Queued status = currentItem.Nickname + " - " + currentItem.FileName + " - Queue position " + queuePosition; } } } } finally { foreach (MemoryBuffer buff in utilisedBuffers) { bufferService.FreeBuffer(buff); } tokenizer.Dispose(); } } } resp.Close(); model.DownloadQueue.List.Remove(currentItem); currentItem.State = DownloadRequestState.Downloaded; fileStream.Close(); fileStream.Dispose(); //Move from the incomplete folder. if (mainPath != incompletePath) { if (!Directory.Exists(mainFolder)) { Directory.CreateDirectory(mainFolder); } File.Move(incompletePath, mainPath); } status = currentItem.Nickname + " - Complete: " + currentItem.FileName; resp.Close(); } catch { currentItem.State = DownloadRequestState.Error; currentItem.NextTryTime = Environment.TickCount + Model.DOWNLOAD_RETRY_TIME; } finally { bufferService.FreeBuffer(buffer); } } } } catch { //Something went very wrong. Clear the queue and die. lock (sync) { isComplete = true; foreach (DownloadRequest v in queue) { v.State = DownloadRequestState.None; } queue.Clear(); } } }
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(); } } }
//Old method private void getFilesBtn_Click2(object sender, RoutedEventArgs e) { StringBuilder sb = new StringBuilder(mapPath); sb.Append(territoryName + @"\"); String territoryFolder = sb.ToString(); if (!Directory.Exists(territoryFolder)) { Directory.CreateDirectory(territoryFolder); } if (territory.Terrain != null) { foreach (var part in territory.Terrain.Parts) { addToMapList("territory", part); addToFileList(part.Model.File.Path); } } // Get the files we need foreach (var lgbFile in territory.LgbFiles) { foreach (var group in lgbFile.Groups) { if (!eventCheck(group.Name)) { addHeaderToMapList("LGBGroup: " + group.Name); foreach (var entry in group.Entries) { var asMdl = entry as LgbModelEntry; var asGim = entry as LgbGimmickEntry; string path = ""; //Entry is model if (asMdl != null && asMdl.Model != null && asMdl.Model.Model != null) { string header = string.Format("LgbModelEntry,{0},{1},{2},{3},{4},{5},{6},{7},{8}", asMdl.Header.Translation.X, asMdl.Header.Translation.Y, asMdl.Header.Translation.Z, asMdl.Header.Rotation.X, asMdl.Header.Rotation.Y, asMdl.Header.Rotation.Z, asMdl.Header.Scale.X, asMdl.Header.Scale.Y, asMdl.Header.Scale.Z); addHeaderToMapList(header); path = asMdl.Model.Model.File.Path; //MessageBox.Show(path); addToMapList(group.Name, asMdl.Model); addToFileList(path); addHeaderToMapList("EndLgbModelEntry"); } //Entry is gimmick if (asGim != null && asGim.Gimmick != null) { List <String> gimmickFileList = new List <string>(); getGimmickPaths(asGim.Gimmick, ref gimmickFileList); addGimmickInfoToMapList(asGim); ExportSgbFile(group.Name, asGim.Gimmick, 0, asGim.Header.Translation, asGim.Header.Rotation, asGim.Header.Scale); addHeaderToMapList("GimmickEnd"); } addToFileList(path); } } } } }
/// <summary> /// Creates a junction point from the specified directory to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name = "junctionPoint">The junction point path</param> /// <param name = "targetDir">The target directory</param> /// <param name = "overwrite">If true overwrites an existing reparse point or empty directory</param> /// <exception cref = "IOException">Thrown when the junction point could not be created or when /// an existing directory was found and <paramref name = "overwrite" /> if false</exception> public static void Create(Directory junctionPoint, string targetDir, bool overwrite) { //targetDir = Path.GetFullPath(targetDir); if (junctionPoint.Exists()) { if (!overwrite) throw new IOException("Directory already exists and overwrite parameter is false."); } else junctionPoint.Create(); using (var handle = OpenReparsePoint(junctionPoint.Path, EFileAccess.GenericWrite)) { var targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDir)); var reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = (ushort) (targetDirBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort) targetDirBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort) (targetDirBytes.Length + 2); reparseDataBuffer.PrintNameLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) ThrowLastWin32Error("Unable to create junction point."); } finally { Marshal.FreeHGlobal(inBuffer); } } }
private static string FindMsBuildToolsPathOnWindows() { if (!OS.IsWindows) { throw new PlatformNotSupportedException(); } // Try to find 15.0 with vswhere var envNames = Internal.GodotIs32Bits() ? new[] { "ProgramFiles", "ProgramW6432" } : new[] { "ProgramFiles(x86)", "ProgramFiles" }; string vsWherePath = null; foreach (var envName in envNames) { vsWherePath = Environment.GetEnvironmentVariable(envName); if (!string.IsNullOrEmpty(vsWherePath)) { vsWherePath += "\\Microsoft Visual Studio\\Installer\\vswhere.exe"; if (File.Exists(vsWherePath)) { break; } } vsWherePath = null; } var vsWhereArgs = new[] { "-latest", "-products", "*", "-requires", "Microsoft.Component.MSBuild" }; var outputArray = new Godot.Collections.Array <string>(); int exitCode = Godot.OS.Execute(vsWherePath, vsWhereArgs, blocking: true, output: (Godot.Collections.Array)outputArray); if (exitCode != 0) { return(string.Empty); } if (outputArray.Count == 0) { return(string.Empty); } var lines = outputArray[0].Split('\n'); foreach (string line in lines) { int sepIdx = line.IndexOf(':'); if (sepIdx <= 0) { continue; } string key = line.Substring(0, sepIdx); // No need to trim if (key != "installationPath") { continue; } string value = line.Substring(sepIdx + 1).StripEdges(); if (string.IsNullOrEmpty(value)) { throw new FormatException("installationPath value is empty"); } if (!value.EndsWith("\\")) { value += "\\"; } // Since VS2019, the directory is simply named "Current" string msbuildDir = Path.Combine(value, "MSBuild\\Current\\Bin"); if (Directory.Exists(msbuildDir)) { return(msbuildDir); } // Directory name "15.0" is used in VS 2017 return(Path.Combine(value, "MSBuild\\15.0\\Bin")); } return(string.Empty); }
public static bool Exists(string d) => OgDir.Exists(d);
private bool InstallAssemblyProvider(Package provider, Link link, string fastPath, BootstrapRequest request, bool deleteFile = true) { request.Verbose(Resources.Messages.InstallingPackage, fastPath); if (!Directory.Exists(request.DestinationPath(request))) { request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.DestinationPathNotSet); return(false); } string targetFilename = fastPath; string file = fastPath; //source can be from install-packageprovider or can be from the pipeline if (!request.LocalSource.Any() && !fastPath.IsFile() && link != null) { targetFilename = link.Attributes[Iso19770_2.Discovery.TargetFilename]; // download the file file = request.DownloadAndValidateFile(provider._swidtag); } if (string.IsNullOrWhiteSpace(targetFilename)) { request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.InvalidFilename); return(false); } targetFilename = Path.GetFileName(targetFilename); if (string.IsNullOrWhiteSpace(provider.Version)) { request.Error(ErrorCategory.InvalidOperation, fastPath, Resources.Messages.MissingVersion); return(false); } //the provider is installing to like this folder: \WindowsPowerShell\Modules\PackageManagement\ProviderAssemblies\nuget\2.8.5.127 //... providername\version\.dll var versionFolder = Path.Combine(request.DestinationPath(request), provider.Name, provider.Version); // if version folder exists, remove it if (Directory.Exists(versionFolder)) { RemoveDirectory(versionFolder); } // create the directory if we successfully deleted it if (!Directory.Exists(versionFolder)) { Directory.CreateDirectory(versionFolder); } var targetFile = Path.Combine(versionFolder, targetFilename); if (file != null) { try { // is that file still there? if (File.Exists(targetFile)) { request.Error(ErrorCategory.InvalidOperation, fastPath, Constants.Messages.UnableToRemoveFile, targetFile); return(false); } request.Debug("Copying file '{0}' to '{1}'", file, targetFile); try { if (File.Exists(file)) { // if this is a file File.Copy(file, targetFile); } else if (Directory.Exists(file)) { // if this is a directory, copy items over CopyDirectory(file, versionFolder); } } catch (Exception ex) { request.Debug(ex.StackTrace); return(false); } if (File.Exists(targetFile)) { request.Verbose(Resources.Messages.InstalledPackage, provider.Name, targetFile); request.YieldFromSwidtag(provider, fastPath); //Load the provider. This is needed when a provider has dependencies. For example, if Nuget provider has a dependent foobar // provider and when 'Install-PackageProvider -name NuGet', we want both NuGet and Foobar provider gets loaded. PackageManagementService.LoadProviderAssembly(request, targetFile, false); return(true); } } finally { if (deleteFile) { file.TryHardToDelete(); } } } return(false); }
/// Rebuilds the material on the asset. public static void CreateMaterial() { //clear out the main material in case it is filled in from previous import _mainMaterial = null; //Make sure the materials directoy exists before adding stuff to it if (!Directory.Exists(MaterialsPath)) { Directory.CreateDirectory(MaterialsPath); } //Check all the files in the directory for the main material foreach (var file in Directory.GetFiles(MaterialsPath, "*.mat", SearchOption.TopDirectoryOnly)) { if (!file.Contains(_assetName)) { continue; } if (file.Contains("sft")) { _shaderName = "LaidlawFX/Soft"; _materialName = _assetName + "_sft_mat_vat.mat"; } else if (file.Contains("rgd")) { _shaderName = "LaidlawFX/Rigid"; _materialName = _assetName + "_rgd_mat_vat.mat"; } else if (file.Contains("fld")) { _shaderName = "LaidlawFX/Fluid"; _materialName = _assetName + "_fld_mat_vat.mat"; } else { _shaderName = "LaidlawFX/Sprite"; _materialName = _assetName + "_spr_mat_vat.mat"; } //compare strings and check for the materialname in the file Match match = Regex.Match(file, _materialName, RegexOptions.IgnoreCase); //If the file exists, set the old material variable with the project file if (match.Success) { _oldMaterial = (Material)AssetDatabase.LoadAssetAtPath(file, typeof(Material)); } } //create a new material var tempMaterial = new Material(Shader.Find(_shaderName)); string tempName = "temp_mat_vat.mat"; //save material to the project directory AssetDatabase.CreateAsset(tempMaterial, Path.Combine(MaterialsPath, tempName)); //load up the the new material and store it _mainMaterial = (Material)AssetDatabase.LoadAssetAtPath(Path.Combine(MaterialsPath, tempName), typeof(Material)); // copy the old material options to the new material _mainMaterial.CopyPropertiesFromMaterial(_oldMaterial); // destroy the old material AssetDatabase.DeleteAsset(Path.Combine(MaterialsPath, _materialName)); // rename the new material AssetDatabase.RenameAsset(Path.Combine(MaterialsPath, tempName), _materialName); //Grab the position texture if it exists Debug.Log("Warning: Textures not being applied."); string texturePath = GetFilesPathNotMeta(TexturePath, _assetName + "_pos_vat").Replace("\\", "/"); Debug.Log("this is my pos texture path : " + texturePath); Texture2D posTex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturePath, typeof(Texture2D)); int temp = posTex.GetInstanceID(); Debug.Log(temp); //if (posTex != null) //{ // _mainMaterial.SetTexture("_posTex", posTex); //} _mainMaterial.SetTexture("_posTex", posTex); //Grab the rotation map path if it exists texturePath = GetFilesPathNotMeta(TexturePath, _assetName + "_rot_vat").Replace("\\", "/"); Texture2D rotTex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturePath, typeof(Texture2D)); if (rotTex != null) { _mainMaterial.SetTexture("_rotTex", rotTex); } //Grab the Scale map path if it exists texturePath = GetFilesPathNotMeta(TexturePath, _assetName + "_scale_vat"); Texture2D scaleTex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturePath, typeof(Texture2D)); if (scaleTex != null) { _mainMaterial.SetTexture("_scaleTex", scaleTex); } //Grab the rotation map path if it exists texturePath = GetFilesPathNotMeta(TexturePath, _assetName + "_norm_vat"); Texture2D normTex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturePath, typeof(Texture2D)); if (normTex != null) { _mainMaterial.SetTexture("_normTex", normTex); } //Grab the Scale map path if it exists texturePath = GetFilesPathNotMeta(TexturePath, _assetName + "_col_vat"); Texture2D colTex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturePath, typeof(Texture2D)); if (colTex != null) { _mainMaterial.SetTexture("_colTex", colTex); } }
private void InitializeLocalIndexAndDirectory(Lucene.Net.Store.Directory baseLuceneDirectory, Analyzer analyzer, string configuredPath) { lock (Locker) { if (!Directory.Exists(_tempPath)) { Directory.CreateDirectory(_tempPath); } else { //if we are syncing storage to the main file system to temp files, then clear out whatever is //currently there since we'll re-copy it over if (_syncStorage) { //clear it! Directory.Delete(_tempPath, true); //recreate it Directory.CreateDirectory(_tempPath); } } //if we are syncing storage to the main file system to temp files, then sync from the main FS to our temp FS if (_syncStorage) { //copy index using (new IndexWriter( //read from the underlying/default directory, not the temp codegen dir baseLuceneDirectory, analyzer, Snapshotter, IndexWriter.MaxFieldLength.UNLIMITED)) { try { var basePath = IOHelper.MapPath(configuredPath); var commit = Snapshotter.Snapshot(); var fileNames = commit.GetFileNames(); foreach (var fileName in fileNames) { File.Copy( Path.Combine(basePath, "Index", fileName), Path.Combine(_tempPath, Path.GetFileName(fileName)), true); } var segments = commit.GetSegmentsFileName(); if (segments.IsNullOrWhiteSpace() == false) { File.Copy( Path.Combine(basePath, "Index", segments), Path.Combine(_tempPath, Path.GetFileName(segments)), true); } } finally { Snapshotter.Release(); } } //create the custom lucene directory which will keep the main and temp FS's in sync LuceneDirectory = new TempStorageDirectory( new DirectoryInfo(_tempPath), baseLuceneDirectory); } else { //just return a normal lucene directory that uses the codegen folder LuceneDirectory = FSDirectory.Open(new DirectoryInfo(_tempPath)); } } }
private async void OpenFile() { Status = new AppStatusInfo { Status = Enums.Status.Working }; try { var openDig = new OpenFolderDialog { Title = "Choose a directory with images" }; var dirName = await openDig.ShowAsync(new Window()); if (string.IsNullOrEmpty(dirName) || !Directory.Exists(dirName)) { Status = new AppStatusInfo { Status = Enums.Status.Ready }; return; } var fileNames = Directory.GetFiles(dirName); _frameLoadProgressIndex = 0; Frames.Clear(); _frames.Clear(); GC.Collect(); var loadingFrames = new List <Frame>(); foreach (var fileName in fileNames) { // TODO: Проверка IsImage вне зависимости от расширений. if (!Path.HasExtension(fileName)) { continue; } if (Path.GetExtension(fileName).ToLower() != ".jpg" && Path.GetExtension(fileName).ToLower() != ".jpeg" && Path.GetExtension(fileName).ToLower() != ".png" && Path.GetExtension(fileName).ToLower() != ".bmp") { continue; } var frame = new Frame(); frame.OnLoad += FrameLoadingProgressUpdate; frame.Load(fileName, Enums.ImageLoadMode.Miniature); loadingFrames.Add(frame); } if (loadingFrames.Count == 0) { Status = new AppStatusInfo { Status = Enums.Status.Ready }; return; } Frames = loadingFrames; if (SelectedIndex < 0) { SelectedIndex = 0; } UpdateFramesRepo(); UpdateUi(); _frames = new List <Frame>(Frames); Status = new AppStatusInfo { Status = Enums.Status.Ready }; } catch (Exception ex) { Status = new AppStatusInfo { Status = Enums.Status.Error, StringStatus = $"Error | {ex.Message.Replace('\n', ' ')}" }; } }
//Does not support recursive sgb private void getFilesBtn_Click(object sender, RoutedEventArgs e) { maplist.Clear(); StringBuilder sb = new StringBuilder(mapPath); sb.Append(territoryName + @"\"); territory = new SaintCoinach.Graphics.Territory((TerritoryType)placeBox.SelectedItem); String territoryFolder = sb.ToString(); if (!Directory.Exists(territoryFolder)) { Directory.CreateDirectory(territoryFolder); } if (territory.Terrain != null) { foreach (var part in territory.Terrain.Parts) { addToMapList("territory", part); addToFileList(part.Model.File.Path); } } // Get the files we need foreach (var lgbFile in territory.LgbFiles) { foreach (var group in lgbFile.Groups) { if (!eventCheck(group.Name)) { addHeaderToMapList("LGBGroup: " + group.Name); foreach (var part in group.Entries) { var asMdl = part as SaintCoinach.Graphics.Lgb.LgbModelEntry; var asGim = part as SaintCoinach.Graphics.Lgb.LgbGimmickEntry; string path = ""; if (asMdl?.Model?.Model != null) { path = asMdl.Model.Model.File.Path; addToMapList(group.Name, asMdl.Model); addToFileList(path); } if (asGim?.Gimmick != null) { List <String> gimmickFileList = getGimmickPaths(asGim); addGimmickInfoToMapList(asGim); addGimmicksToMapList(group.Name, asGim); addHeaderToMapList("GimmickEnd"); foreach (String gPath in gimmickFileList) { addToFileList(gPath); } } addToFileList(path); } } } } }
private async void ImportAll() { Status = new AppStatusInfo { Status = Enums.Status.Working }; try { var openDig = new OpenFolderDialog { Title = "Choose a directory with xml annotations" }; var dirName = await openDig.ShowAsync(new Window()); if (string.IsNullOrEmpty(dirName) || !Directory.Exists(dirName)) { Status = new AppStatusInfo { Status = Enums.Status.Ready }; return; } var fileNames = Directory.GetFiles(dirName); _frameLoadProgressIndex = 0; Frames.Clear(); _frames.Clear(); GC.Collect(); var loadingFrames = new List <Frame>(); var annotations = fileNames.Where(i => Path.GetExtension(i).ToLower() == ".xml") .Select(Annotation.ParseFromXml).ToList(); foreach (var ann in annotations) { var fileName = Path.Combine(dirName, ann.Filename); // TODO: Проверка IsImage вне зависимости от расширений. if (!File.Exists(fileName)) { continue; } if (!Path.HasExtension(fileName)) { continue; } if (Path.GetExtension(fileName).ToLower() != ".jpg" && Path.GetExtension(fileName).ToLower() != ".jpeg" && Path.GetExtension(fileName).ToLower() != ".png" && Path.GetExtension(fileName).ToLower() != ".bmp") { continue; } var frame = new Frame(); frame.OnLoad += FrameLoadingProgressUpdate; frame.Load(fileName, Enums.ImageLoadMode.Miniature); frame.Rectangles = ann.Objects.Select(obj => new BoundBox(obj.Box.Xmin, obj.Box.Ymin, obj.Box.Ymax - obj.Box.Ymin, obj.Box.Xmax - obj.Box.Xmin)); if (frame.Rectangles.Any()) { frame.IsVisible = true; } loadingFrames.Add(frame); } if (loadingFrames.Count == 0) { Status = new AppStatusInfo { Status = Enums.Status.Ready }; return; } Frames = loadingFrames; if (SelectedIndex < 0) { SelectedIndex = 0; } UpdateFramesRepo(); UpdateUi(); _frames = new List <Frame>(Frames); Status = new AppStatusInfo { Status = Enums.Status.Ready }; } catch (Exception ex) { Status = new AppStatusInfo { Status = Enums.Status.Error, StringStatus = $"Error | {ex.Message.Replace('\n', ' ')}" }; } }
public static Maybe <bool> Exists(Maybe <string> mayPath) => from path in mayPath select IODic.Exists(path);
/// <summary> /// Update to the current version. /// </summary> /// <param name="detectDataChanges">Boolean indicating whether the update should also look for changes in data.</param> /// <param name="progress">Optional object to which update progress is reported.</param> /// <returns>Returns the <see cref="UpdateReport" /> containing all changes.</returns> /// <exception cref="InvalidOperationException">Definition is up-to-date.</exception> public UpdateReport Update(bool detectDataChanges, IProgress <UpdateProgress> progress = null) { if (DefinitionVersion == GameVersion) { throw new InvalidOperationException(); } string previousVersion = DefinitionVersion; PackIdentifier exdPackId = new PackIdentifier("exd", PackIdentifier.DefaultExpansion, 0); Pack exdPack = Packs.GetPack(exdPackId); bool exdOldKeepInMemory = exdPack.KeepInMemory; exdPack.KeepInMemory = true; string tempPath = null; UpdateReport report; try { using (ZipFile zip = new ZipFile(StateFile.FullName, ZipEncoding)) { tempPath = ExtractPacks(zip, previousVersion); PackCollection previousPack = new PackCollection(Path.Combine(tempPath, previousVersion)); previousPack.GetPack(exdPackId).KeepInMemory = true; RelationDefinition previousDefinition; if (previousVersion == _GameData.Definition.Version) { // Override previous definition when current definition version matches. // Definitions may have changed since this was recorded and we want to compare that. previousDefinition = _GameData.Definition; } else { // Otherwise, read the previous definition from the zip. previousDefinition = ReadDefinition(zip, previousVersion); } RelationUpdater updater = new RelationUpdater(previousPack, previousDefinition, Packs, GameVersion, progress); System.Collections.Generic.IEnumerable <IChange> changes = updater.Update(detectDataChanges); report = new UpdateReport(previousVersion, GameVersion, changes); RelationDefinition definition = updater.Updated; StorePacks(zip); StoreDefinitionInZip(zip, definition); StoreDefinitionOnFilesystem(definition, ""); if (Debugger.IsAttached) { // Little QOL path - when updating with the debugger attached, // also write to the project definitions path so no need to copy // them manually afterward. string projectDefinitionsPath = "../../../SaintCoinach"; if (Directory.Exists(projectDefinitionsPath)) { StoreDefinitionOnFilesystem(definition, projectDefinitionsPath); } } StoreReport(zip, report); UpdateVersion(zip); zip.Save(); GameData.Definition = definition; GameData.Definition.Compile(); } } finally { if (exdPack != null) { exdPack.KeepInMemory = exdOldKeepInMemory; } if (tempPath != null) { try { Directory.Delete(tempPath, true); } catch { Console.Error.WriteLine("Failed to delete temporary directory {0}.", tempPath); } } } return(report); }
public async Task Start() { Instance = this; IInjectionService injection = Services.Get <IInjectionService>(); string directory = injection.GamePath; if (!IsValidInstallation(directory)) { throw new Exception("Invalid FFXIV installation"); } bool forceUpdate = false; Stopwatch sw = new Stopwatch(); sw.Start(); if (forceUpdate) { if (File.Exists("SaintCoinach.History.zip")) { File.Delete("SaintCoinach.History.zip"); } if (Directory.Exists("./Definitions/")) { Directory.Delete("./Definitions/", true); } } // Unzip definitions if (!Directory.Exists("./Definitions/")) { ZipFile.ExtractToDirectory("./Modules/SaintCoinach/bin/Definitions.zip", "./Definitions/"); } // TODO get language from language service? ARealmReversed realm = new ARealmReversed(directory, Language.English); try { if (!realm.IsCurrentVersion) { realm.Update(true, this); } } catch (Exception ex) { throw new Exception(@"Failed to update Saint Coinach", ex); } List <Task> tasks = new List <Task>(); tasks.Add(Task.Run(() => this.Items = this.Load <Table <IItem>, IItem, Item, ItemWrapper>(realm))); tasks.Add(Task.Run(() => this.Races = this.Load <Table <IRace>, IRace, Race, RaceWrapper>(realm))); tasks.Add(Task.Run(() => this.Tribes = this.Load <Table <ITribe>, ITribe, Tribe, TribeWrapper>(realm))); tasks.Add(Task.Run(() => this.Dyes = this.Load <Table <IDye>, IDye, Stain, DyeWrapper>(realm))); tasks.Add(Task.Run(() => this.BaseNPCs = this.Load <Table <INpcBase>, INpcBase, ENpcBase, NpcBaseWrapper>(realm))); tasks.Add(Task.Run(() => this.Territories = this.Load <Table <ITerritoryType>, ITerritoryType, TerritoryType, TerritoryTypeWrapper>(realm))); tasks.Add(Task.Run(() => this.Weathers = this.Load <Table <IWeather>, IWeather, Weather, WeatherWrapper>(realm))); tasks.Add(Task.Run(() => this.CharacterMakeCustomize = this.Load <CustomizeTable, ICharaMakeCustomize, CharaMakeCustomize, CharacterMakeCustomizeWrapper>(realm))); tasks.Add(Task.Run(() => this.CharacterMakeTypes = this.Load <Table <ICharaMakeType>, ICharaMakeType, CharaMakeType, CharacterMakeTypeWrapper>(realm))); tasks.Add(Task.Run(() => this.ResidentNPCs = this.Load <Table <INpcResident>, INpcResident, ENpcResident, NpcResidentWrapper>(realm))); tasks.Add(Task.Run(() => this.Titles = this.Load <Table <ITitle>, ITitle, Title, TitleWrapper>(realm))); tasks.Add(Task.Run(() => this.Statuses = this.Load <Table <IStatus>, IStatus, Status, StatusWrapper>(realm))); foreach (Task t in tasks) { await t; } Log.Write("Initialization took " + sw.ElapsedMilliseconds + "ms", @"Saint Coinach"); }
public Resources(string dbUrl, string storageDir) : base(dbUrl) { var resourceDir = Path.Combine(storageDir, "resource"); if (!Dir.Exists(resourceDir)) { Dir.CreateDirectory(resourceDir); } GetAsync["/{id:int}/image"] = async(p, c) => { var id = (int)p["id"]; var oldResource = new Resource { id = id }; using (var db = await DB.CreateAsync(dbUrl)) { if (!await oldResource.LoadAsync(db, true)) { oldResource = null; } } if (oldResource == null) { return; } var fullPath = Path.Combine(resourceDir, $"{id}.jpg"); if (File.Exists(fullPath)) { var shortName = Path.GetFileName(fullPath); c.Response.Headers["content-type"] = "image/jpeg"; var lastModif = File.GetLastWriteTime(fullPath); string etag = "\"" + lastModif.Ticks.ToString("X") + "\""; c.Response.Headers["etag"] = etag; if (c.Request.QueryString.ContainsKey("if-none-match") && (c.Request.QueryString["if-none-match"] == etag)) { c.Response.StatusCode = 304; } else { c.Response.StatusCode = 200; c.Response.SupportRanges = true; c.Response.Content = new FileContent(fullPath); } } }; DeleteAsync["/{id:int}/image"] = async(p, c) => { var id = (int)p["id"]; var oldResource = new Resource { id = id }; using (var db = await DB.CreateAsync(dbUrl)) { if (!await oldResource.LoadAsync(db, true)) { oldResource = null; } } if (oldResource == null) { return; } var fullPath = Path.Combine(resourceDir, $"{id}.jpg"); if (File.Exists(fullPath)) { File.Delete(fullPath); c.Response.StatusCode = 200; c.Response.Content = ""; } }; PostAsync["/{id:int}/image"] = async(p, c) => { var id = (int)p["id"]; var oldResource = new Resource { id = id }; using (var db = await DB.CreateAsync(dbUrl)) { if (!await oldResource.LoadAsync(db, true)) { oldResource = null; } } if (oldResource == null) { return; } var reader = c.Request.ReadAsMultipart(); MultipartPart part; while ((part = await reader.ReadPartAsync()) != null) { if (part.Headers.ContainsKey("content-disposition") && part.Headers.ContainsKey("content-type")) { if ((part.Headers["content-type"] != "image/jpeg") && (part.Headers["content-type"] != "image/png") && (part.Headers["content-type"] != "image/svg+xml")) { continue; } var disposition = ContentDisposition.Decode(part.Headers["content-disposition"]); if (disposition.ContainsKey("name") && (disposition["name"] == "image")) { var dir = DirExt.CreateRecursive(resourceDir); var fullPath = Path.Combine(dir.FullName, $"{id}.jpg"); // crop / resize / convert the image using ImageMagick var startInfo = new ProcessStartInfo("/usr/bin/convert", $"- -auto-orient -strip -distort SRT 0 +repage -quality 80 -resize 1024x1024 jpeg:{fullPath}"); startInfo.RedirectStandardOutput = false; startInfo.RedirectStandardInput = true; startInfo.UseShellExecute = false; var process = new Process(); process.StartInfo = startInfo; process.Start(); // read the file stream and send it to ImageMagick await part.Stream.CopyToAsync(process.StandardInput.BaseStream); process.StandardInput.Close(); process.WaitForExit(); process.Dispose(); c.Response.StatusCode = 200; } } } }; }
public void Sort(string path, CancellationToken token) { Trace.WriteLine("Вход в папку " + path); int count = 0; string[] dirs = null; string[] files = null; try { /* string[]*/ dirs = System.IO.Directory.GetDirectories(path); /* string[]*/ files = System.IO.Directory.GetFiles(path, "*.*").Where((s) => s.ToLower().EndsWith(".jpg") || s.ToLower().EndsWith(".jpeg")).ToArray(); } catch (IOException ioe) { Trace.WriteLine(ioe.Message); //выясним, не извлекли ли съемный диск DriveInfo drive = new DriveInfo(System.IO.Path.GetPathRoot(path)); if (!drive.IsReady) { Trace.WriteLine("Диск " + drive.Name + " был извлечен, или содержит ошибки, мешаюшие поиску"); return; /*result*/; } if (dirs == null || files == null) { Trace.WriteLine("Массивы со списком файлов или папок - null"); return; /*result*/; } } foreach (var f in files) { if (token.IsCancellationRequested) { break; } try { DateTime fileDateTime = GetDateTimeForImage(f); string result_directory = ""; if (Parameters.format == DestinationDirectoriesFormat.YearMonth) { result_directory = fileDateTime.ToString("yyyy_MM"); } else { result_directory = fileDateTime.ToString("yyyy_MM_dd"); } if (!Directory.Exists(Path.Combine(DestinationDirectory, result_directory))) { Directory.CreateDirectory(Path.Combine(DestinationDirectory, result_directory)); } //-------------------------------------------------------- string dstname = Path.Combine(DestinationDirectory, result_directory, Path.GetFileName(f)); foreach (string dname in DestinationFileNames(dstname)) { if (!File.Exists(dname)) { if (Parameters.mode == FileOperations.Copy) { File.Copy(f, dname); } else { File.Move(f, dname); } break; } } sorterFileChangedEvent?.Invoke(new SortedEventArgs(f, fileDateTime.Date.ToShortDateString(), Path.Combine(DestinationDirectory, result_directory))); //-------------------------------------------------------- } catch (UnauthorizedAccessException ex) { Trace.WriteLine("Windows Access Error : " + ex.Message); sorterMetadataErrorEvent?.Invoke(new SorterErrorEventArgs(f)); } catch (IOException ex) { Trace.WriteLine("I/O Error : " + ex.Message); sorterMetadataErrorEvent?.Invoke(new SorterErrorEventArgs(f)); } catch (MetadataException ex) { Trace.WriteLine("Date Extraction Error: " + ex.Message); sorterMetadataErrorEvent?.Invoke(new SorterErrorEventArgs(f)); } catch (NullReferenceException ex) { Trace.WriteLine("NRE: " + ex.Message); } catch (Exception ex) { Trace.WriteLine("Unknow error: " + ex.Message); } } foreach (var d in dirs) { if (token.IsCancellationRequested) { break; } try { Sort(d, token); } catch (UnauthorizedAccessException ex) { Trace.WriteLine("Windows Access Error : " + ex.Message); } catch (IOException ex) { Trace.WriteLine("I/O Error : " + ex.Message); } } return; }
// TODO Merge these, with proper logic depending on the scenario (import, force, etc) public (string, string) MoveWithResultString(string scriptName, bool force = false) { // TODO Make this take an argument to disable removing empty dirs. It's slow, and should only be done if needed if (FullServerPath == null) { logger.Error("Could not find or access the file to move: {0}", VideoLocal_Place_ID); return(string.Empty, "ERROR: Unable to access file"); } if (!File.Exists(FullServerPath)) { logger.Error("Could not find or access the file to move: {0}", FullServerPath); // this can happen due to file locks, so retry return(string.Empty, "ERROR: Could not access the file"); } FileInfo sourceFile = new FileInfo(FullServerPath); // There is a possibility of weird logic based on source of the file. Some handling should be made for it....later (var destImpl, string newFolderPath) = RenameFileHelper.GetDestination(this, scriptName); if (!(destImpl is SVR_ImportFolder destFolder)) { // In this case, an error string was returned, but we'll suppress it and give an error elsewhere if (newFolderPath != null) { logger.Error("Unable to find destination for: {0}", FullServerPath); logger.Error("The error message was: " + newFolderPath); return(string.Empty, "ERROR: " + newFolderPath); } logger.Error("Unable to find destination for: {0}", FullServerPath); return(string.Empty, "ERROR: There was an error but no error code returned..."); } // keep the original drop folder for later (take a copy, not a reference) SVR_ImportFolder dropFolder = ImportFolder; if (string.IsNullOrEmpty(newFolderPath)) { logger.Error("Unable to find destination for: {0}", FullServerPath); return(string.Empty, "ERROR: The returned path was null or empty"); } // We've already resolved FullServerPath, so it doesn't need to be checked string newFilePath = Path.Combine(newFolderPath, Path.GetFileName(FullServerPath)); string newFullServerPath = Path.Combine(destFolder.ImportFolderLocation, newFilePath); var destFullTree = Path.Combine(destFolder.ImportFolderLocation, newFolderPath); if (!Directory.Exists(destFullTree)) { try { Directory.CreateDirectory(destFullTree); } catch (Exception e) { logger.Error(e); return(string.Empty, $"ERROR: Unable to create directory tree: {destFullTree}"); } } // Last ditch effort to ensure we aren't moving a file unto itself if (newFullServerPath.Equals(FullServerPath, StringComparison.InvariantCultureIgnoreCase)) { logger.Info($"The file is already at its desired location: {FullServerPath}"); return(string.Empty, "ERROR: The file is already at its desired location"); } if (File.Exists(newFullServerPath)) { logger.Info($"A file already exists at the desired location for {FullServerPath}"); return(string.Empty, "ERROR: The File already exists at the destination"); } ShokoServer.PauseWatchingFiles(); logger.Info("Moving file from {0} to {1}", FullServerPath, newFullServerPath); try { sourceFile.MoveTo(newFullServerPath); } catch (Exception e) { logger.Error("Unable to MOVE file: {0} to {1} error {2}", FullServerPath, newFullServerPath, e); ShokoServer.UnpauseWatchingFiles(); return(newFullServerPath, "ERROR: " + e); } // Save for later. Scan for subtitles while the vlplace is still set for the source location string originalFileName = FullServerPath; var textStreams = SubtitleHelper.GetSubtitleStreams(this); // Handle Duplicate Files var dups = RepoFactory.DuplicateFile.GetByFilePathAndImportFolder(FilePath, ImportFolderID).ToList(); foreach (var dup in dups) { // Move source if (dup.FilePathFile1.Equals(FilePath) && dup.ImportFolderIDFile1 == ImportFolderID) { dup.FilePathFile1 = newFilePath; dup.ImportFolderIDFile1 = destFolder.ImportFolderID; } else if (dup.FilePathFile2.Equals(FilePath) && dup.ImportFolderIDFile2 == ImportFolderID) { dup.FilePathFile2 = newFilePath; dup.ImportFolderIDFile2 = destFolder.ImportFolderID; } // validate the dup file // There are cases where a dup file was not cleaned up before, so we'll do it here, too if (!dup.GetFullServerPath1() .Equals(dup.GetFullServerPath2(), StringComparison.InvariantCultureIgnoreCase)) { RepoFactory.DuplicateFile.Save(dup); } else { RepoFactory.DuplicateFile.Delete(dup); } } ImportFolderID = destFolder.ImportFolderID; FilePath = newFilePath; RepoFactory.VideoLocalPlace.Save(this); try { // move any subtitle files foreach (TextStream subtitleFile in textStreams) { if (string.IsNullOrEmpty(subtitleFile.Filename)) { continue; } var newParent = Path.GetDirectoryName(newFullServerPath); var srcParent = Path.GetDirectoryName(originalFileName); if (string.IsNullOrEmpty(newParent) || string.IsNullOrEmpty(srcParent)) { continue; } var subPath = Path.Combine(srcParent, subtitleFile.Filename); if (!File.Exists(subPath)) { continue; } var subFile = new FileInfo(subPath); string newSubPath = Path.Combine(newParent, subFile.Name); if (File.Exists(newSubPath)) { try { File.Delete(newSubPath); } catch (Exception e) { logger.Warn("Unable to DELETE file: {0} error {1}", subtitleFile, e); } } try { subFile.MoveTo(newSubPath); } catch (Exception e) { logger.Error("Unable to MOVE file: {0} to {1} error {2}", subtitleFile, newSubPath, e); } } } catch (Exception ex) { logger.Error(ex, ex.ToString()); } // check for any empty folders in drop folder // only for the drop folder if (dropFolder.IsDropSource == 1) { RecursiveDeleteEmptyDirectories(dropFolder?.ImportFolderLocation, true); } ShokoServer.UnpauseWatchingFiles(); return(newFolderPath, string.Empty); }
public static void Main(System.String[] args) { // get command line arguments String prologFilename = null; // name of file "wn_s.pl" String indexDir = null; if (args.Length == 2) { prologFilename = args[0]; indexDir = args[1]; } else { Usage(); Environment.Exit(1); } // ensure that the prolog file is readable if (!(new FileInfo(prologFilename)).Exists) { err.WriteLine("Error: cannot read Prolog file: " + prologFilename); Environment.Exit(1); } // exit if the target index directory already exists if (Directory.Exists((new FileInfo(indexDir)).FullName)) { err.WriteLine("Error: index directory already exists: " + indexDir); err.WriteLine("Please specify a name of a non-existent directory"); Environment.Exit(1); } o.WriteLine("Opening Prolog file " + prologFilename); var fis = new FileStream(prologFilename, FileMode.Open, FileAccess.Read); var br = new StreamReader(new StreamReader(fis, System.Text.Encoding.Default).BaseStream, new StreamReader(fis, System.Text.Encoding.Default).CurrentEncoding); String line; // maps a word to all the "groups" it's in System.Collections.IDictionary word2Nums = new System.Collections.SortedList(); // maps a group to all the words in it System.Collections.IDictionary num2Words = new System.Collections.SortedList(); // number of rejected words var ndecent = 0; // status output var mod = 1; var row = 1; // parse prolog file o.WriteLine("[1/2] Parsing " + prologFilename); while ((line = br.ReadLine()) != null) { // occasional progress if ((++row) % mod == 0) // periodically print out line we read in { mod *= 2; o.WriteLine("\t" + row + " " + line + " " + word2Nums.Count + " " + num2Words.Count + " ndecent=" + ndecent); } // syntax check if (!line.StartsWith("s(")) { err.WriteLine("OUCH: " + line); Environment.Exit(1); } // parse line line = line.Substring(2); var comma = line.IndexOf(','); var num = line.Substring(0, comma); var q1 = line.IndexOf('\''); line = line.Substring(q1 + 1); var q2 = line.IndexOf('\''); var word = line.Substring(0, q2).ToLower().Replace("''", "'"); // make sure is a normal word if (!IsDecent(word)) { ndecent++; continue; // don't store words w/ spaces } // 1/2: word2Nums map // append to entry or add new one var lis = (System.Collections.IList)word2Nums[word]; if (lis == null) { lis = new List <String> { num }; word2Nums[word] = lis; } else { lis.Add(num); } // 2/2: num2Words map lis = (System.Collections.IList)num2Words[num]; if (lis == null) { lis = new List <String> { word }; num2Words[num] = lis; } else { lis.Add(word); } } // close the streams fis.Close(); br.Close(); // create the index o.WriteLine("[2/2] Building index to store synonyms, " + " map sizes are " + word2Nums.Count + " and " + num2Words.Count); Index(indexDir, word2Nums, num2Words); }
internal static string DownloadFile(string queryUrl, string destination, PackageSourceListRequest request, ProgressTracker progressTracker) { try { request.Debug(Resources.Messages.DebugInfoCallMethod, Constants.ProviderName, string.Format(System.Globalization.CultureInfo.InvariantCulture, "DownloadFile - url='{0}', destination='{1}'", queryUrl, destination)); if (string.IsNullOrWhiteSpace(destination)) { throw new ArgumentNullException("destination"); } // make sure that the parent folder is created first. var folder = Path.GetDirectoryName(destination); if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } if (File.Exists(destination)) { destination.TryHardToDelete(); } if (progressTracker == null) { progressTracker = new ProgressTracker(request.StartProgress(0, Resources.Messages.DownloadingPackage, queryUrl)); } Uri uri; if (!Uri.TryCreate(queryUrl, UriKind.Absolute, out uri)) { request.Error(Internal.ErrorCategory.InvalidOperation, Resources.Messages.UnsuportedUriFormat, Constants.ProviderName, queryUrl); return(null); } if (uri.IsFile) { // downloading from a file share using (var input = File.OpenRead(queryUrl)) { using (var output = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.Read)) { request.Progress(progressTracker.ProgressID, progressTracker.StartPercent, Resources.Messages.Downloading); input.CopyTo(output); } } request.CompleteProgress(progressTracker.ProgressID, true); } else { //Downloading from url var result = DownloadDataToFileAsync(destination, queryUrl, request, PathUtility.GetNetworkCredential(request.CredentialUsername, request.CredentialPassword), progressTracker).Result; } if (File.Exists(destination)) { request.Verbose(Resources.Messages.CompletedDownload, queryUrl); return(destination); } else { request.Error(Internal.ErrorCategory.InvalidOperation, Resources.Messages.FailedToDownload, Constants.ProviderName, queryUrl, destination); return(null); } } catch (Exception ex) { ex.Dump(request); request.Warning(ex.Message); return(null); } }
public void BaselineDirectoryExists() => Assert.IsTrue(Directory.Exists(UncHelper.GetUncFromPath(".")));
public override void ExecuteCmdlet() { CloudFile fileToBeDownloaded; string[] path = NamingUtil.ValidatePath(this.Path, true); switch (this.ParameterSetName) { case Constants.FileParameterSetName: fileToBeDownloaded = this.File; break; case Constants.ShareNameParameterSetName: var share = this.BuildFileShareObjectFromName(this.ShareName); fileToBeDownloaded = share.GetRootDirectoryReference().GetFileReferenceByPath(path); break; case Constants.ShareParameterSetName: fileToBeDownloaded = this.Share.GetRootDirectoryReference().GetFileReferenceByPath(path); break; case Constants.DirectoryParameterSetName: fileToBeDownloaded = this.Directory.GetFileReferenceByPath(path); break; default: throw new PSArgumentException(string.Format(CultureInfo.InvariantCulture, "Invalid parameter set name: {0}", this.ParameterSetName)); } string resolvedDestination = this.GetUnresolvedProviderPathFromPSPath( string.IsNullOrWhiteSpace(this.Destination) ? "." : this.Destination); FileMode mode = this.Force ? FileMode.Create : FileMode.CreateNew; string targetFile; if (LocalDirectory.Exists(resolvedDestination)) { // If the destination pointed to an existing directory, we // would download the file into the folder with the same name // on cloud. targetFile = LocalPath.Combine(resolvedDestination, fileToBeDownloaded.GetBaseName()); } else { // Otherwise we treat the destination as a file no matter if // there's one existing or not. The overwrite behavior is configured // by FileMode. targetFile = resolvedDestination; } this.RunTask(async taskId => { var downloadJob = new FileDownloadJob() { SourceFile = fileToBeDownloaded, DestPath = targetFile }; var progressRecord = new ProgressRecord( this.OutputStream.GetProgressId(taskId), string.Format(CultureInfo.CurrentCulture, Resources.ReceiveAzureFileActivity, fileToBeDownloaded.GetFullPath(), targetFile), Resources.PrepareDownloadingFile); await this.RunTransferJob(downloadJob, progressRecord); if (this.PassThru) { this.OutputStream.WriteObject(taskId, fileToBeDownloaded); } }); }
// returns false if we should retry private bool MoveFileIfRequired(bool deleteEmpty = true) { if (!ServerSettings.Instance.Import.MoveOnImport) { logger.Trace($"Skipping move of \"{this.FullServerPath}\" as move on import is disabled"); return(true); } // TODO Make this take an argument to disable removing empty dirs. It's slow, and should only be done if needed try { logger.Trace("Attempting to MOVE file: {0}", FullServerPath ?? VideoLocal_Place_ID.ToString()); if (FullServerPath == null) { logger.Error("Could not find or access the file to move: {0}", VideoLocal_Place_ID); return(true); } // check if this file is in the drop folder // otherwise we don't need to move it if (ImportFolder.IsDropSource == 0) { logger.Trace("Not moving file as it is NOT in the drop folder: {0}", FullServerPath); return(true); } if (!File.Exists(FullServerPath)) { logger.Error("Could not find or access the file to move: {0}", FullServerPath); // this can happen due to file locks, so retry return(false); } var sourceFile = new FileInfo(FullServerPath); // find the default destination (var destImpl, string newFolderPath) = RenameFileHelper.GetDestination(this, null); if (!(destImpl is SVR_ImportFolder destFolder)) { // In this case, an error string was returned, but we'll suppress it and give an error elsewhere if (newFolderPath != null) { return(true); } logger.Error("Could not find a valid destination: {0}", FullServerPath); return(true); } // keep the original drop folder for later (take a copy, not a reference) SVR_ImportFolder dropFolder = ImportFolder; if (string.IsNullOrEmpty(newFolderPath)) { return(true); } // We've already resolved FullServerPath, so it doesn't need to be checked string newFilePath = Path.Combine(newFolderPath, Path.GetFileName(FullServerPath)); string newFullServerPath = Path.Combine(destFolder.ImportFolderLocation, newFilePath); var destFullTree = Path.Combine(destFolder.ImportFolderLocation, newFolderPath); if (!Directory.Exists(destFullTree)) { try { Directory.CreateDirectory(destFullTree); } catch (Exception e) { logger.Error(e); return(true); } } // Last ditch effort to ensure we aren't moving a file unto itself if (newFullServerPath.Equals(FullServerPath, StringComparison.InvariantCultureIgnoreCase)) { logger.Error($"Resolved to move {newFullServerPath} unto itself. NOT MOVING"); return(true); } var originalFileName = FullServerPath; var textStreams = SubtitleHelper.GetSubtitleStreams(this); if (File.Exists(newFullServerPath)) { // A file with the same name exists at the destination. // Handle Duplicate Files, A duplicate file record won't exist yet, // so we'll check the old fashioned way logger.Trace("A file already exists at the new location, checking it for duplicate"); var destVideoLocalPlace = RepoFactory.VideoLocalPlace.GetByFilePathAndImportFolderID(newFilePath, destFolder.ImportFolderID); var destVideoLocal = destVideoLocalPlace?.VideoLocal; if (destVideoLocal == null) { logger.Error("The existing file at the new location does not have a VideoLocal. Not moving"); return(true); } if (destVideoLocal.Hash == VideoLocal.Hash) { logger.Info( "Not moving file as it already exists at the new location, deleting source file instead: {0} --- {1}", FullServerPath, newFullServerPath); // if the file already exists, we can just delete the source file instead // this is safer than deleting and moving try { sourceFile.Delete(); } catch (Exception e) { logger.Warn("Unable to DELETE file: {0} error {1}", FullServerPath, e); RemoveRecord(false); // check for any empty folders in drop folder // only for the drop folder if (dropFolder.IsDropSource != 1) { return(true); } RecursiveDeleteEmptyDirectories(dropFolder?.ImportFolderLocation, true); return(true); } } // Not a dupe, don't delete it logger.Trace("A file already exists at the new location, checking it for version and group"); var destinationExistingAniDBFile = destVideoLocal.GetAniDBFile(); if (destinationExistingAniDBFile == null) { logger.Error("The existing file at the new location does not have AniDB info. Not moving."); return(true); } var aniDBFile = VideoLocal.GetAniDBFile(); if (aniDBFile == null) { logger.Error("The file does not have AniDB info. Not moving."); return(true); } if (destinationExistingAniDBFile.Anime_GroupName == aniDBFile.Anime_GroupName && destinationExistingAniDBFile.FileVersion < aniDBFile.FileVersion) { // This is a V2 replacing a V1 with the same name. // Normally we'd let the Multiple Files Utility handle it, but let's just delete the V1 logger.Info("The existing file is a V1 from the same group. Replacing it."); // Delete the destination (bool success, string _) = destVideoLocalPlace.RemoveAndDeleteFile(); if (!success) { return(false); } // Move ShokoServer.PauseWatchingFiles(); logger.Info("Moving file from {0} to {1}", FullServerPath, newFullServerPath); try { sourceFile.MoveTo(newFullServerPath); } catch (Exception e) { logger.Error("Unable to MOVE file: {0} to {1} error {2}", FullServerPath, newFullServerPath, e); ShokoServer.UnpauseWatchingFiles(); return(false); } // Handle Duplicate Files var dups = RepoFactory.DuplicateFile.GetByFilePathAndImportFolder(FilePath, ImportFolderID).ToList(); foreach (var dup in dups) { // Move source if (dup.FilePathFile1.Equals(FilePath) && dup.ImportFolderIDFile1 == ImportFolderID) { dup.FilePathFile1 = newFilePath; dup.ImportFolderIDFile1 = destFolder.ImportFolderID; } else if (dup.FilePathFile2.Equals(FilePath) && dup.ImportFolderIDFile2 == ImportFolderID) { dup.FilePathFile2 = newFilePath; dup.ImportFolderIDFile2 = destFolder.ImportFolderID; } // validate the dup file // There are cases where a dup file was not cleaned up before, so we'll do it here, too if (!dup.GetFullServerPath1() .Equals(dup.GetFullServerPath2(), StringComparison.InvariantCultureIgnoreCase)) { RepoFactory.DuplicateFile.Save(dup); } else { RepoFactory.DuplicateFile.Delete(dup); } } ImportFolderID = destFolder.ImportFolderID; FilePath = newFilePath; RepoFactory.VideoLocalPlace.Save(this); // check for any empty folders in drop folder // only for the drop folder if (dropFolder.IsDropSource == 1 && deleteEmpty) { RecursiveDeleteEmptyDirectories(dropFolder?.ImportFolderLocation, true); } } } else { ShokoServer.PauseWatchingFiles(); logger.Info("Moving file from {0} to {1}", FullServerPath, newFullServerPath); try { sourceFile.MoveTo(newFullServerPath); } catch (Exception e) { logger.Error("Unable to MOVE file: {0} to {1} error {2}", FullServerPath, newFullServerPath, e); ShokoServer.UnpauseWatchingFiles(); return(false); } // Handle Duplicate Files var dups = RepoFactory.DuplicateFile.GetByFilePathAndImportFolder(FilePath, ImportFolderID).ToList(); foreach (var dup in dups) { // Move source if (dup.FilePathFile1.Equals(FilePath) && dup.ImportFolderIDFile1 == ImportFolderID) { dup.FilePathFile1 = newFilePath; dup.ImportFolderIDFile1 = destFolder.ImportFolderID; } else if (dup.FilePathFile2.Equals(FilePath) && dup.ImportFolderIDFile2 == ImportFolderID) { dup.FilePathFile2 = newFilePath; dup.ImportFolderIDFile2 = destFolder.ImportFolderID; } // validate the dup file // There are cases where a dup file was not cleaned up before, so we'll do it here, too if (!dup.GetFullServerPath1() .Equals(dup.GetFullServerPath2(), StringComparison.InvariantCultureIgnoreCase)) { RepoFactory.DuplicateFile.Save(dup); } else { RepoFactory.DuplicateFile.Delete(dup); } } ImportFolderID = destFolder.ImportFolderID; FilePath = newFilePath; RepoFactory.VideoLocalPlace.Save(this); // check for any empty folders in drop folder // only for the drop folder if (dropFolder.IsDropSource == 1 && deleteEmpty) { RecursiveDeleteEmptyDirectories(dropFolder?.ImportFolderLocation, true); } } try { // move any subtitle files foreach (TextStream subtitleFile in textStreams) { if (string.IsNullOrEmpty(subtitleFile.Filename)) { continue; } var newParent = Path.GetDirectoryName(newFullServerPath); var srcParent = Path.GetDirectoryName(originalFileName); if (string.IsNullOrEmpty(newParent) || string.IsNullOrEmpty(srcParent)) { continue; } var subPath = Path.Combine(srcParent, subtitleFile.Filename); if (!File.Exists(subPath)) { continue; } var subFile = new FileInfo(subPath); string newSubPath = Path.Combine(newParent, subFile.Name); if (File.Exists(newSubPath)) { try { File.Delete(newSubPath); } catch (Exception e) { logger.Warn("Unable to DELETE file: {0} error {1}", subtitleFile, e); } } try { subFile.MoveTo(newSubPath); } catch (Exception e) { logger.Error("Unable to MOVE file: {0} to {1} error {2}", subtitleFile, newSubPath, e); } } } catch (Exception ex) { logger.Error(ex, ex.ToString()); } } catch (Exception ex) { string msg = $"Could not MOVE file: {FullServerPath ?? VideoLocal_Place_ID.ToString()} -- {ex}"; logger.Error(ex, msg); } ShokoServer.UnpauseWatchingFiles(); return(true); }
/// <summary> /// Checks the index. If it does not exists, this will start /// creating a new index. This process is recoverable/restartable and /// can/should be called each time the Search is expected to be used. /// </summary> /// <param name="force">if set to <c>true</c> a re-indexing of all /// items is started.</param> public void CheckIndex(bool force) { if (!UseIndex) { return; } bool restartIndexing = false; bool fileBasedIndex = this._settings.IndexPath != null && Directory.Exists(this._settings.IndexPath); string indexingStateFile = this.RestartIndexingStateFile; DateTime indexModifiedAt = DateTime.MinValue; if (fileBasedIndex) { indexModifiedAt = Directory.GetLastWriteTimeUtc(this._settings.IndexPath); bool indexStateFileExists = (indexingStateFile != null && File.Exists(indexingStateFile)); // if the index have to be (re-)created, we don't want to rely on old restart infos: if ((force || startIndexAll) && indexStateFileExists) { FileHelper.Delete(indexingStateFile); } // restart indexing: read state and go on with the next non-indexed feed restartIndexing = (!startIndexAll && indexStateFileExists); } else { startIndexAll = true; } if (force || restartIndexing || startIndexAll) { IDictionary restartInfo = null; DictionaryEntry lastIndexed = new DictionaryEntry(); if (restartIndexing) { // read indexState into restartInfo (persisted feed urls/id, that are yet indexed) restartInfo = ReadIndexingRestartStateFileContent(indexingStateFile, out lastIndexed); } if (restartInfo == null) { restartInfo = new HybridDictionary(); } if (startIndexAll) { this._indexModifier.CreateIndex(); } LuceneIndexer indexer = GetIndexer(); indexer.IndexingFinished += OnIndexingFinished; indexer.IndexingProgress += OnIndexingProgress; indexer.IndexAll(restartInfo, lastIndexed); } else if (fileBasedIndex) { // check, if we have to call OptimizeIndex(): DateTime lastIndexModification = this._settings.LastIndexOptimization; int compareResult = indexModifiedAt.CompareTo(lastIndexModification); // indexModifiedAt is greater than lastIndexModification, hence index was modified: if (compareResult > 0) { // attach event to get optimize index finished notification: this._indexModifier.FinishedIndexOperation += OnIndexModifierFinishedIndexOperation; this.IndexOptimize(); } else if (compareResult != 0) { // correct the bad persisted entry: this._settings.LastIndexOptimization = Directory.GetLastWriteTimeUtc(this._settings.IndexPath); } } }