public static void HandleSyntaxTree(SyntaxTreeAnalysisContext context, StyleCopSettings settings) { var syntaxRoot = context.Tree.GetRoot(context.CancellationToken); var firstTypeDeclaration = GetFirstTypeDeclaration(syntaxRoot); if (firstTypeDeclaration == null) { return; } if (firstTypeDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword)) { return; } string suffix; var fileName = FileNameHelpers.GetFileNameAndSuffix(context.Tree.FilePath, out suffix); var expectedFileName = FileNameHelpers.GetConventionalFileName(firstTypeDeclaration, settings.DocumentationRules.FileNamingConvention); if (string.Compare(fileName, expectedFileName, StringComparison.OrdinalIgnoreCase) != 0) { if (settings.DocumentationRules.FileNamingConvention == FileNamingConvention.StyleCop && string.Compare(fileName, FileNameHelpers.GetSimpleFileName(firstTypeDeclaration), StringComparison.OrdinalIgnoreCase) == 0) { return; } var properties = ImmutableDictionary.Create <string, string>() .Add(ExpectedFileNameKey, expectedFileName + suffix); context.ReportDiagnostic(Diagnostic.Create(Descriptor, firstTypeDeclaration.Identifier.GetLocation(), properties)); } }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(500, string.Format("{0} needs a paramter", Command))); } string dirToMake = GetPath(FileNameHelpers.AppendDirTag(sMessage)); // check directory name if (!FileNameHelpers.IsValid(dirToMake)) { return(GetMessage(553, string.Format("\"{0}\": Invalid directory name", sMessage))); } // check whether directory already exists if (ConnectionObject.FileSystemObject.DirectoryExists(dirToMake)) { return(GetMessage(553, string.Format("Directory \"{0}\" already exists", sMessage))); } // create directory if (!ConnectionObject.FileSystemObject.CreateDirectory(dirToMake)) { return(GetMessage(550, string.Format("Couldn't create directory. ({0})", sMessage))); } return(GetMessage(257, string.Format("{0} successful \"{1}\".", Command, dirToMake))); }
protected override async Task <string> OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(501, string.Format("{0} needs a parameter", Command))); } string sFile = GetPath(sMessage); if (!FileNameHelpers.IsValid(sFile)) { return(GetMessage(553, string.Format("\"{0}\" is not a valid file name", sMessage))); } var socketData = new FtpDataSocket(ConnectionObject); if (!socketData.Loaded) { return(GetMessage(425, "Unable to establish the data connection")); } SocketHelpers.Send(ConnectionObject.Socket, GetMessage(150, "Opening connection for data transfer."), ConnectionObject.Encoding); if (!ConnectionObject.FileSystemObject.AppendFile(sFile, socketData.Socket.GetStream()).Result) { return(GetMessage(553, string.Format("{0} error", Command))); } // remove the orginal blob ContentMD5 await ConnectionObject.FileSystemObject.SetFileMd5(sFile, string.Empty); return(GetMessage(250, string.Format("{0} successful", Command))); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(501, string.Format("{0} needs a parameter", Command))); } string dirToRemove = GetPath(FileNameHelpers.AppendDirTag(sMessage)); // check whether directory exists if (!ConnectionObject.FileSystemObject.DirectoryExists(dirToRemove)) { return(GetMessage(550, string.Format("Directory \"{0}\" does not exist", dirToRemove))); } // can not delete root directory if (dirToRemove == "/") { return(GetMessage(553, "Can not remove root directory")); } // delete directory if (ConnectionObject.FileSystemObject.DeleteDirectory(dirToRemove)) { return(GetMessage(250, string.Format("{0} successful.", Command))); } else { return(GetMessage(550, string.Format("Couldn't remove directory ({0}).", dirToRemove))); } }
protected override async Task <string> OnProcess(string sMessage) { if (ConnectionObject.FileToRename.Length == 0) { return(GetMessage(503, "RNTO must be preceded by a RNFR.")); } string sOldFileName = ConnectionObject.FileToRename; ConnectionObject.FileToRename = ""; // note: sMessage = sMessage.Trim(); string sNewFileName = GetPath(sMessage); // check whether the new filename is valid if (!FileNameHelpers.IsValid(sNewFileName) || sNewFileName.EndsWith(@"/")) { return(GetMessage(553, string.Format("\"{0}\" is not a valid file name", sMessage))); } // check whether the new filename exists // note: azure allows file&virtualdir has the same name if (await ConnectionObject.FileSystemObject.FileExists(sNewFileName)) { return(GetMessage(553, string.Format("File already exists ({0}).", sMessage))); } if (!await ConnectionObject.FileSystemObject.Move(sOldFileName, sNewFileName)) { return(GetMessage(553, "Rename failed")); } return(GetMessage(250, "Renamed file successfully.")); }
public bool HasExtension(string extension) { Argument.IsNotNull(nameof(extension), extension); Argument.IsValid(nameof(extension), extension, extension.Length >= 2 && extension[0] == '.'); return(FileNameHelpers.HasExtension(CurrentPath, extension)); }
private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context, StyleCopSettings settings) { var syntaxRoot = context.Tree.GetRoot(context.CancellationToken); var typeNodes = GetTopLevelTypeDeclarations(syntaxRoot, settings); string suffix; var fileName = FileNameHelpers.GetFileNameAndSuffix(context.Tree.FilePath, out suffix); var preferredTypeNode = typeNodes.FirstOrDefault(n => FileNameHelpers.GetConventionalFileName(n, settings.DocumentationRules.FileNamingConvention) == fileName) ?? typeNodes.FirstOrDefault(); if (preferredTypeNode == null) { return; } var foundTypeName = NamedTypeHelpers.GetNameOrIdentifier(preferredTypeNode); var isPartialType = NamedTypeHelpers.IsPartialDeclaration(preferredTypeNode); foreach (var typeNode in typeNodes) { if (typeNode == preferredTypeNode || (isPartialType && foundTypeName == NamedTypeHelpers.GetNameOrIdentifier(typeNode))) { continue; } var location = NamedTypeHelpers.GetNameOrIdentifierLocation(typeNode); if (location != null) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, location)); } } }
public bool HasExtension(string extension) { // All these 3 assertions have been checked by contract! Debug.Assert(extension != null); Debug.Assert(extension.Length >= 2); Debug.Assert(extension[0] == '.'); return(FileNameHelpers.HasExtension(m_PathString, extension)); }
string[] FilterOutRequiredReqFile(string[] filesWithPath) { List <string> result = new List <string>(); foreach (string filename in filesWithPath) { if (FileNameHelpers.GetFileName(filename) != "required.req") { result.Add(filename); } } return(result.ToArray()); }
// Convert a string instance of a URI to a relative FTP path // Return the file name or the folder name public static string ToFtpPath(string s) { bool isDir = s.EndsWith(@"/"); if (isDir) { // Note: append the directory end tag "/" return(FileNameHelpers.GetDirectoryName(s) + "/"); } // the path is a file else { return(FileNameHelpers.GetFileName(s)); } }
protected override async Task <string> OnProcess(string sMessage) { sMessage = sMessage.Trim(); // Get the file/dir to list string targetToList = GetPath(sMessage); // checks the file/dir name if (!FileNameHelpers.IsValid(targetToList)) { return(GetMessage(501, string.Format("\"{0}\" is not a valid file/directory name", sMessage))); } bool targetIsFile = await ConnectionObject.FileSystemObject.FileExists(targetToList); bool targetIsDir = await ConnectionObject.FileSystemObject.DirectoryExists(FileNameHelpers.AppendDirTag(targetToList)); if (!targetIsFile && !targetIsDir) { return(GetMessage(550, string.Format("\"{0}\" not exists", sMessage))); } SocketHelpers.Send(ConnectionObject.Socket, string.Format("250- MLST {0}\r\n", targetToList), ConnectionObject.Encoding); StringBuilder response = new StringBuilder(); if (targetIsFile) { response.Append(" "); var fileInfo = await ConnectionObject.FileSystemObject.GetFileInfo(targetToList); response.Append(GenerateEntry(fileInfo)); response.Append("\r\n"); } if (targetIsDir) { response.Append(" "); var dirInfo = await ConnectionObject.FileSystemObject.GetDirectoryInfo(FileNameHelpers.AppendDirTag(targetToList)); response.Append(GenerateEntry(dirInfo)); response.Append("\r\n"); } SocketHelpers.Send(ConnectionObject.Socket, response.ToString(), ConnectionObject.Encoding); return(GetMessage(250, "MLST successful")); }
private static void HandleDifferentCourses(IEnumerable <ICourseLink> differentCourses) { foreach (var course in differentCourses) { var dirName = FileNameHelpers.FullyPrepareDirectory(course.Name.TrimInnerSpaces(), true); var linksWithinThisCourse = SharedVars.DownloadQueue .Where(link => link.ParentSection.ParentCourse == course) .ToList(); AdjustExtraPaths(linksWithinThisCourse, courseDirName: dirName, null); HandleDifferentSections(linksWithinThisCourse); } }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage.Length == 0) { return(GetMessage(501, string.Format("Syntax error. {0} needs a parameter", Command))); } // append the final '/' char string sMessageFull = FileNameHelpers.AppendDirTag(sMessage); #region change to the parent dir if (sMessageFull == @"../") { // get the parent directory string parentDir = GetParentDir(); if (parentDir == null) { return(GetMessage(550, "Root directory, cannot change to the parent directory")); } ConnectionObject.CurrentDirectory = parentDir; FtpServer.LogWrite(this, sMessage, 200, 0); return(GetMessage(200, string.Format("{0} Successful ({1})", Command, parentDir))); } #endregion if (!FileNameHelpers.IsValid(sMessageFull)) { FtpServer.LogWrite(this, sMessage, 550, 0); return(GetMessage(550, string.Format("\"{0}\" is not a valid directory string.", sMessage))); } // get the new directory path string newDirectory = GetPath(sMessageFull); // checks whether the new directory exists if (!ConnectionObject.FileSystemObject.DirectoryExists(newDirectory)) { FtpServer.LogWrite(this, sMessage, 550, 0); return(GetMessage(550, string.Format("\"{0}\" no such directory.", sMessage))); } ConnectionObject.CurrentDirectory = newDirectory; FtpServer.LogWrite(this, sMessage, 250, 0); return(GetMessage(250, string.Format("{0} Successful ({1})", Command, newDirectory))); }
protected override string OnProcess(string message) { message = message.Replace('/', '\\'); if (!FileNameHelpers.IsValid(message)) { return(GetMessage(550, "Not a valid directory string.")); } var dir = GetPath(message); if (!ConnectionObject.FileSystemObject.DirectoryExists(dir)) { return(GetMessage(550, "Not a valid directory.")); } ConnectionObject.CurrentDirectory = Path.Combine(ConnectionObject.CurrentDirectory, message); return(GetMessage(250, string.Format("CWD Successful ({0})", ConnectionObject.CurrentDirectory.Replace("\\", "/")))); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Replace('/', '\\'); if (!FileNameHelpers.IsValid(sMessage)) { return(this.GetMessage(550, "Not a valid directory string.")); } string sDirectory = this.GetPath(sMessage); if (!this.ConnectionObject.FileSystemObject.DirectoryExists(sDirectory)) { return(this.GetMessage(550, "Not a valid directory.")); } this.ConnectionObject.CurrentDirectory = Path.Combine(this.ConnectionObject.CurrentDirectory, sMessage); return(this.GetMessage(250, string.Format("CWD Successful ({0})", this.ConnectionObject.CurrentDirectory.Replace("\\", "/")))); }
protected override string OnProcess(string sMessage) { Stopwatch sw = new Stopwatch(); sw.Start(); if (ConnectionObject.FileToRename.Length == 0) { FtpServer.LogWrite(this, sMessage, 503, 0); return(GetMessage(503, "RNTO must be preceded by a RNFR.")); } string sOldFileName = ConnectionObject.FileToRename; ConnectionObject.FileToRename = ""; // note: sMessage = sMessage.Trim(); string sNewFileName = GetPath(sMessage); // check whether the new filename is valid if (!FileNameHelpers.IsValid(sNewFileName) || sNewFileName.EndsWith(@"/")) { FtpServer.LogWrite(this, sMessage, 553, 0); return(GetMessage(553, string.Format("\"{0}\" is not a valid file name", sMessage))); } // check whether the new filename exists // note: azure allows file&virtualdir has the same name if (ConnectionObject.FileSystemObject.FileExists(sNewFileName)) { FtpServer.LogWrite(this, sMessage, 553, sw.ElapsedMilliseconds); return(GetMessage(553, string.Format("File already exists ({0}).", sMessage))); } if (!ConnectionObject.FileSystemObject.Move(sOldFileName, sNewFileName)) { FtpServer.LogWrite(this, sMessage, 553, sw.ElapsedMilliseconds); return(GetMessage(553, "Rename failed")); } FtpServer.LogWrite(this, sMessage, 250, sw.ElapsedMilliseconds); return(GetMessage(250, "Renamed file successfully.")); }
protected string GenerateEntry(IFileInfo info) { StringBuilder entry = new StringBuilder(); bool isDirectory = info.IsDirectory(); if (isDirectory) { entry.Append("Type=dir; "); string dirName = FileNameHelpers.GetDirectoryName(info.Path()); entry.Append(dirName); } else { entry.Append(string.Format("Type=file;Size={0};Modify={1}; ", info.GetSize(), info.GetModifiedTime().ToString("yyyyMMddHHmmss"))); entry.Append(FileNameHelpers.GetFileName(info.Path())); } return(entry.ToString()); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(501, string.Format("{0} needs a parameter", Command))); } string sFile = GetPath(sMessage); Stopwatch sw = new Stopwatch(); sw.Start(); if (!FileNameHelpers.IsValid(sFile)) { FtpServer.LogWrite(this, sMessage, 553, sw.ElapsedMilliseconds); return(GetMessage(553, string.Format("\"{0}\" is not a valid file name", sMessage))); } var socketData = new FtpDataSocket(ConnectionObject); if (!socketData.Loaded) { return(GetMessage(425, "Unable to establish the data connection")); } SocketHelpers.Send(ConnectionObject.Socket, GetMessage(150, "Opening connection for data transfer."), ConnectionObject.Encoding); if (!ConnectionObject.FileSystemObject.AppendFile(sFile, socketData.Socket.GetStream())) { FtpServer.LogWrite(this, sMessage, 553, sw.ElapsedMilliseconds); return(GetMessage(553, string.Format("{0} error", Command))); } // remove the orginal blob ContentMD5 ConnectionObject.FileSystemObject.SetFileMd5(sFile, string.Empty); sw.Stop(); FtpServer.LogWrite(this, sMessage, 250, sw.ElapsedMilliseconds); return(GetMessage(250, string.Format("{0} successful", Command))); }
// build short list reply, only list the file names protected string BuildShortReply(string[] asFiles, string[] asDirectories) { var stringBuilder = new StringBuilder(); if (asFiles != null) { foreach (string filePath in asFiles) { stringBuilder.Append(string.Format("{0}\r\n", FileNameHelpers.GetFileName(filePath))); } } if (asDirectories != null) { foreach (string dirPath in asDirectories) { stringBuilder.Append(string.Format("{0}\r\n", FileNameHelpers.GetDirectoryName(dirPath))); } } return(stringBuilder.ToString()); }
private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context, StyleCopSettings settings) { var syntaxRoot = context.Tree.GetRoot(context.CancellationToken); var descentNodes = syntaxRoot.DescendantNodes(descendIntoChildren: node => node != null && !node.IsKind(SyntaxKind.ClassDeclaration)); var classNodes = from descentNode in descentNodes where descentNode.IsKind(SyntaxKind.ClassDeclaration) select descentNode as ClassDeclarationSyntax; string suffix; var fileName = FileNameHelpers.GetFileNameAndSuffix(context.Tree.FilePath, out suffix); var preferredClassNode = classNodes.FirstOrDefault(n => FileNameHelpers.GetConventionalFileName(n, settings.DocumentationRules.FileNamingConvention) == fileName) ?? classNodes.FirstOrDefault(); if (preferredClassNode == null) { return; } string foundClassName = null; bool isPartialClass = false; foundClassName = preferredClassNode.Identifier.Text; isPartialClass = preferredClassNode.Modifiers.Any(SyntaxKind.PartialKeyword); foreach (var classNode in classNodes) { if (classNode == preferredClassNode || (isPartialClass && foundClassName == classNode.Identifier.Text)) { continue; } var location = NamedTypeHelpers.GetNameOrIdentifierLocation(classNode); if (location != null) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, location)); } } }
private static void HandleDifferentSections(ICollection <IDownloadableLink> commonParentLinks) { var differentSections = commonParentLinks .Select(link => link.ParentSection) .Distinct() .ToList(); if (differentSections.Count > 1) { foreach (var section in differentSections) { var dirName = FileNameHelpers.FullyPrepareDirectory(section.Header.Name, true); var linksWithinThisSection = commonParentLinks .Where(link => link.ParentSection == section) .ToList(); AdjustExtraPaths(linksWithinThisSection, null, dirName); } } }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Replace('/', '\\'); if (!FileNameHelpers.IsValid(sMessage)) { return(GetMessage(550, "Not a valid directory string.")); } string sDirectory = GetPath(sMessage); if (!ConnectionObject.FileSystemObject.DirectoryExists(sDirectory)) { return(GetMessage(550, "Not a valid directory.")); } // Process the current path and remove the last child directory string current = ConnectionObject.CurrentDirectory.Replace(@"\", @"/"); if (current == @"/") { return(GetMessage(550, "Not a valid directory.")); } int lastDirectoryDelim = current.LastIndexOf(@"/"); if (lastDirectoryDelim > -1) { current = current.Remove(lastDirectoryDelim, current.Length - lastDirectoryDelim); } ConnectionObject.CurrentDirectory = current; return(GetMessage(250, string.Format("CWD Successful ({0})", ConnectionObject.CurrentDirectory.Replace("\\", "/")))); }
public async Task Download(string[] middlePath) { await CoursesClient.LazyRefresh(); await GetNameFromUrlNow(); string filename; switch (SharedVars.NamingMethod) { case NamingMethod.CoursesName: filename = FileFromCourses.FileNameAndExtensionOnly; break; case NamingMethod.UrlName: filename = FileFromUrl.FileNameAndExtensionOnly; break; default: filename = FileFromUrl.FileNameAndExtensionOnly; break; } var filepath = FileNameHelpers.FullyPrepareFile(filename, middlePath); FileFromUrl.FullPathAndFileAndExtension = FileFromCourses.FullPathAndFileAndExtension = filepath; var fileInfo = new FileInfo(filepath); if (!fileInfo.Directory?.Exists ?? false) { fileInfo.Directory.Create(); } await GetAndSaveFile(filepath); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(211, "Server status: OK")); } // if no parameter is given, STAT works as LIST // but won't use data connection string[] asFiles = null; string[] asDirectories = null; // Get the file/dir to list string targetToList = GetPath(sMessage); // checks the file/dir name if (!FileNameHelpers.IsValid(targetToList)) { return(GetMessage(501, string.Format("\"{0}\" is not a valid file/directory name", sMessage))); } // two vars indicating different list results bool targetIsFile = false; bool targetIsDir = false; // targetToList ends with '/', must be a directory if (targetToList.EndsWith(@"/")) { targetIsFile = false; if (ConnectionObject.FileSystemObject.DirectoryExists(targetToList)) { targetIsDir = true; } } else { // check whether the target to list is a directory if (ConnectionObject.FileSystemObject.DirectoryExists(FileNameHelpers.AppendDirTag(targetToList))) { targetIsDir = true; } // check whether the target to list is a file if (ConnectionObject.FileSystemObject.FileExists(targetToList)) { targetIsFile = true; } } if (targetIsFile) { asFiles = new string[1] { targetToList }; if (targetIsDir) { asDirectories = new string[1] { FileNameHelpers.AppendDirTag(targetToList) } } ; } // list a directory else if (targetIsDir) { targetToList = FileNameHelpers.AppendDirTag(targetToList); asFiles = ConnectionObject.FileSystemObject.GetFiles(targetToList); asDirectories = ConnectionObject.FileSystemObject.GetDirectories(targetToList); } else { return(GetMessage(550, string.Format("\"{0}\" not exists", sMessage))); } // generate the response string sFileList = BuildReply(asFiles, asDirectories); SocketHelpers.Send(ConnectionObject.Socket, string.Format("213-Begin STAT \"{0}\":\r\n", sMessage), ConnectionObject.Encoding); SocketHelpers.Send(ConnectionObject.Socket, sFileList, ConnectionObject.Encoding); return(GetMessage(213, string.Format("{0} successful.", Command))); }
protected override async Task <string> OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(501, string.Format("{0} needs a parameter", Command))); } string sFile = GetPath(sMessage); if (!FileNameHelpers.IsValid(sFile) || sFile.EndsWith(@"/")) { return(GetMessage(553, string.Format("\"{0}\" is not a valid file name", sMessage))); } if (await ConnectionObject.FileSystemObject.FileExists(sFile)) { return(GetMessage(553, string.Format("File \"{0}\" already exists.", sMessage))); } var socketData = new FtpDataSocket(ConnectionObject); if (!socketData.Loaded) { return(GetMessage(425, "Unable to establish the data connection")); } IFile file = await ConnectionObject.FileSystemObject.OpenFile(sFile, true); if (file == null) { socketData.Close();// close data socket return(GetMessage(550, "Couldn't open file")); } SocketHelpers.Send(ConnectionObject.Socket, GetMessage(150, "Opening connection for data transfer."), ConnectionObject.Encoding); string md5Value = string.Empty; // TYPE I, default if (ConnectionObject.DataType == DataType.Image) { // md5 hash function MD5 md5Hash = MD5.Create(); var abData = new byte[m_nBufferSize]; int nReceived = socketData.Receive(abData); while (nReceived > 0) { int writeSize = file.Write(abData, nReceived); // maybe error if (writeSize != nReceived) { file.Close(); socketData.Close(); return(GetMessage(451, "Write data to Azure error!")); } md5Hash.TransformBlock(abData, 0, nReceived, null, 0); nReceived = socketData.Receive(abData); } md5Hash.TransformFinalBlock(new byte[1], 0, 0); md5Value = BytesToStr(md5Hash.Hash); } // TYPE A // won't compute md5, because read characters from client stream else if (ConnectionObject.DataType == DataType.Ascii) { int readSize = SocketHelpers.CopyStreamAscii(socketData.Socket.GetStream(), file.BlobStream, m_nBufferSize); FtpServerMessageHandler.SendMessage(ConnectionObject.Id, string.Format("Use ascii type success, read {0} chars!", readSize)); } else { // mustn't reach file.Close(); socketData.Close(); return(GetMessage(451, "Error in transfer data: invalid data type.")); } // upload notification await ConnectionObject.FileSystemObject.Log4Upload(sFile); file.Close(); socketData.Close(); // record md5 await ConnectionObject.FileSystemObject.SetFileMd5(sFile, md5Value); return(GetMessage(226, string.Format("{0} successful", Command))); }
private static async Task <Solution> GetTransformedSolutionAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxNode node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true); if (!(node is MemberDeclarationSyntax memberDeclarationSyntax)) { return(document.Project.Solution); } DocumentId extractedDocumentId = DocumentId.CreateNewId(document.Project.Id); string suffix; FileNameHelpers.GetFileNameAndSuffix(document.Name, out suffix); var settings = document.Project.AnalyzerOptions.GetStyleCopSettings(root.SyntaxTree, cancellationToken); string extractedDocumentName = FileNameHelpers.GetConventionalFileName(memberDeclarationSyntax, settings.DocumentationRules.FileNamingConvention) + suffix; List <SyntaxNode> nodesToRemoveFromExtracted = new List <SyntaxNode>(); SyntaxNode previous = node; for (SyntaxNode current = node.Parent; current != null; previous = current, current = current.Parent) { foreach (SyntaxNode child in current.ChildNodes()) { if (child == previous) { continue; } switch (child.Kind()) { case SyntaxKind.NamespaceDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.StructDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.EnumDeclaration: case SyntaxKind.DelegateDeclaration: nodesToRemoveFromExtracted.Add(child); break; default: break; } } } // Add the new file SyntaxNode extractedDocumentNode = root.RemoveNodes(nodesToRemoveFromExtracted, SyntaxRemoveOptions.KeepUnbalancedDirectives); Solution updatedSolution = document.Project.Solution.AddDocument(extractedDocumentId, extractedDocumentName, extractedDocumentNode, document.Folders); // Make sure to also add the file to linked projects foreach (var linkedDocumentId in document.GetLinkedDocumentIds()) { DocumentId linkedExtractedDocumentId = DocumentId.CreateNewId(linkedDocumentId.ProjectId); updatedSolution = updatedSolution.AddDocument(linkedExtractedDocumentId, extractedDocumentName, extractedDocumentNode, document.Folders); } // Remove the type from its original location updatedSolution = updatedSolution.WithDocumentSyntaxRoot(document.Id, root.RemoveNode(node, SyntaxRemoveOptions.KeepUnbalancedDirectives)); return(updatedSolution); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); string[] asFiles = null; string[] asDirectories = null; // Get the file/dir to list string targetToList = GetPath(sMessage); // checks the file/dir name if (!FileNameHelpers.IsValid(targetToList)) { return(GetMessage(501, string.Format("\"{0}\" is not a valid file/directory name", sMessage))); } // two vars indicating different list results bool targetIsFile = false; bool targetIsDir = false; // targetToList ends with '/', must be a directory if (targetToList.EndsWith(@"/")) { targetIsFile = false; if (ConnectionObject.FileSystemObject.DirectoryExists(targetToList)) { targetIsDir = true; } } else { // check whether the target to list is a directory if (ConnectionObject.FileSystemObject.DirectoryExists(FileNameHelpers.AppendDirTag(targetToList))) { targetIsDir = true; } // check whether the target to list is a file if (ConnectionObject.FileSystemObject.FileExists(targetToList)) { targetIsFile = true; } } if (targetIsFile) { asFiles = new string[1] { targetToList }; if (targetIsDir) { asDirectories = new string[1] { FileNameHelpers.AppendDirTag(targetToList) } } ; } // list a directory else if (targetIsDir) { targetToList = FileNameHelpers.AppendDirTag(targetToList); asFiles = ConnectionObject.FileSystemObject.GetFiles(targetToList); asDirectories = ConnectionObject.FileSystemObject.GetDirectories(targetToList); } else { return(GetMessage(550, string.Format("\"{0}\" not exists", sMessage))); } var socketData = new FtpDataSocket(ConnectionObject); if (!socketData.Loaded) { return(GetMessage(425, "Unable to establish the data connection")); } // prepare to write response to data channel SocketHelpers.Send(ConnectionObject.Socket, string.Format("150 Opening data connection for {0}\r\n", Command), ConnectionObject.Encoding); // generate the response string sFileList = BuildReply(asFiles, asDirectories); // ToDo, send response according to ConnectionObject.DataType, i.e., Ascii or Binary socketData.Send(sFileList, Encoding.UTF8); socketData.Close(); return(GetMessage(226, string.Format("{0} successful.", Command))); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); // Get the dir to list string targetToList = GetPath(sMessage); // checks the dir name if (!FileNameHelpers.IsValid(targetToList)) { return(GetMessage(501, $"\"{sMessage}\" is not a valid directory name")); } // specify the directory tag targetToList = FileNameHelpers.AppendDirTag(targetToList); bool targetIsDir = ConnectionObject.FileSystemObject.DirectoryExists(targetToList); if (!targetIsDir) { return(GetMessage(550, $"Directory \"{targetToList}\" not exists")); } #region Generate response StringBuilder response = new StringBuilder(); string[] files = ConnectionObject.FileSystemObject.GetFiles(targetToList); string[] directories = ConnectionObject.FileSystemObject.GetDirectories(targetToList); if (files != null && files.Any()) { foreach (var file in files) { var fileInfo = ConnectionObject.FileSystemObject.GetFileInfo(file); response.Append(GenerateEntry(fileInfo)); response.Append("\r\n"); } } if (directories != null && directories.Any()) { foreach (var dir in directories) { var dirInfo = ConnectionObject.FileSystemObject.GetDirectoryInfo(dir); response.Append(GenerateEntry(dirInfo)); response.Append("\r\n"); } } #endregion #region Write response var socketData = new FtpDataSocket(ConnectionObject); if (!socketData.Loaded) { return(GetMessage(425, "Unable to establish the data connection")); } SocketHelpers.Send(ConnectionObject.Socket, $"150 {ConnectionObject.DataType} Opening data connection for MLSD {targetToList}\r\n", ConnectionObject.Encoding); try { // ToDo, send response according to ConnectionObject.DataType, i.e., Ascii or Binary socketData.Send(response.ToString(), ConnectionObject.Encoding); } finally { socketData.Close(); } #endregion return(GetMessage(226, "MLSD successful")); }
protected override string OnProcess(string sMessage) { sMessage = sMessage.Trim(); if (sMessage == "") { return(GetMessage(501, string.Format("{0} needs a parameter", Command))); } string sFile = GetPath(sMessage); if (!FileNameHelpers.IsValid(sFile) || sFile.EndsWith(@"/")) { return(GetMessage(553, string.Format("\"{0}\" is not a valid file name", sMessage))); } if (ConnectionObject.FileSystemObject.FileExists(sFile)) { // 2015-11-24 cljung : RFC959 says STOR commands overwrite files, so delete if exists if (!StorageProviderConfiguration.FtpOverwriteFileOnSTOR) { return(GetMessage(553, string.Format("File \"{0}\" already exists.", sMessage))); } Trace.TraceInformation(string.Format("STOR {0} - Deleting existing file", sFile)); if (!ConnectionObject.FileSystemObject.DeleteFile(sFile)) { return(GetMessage(550, string.Format("Delete file \"{0}\" failed.", sFile))); } } var socketData = new FtpDataSocket(ConnectionObject); if (!socketData.Loaded) { return(GetMessage(425, "Unable to establish the data connection")); } Trace.TraceInformation(string.Format("STOR {0} - BEGIN", sFile)); IFile file = ConnectionObject.FileSystemObject.OpenFile(sFile, true); if (file == null) { socketData.Close();// close data socket return(GetMessage(550, "Couldn't open file")); } SocketHelpers.Send(ConnectionObject.Socket, GetMessage(150, "Opening connection for data transfer."), ConnectionObject.Encoding); string md5Value = string.Empty; Stopwatch sw = new Stopwatch(); sw.Start(); // TYPE I, default if (ConnectionObject.DataType == DataType.Image) { // md5 hash function MD5 md5Hash = MD5.Create(); var abData = new byte[m_nBufferSize]; int nReceived = socketData.Receive(abData); while (nReceived > 0) { int writeSize = file.Write(abData, nReceived); // maybe error if (writeSize != nReceived) { file.Close(); socketData.Close(); FtpServer.LogWrite(this, sMessage, 451, sw.ElapsedMilliseconds); return(GetMessage(451, "Write data to Azure error!")); } md5Hash.TransformBlock(abData, 0, nReceived, null, 0); nReceived = socketData.Receive(abData); } md5Hash.TransformFinalBlock(new byte[1], 0, 0); md5Value = BytesToStr(md5Hash.Hash); } // TYPE A // won't compute md5, because read characters from client stream else if (ConnectionObject.DataType == DataType.Ascii) { int readSize = SocketHelpers.CopyStreamAscii(socketData.Socket.GetStream(), file.BlobStream, m_nBufferSize); FtpServerMessageHandler.SendMessage(ConnectionObject.Id, string.Format("Use ascii type success, read {0} chars!", readSize)); } else // mustn't reach { file.Close(); socketData.Close(); FtpServer.LogWrite(this, sMessage, 451, sw.ElapsedMilliseconds); return(GetMessage(451, "Error in transfer data: invalid data type.")); } sw.Stop(); Trace.TraceInformation(string.Format("STOR {0} - END, Time {1} ms", sFile, sw.ElapsedMilliseconds)); // upload notification ConnectionObject.FileSystemObject.Log4Upload(sFile); file.Close(); socketData.Close(); // record md5 ConnectionObject.FileSystemObject.SetFileMd5(sFile, md5Value); FtpServer.LogWrite(this, sMessage, 226, sw.ElapsedMilliseconds); return(GetMessage(226, string.Format("{0} successful. Time {1} ms", Command, sw.ElapsedMilliseconds))); }
private string GetLongProperty(IFileInfo info) { if (info == null) { return(null); } var stringBuilder = new StringBuilder(); // permissions string sAttributes = info.GetAttributeString(); stringBuilder.Append(sAttributes); stringBuilder.Append(" 1 owner group"); // check whether info is directory bool isDirectory = info.IsDirectory(); // size string sFileSize = info.GetSize().ToString(); // if info is directory, the size will be 1 stringBuilder.Append(TextHelpers.RightAlignString(sFileSize, 13, ' ')); stringBuilder.Append(" "); // modify time DateTimeOffset fileDate = info.GetModifiedTime(); //if info is directory, the modify time will be the current time // month stringBuilder.Append(TextHelpers.Month(fileDate.Month)); stringBuilder.Append(" "); // day string sDay = fileDate.Day.ToString(); if (sDay.Length == 1) { stringBuilder.Append(" "); } stringBuilder.Append(sDay); stringBuilder.Append(" "); // year or hour:min if (fileDate.Year < DateTime.Now.Year) { stringBuilder.Append(" " + fileDate.Year); } else { stringBuilder.Append(string.Format("{0:hh}:{1:mm}", fileDate, fileDate)); } stringBuilder.Append(" "); // filename string path = info.Path(); if (isDirectory) { stringBuilder.Append(FileNameHelpers.GetDirectoryName(path)); } else { stringBuilder.Append(FileNameHelpers.GetFileName(path)); } // end stringBuilder.Append("\r\n"); return(stringBuilder.ToString()); }