public virtual Task <HttpResponseMessage> PutItem() { string localFilePath = GetLocalFilePath(); HttpResponseMessage response; if (VfsSpecialFolders.TryHandleRequest(Request, localFilePath, out response)) { return(Task.FromResult(response)); } DirectoryInfoBase info = FileSystemHelpers.DirectoryInfoFromDirectoryName(localFilePath); bool itemExists = info.Attributes >= 0; if (itemExists && (info.Attributes & FileAttributes.Directory) != 0) { return(CreateDirectoryPutResponse(info, localFilePath)); } else { // If request URI ends in a "/" then attempt to create the directory. if (localFilePath[localFilePath.Length - 1] == Path.DirectorySeparatorChar) { return(CreateDirectoryPutResponse(info, localFilePath)); } // We are ready to update the file return(CreateItemPutResponse(info, localFilePath, itemExists)); } }
private static void OldRunsCleanup(string jobName, IEnvironment environment, ITraceFactory traceFactory, IDeploymentSettingsManager settings) { // if max is 5 and we have 5 we still want to remove one to make room for the next // that's why we decrement max value by 1 int maxRuns = settings.GetWebJobsHistorySize() - 1; string historyPath = Path.Combine(environment.JobsDataPath, Constants.TriggeredPath, jobName); DirectoryInfoBase historyDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(historyPath); if (!historyDirectory.Exists) { return; } DirectoryInfoBase[] historyRunsDirectories = historyDirectory.GetDirectories(); if (historyRunsDirectories.Length <= maxRuns) { return; } var directoriesToRemove = historyRunsDirectories.OrderByDescending(d => d.Name).Skip(maxRuns); foreach (DirectoryInfoBase directory in directoriesToRemove) { try { directory.Delete(true); } catch (Exception ex) { traceFactory.GetTracer().TraceError(ex); } } }
private static string GetPreInstalledLatestVersion(string directory) { if (!FileSystemHelpers.DirectoryExists(directory)) { return(null); } string[] pathStrings = FileSystemHelpers.GetDirectories(directory); if (pathStrings.Length == 0) { return(null); } return(pathStrings.Max(path => { string versionString = FileSystemHelpers.DirectoryInfoFromDirectoryName(path).Name; SemanticVersion semVer; if (SemanticVersion.TryParse(versionString, out semVer)) { return semVer; } else { return new SemanticVersion(0, 0, 0, 0); } }).ToString()); }
public static IEnumerable <VfsStatEntry> GetEntries(string baseAddress, string query) { if (!String.IsNullOrEmpty(SystemDrivePath)) { var dir = FileSystemHelpers.DirectoryInfoFromDirectoryName(SystemDrivePath + Path.DirectorySeparatorChar); yield return(new VfsStatEntry { Name = SystemDriveFolder, MTime = dir.LastWriteTimeUtc, CRTime = dir.CreationTimeUtc, Mime = "inode/shortcut", Href = baseAddress + Uri.EscapeUriString(SystemDriveFolder + VfsControllerBase.UriSegmentSeparator) + query, Path = dir.FullName }); } if (!String.IsNullOrEmpty(LocalSiteRootPath)) { var dir = FileSystemHelpers.DirectoryInfoFromDirectoryName(LocalSiteRootPath); yield return(new VfsStatEntry { Name = LocalSiteRootFolder, MTime = dir.LastWriteTimeUtc, CRTime = dir.CreationTimeUtc, Mime = "inode/shortcut", Href = baseAddress + Uri.EscapeUriString(LocalSiteRootFolder + VfsControllerBase.UriSegmentSeparator) + query, Path = dir.FullName }); } }
private static string GetLatestPreInstalledExtensionVersion(string id) { try { IEnumerable <string> pathStrings = FileSystemHelpers.GetDirectories("D:\\Program Files (x86)\\SiteExtensions\\" + id); SemanticVersion maxVersion = pathStrings.Max(path => { string versionString = FileSystemHelpers.DirectoryInfoFromDirectoryName(path).Name; SemanticVersion semVer; if (SemanticVersion.TryParse(versionString, out semVer)) { return(semVer); } else { return(new SemanticVersion(0, 0, 0, 0)); } }); return(maxVersion.ToString()); } catch (IOException) { return(null); } }
public TriggeredJobRun GetJobRun(string jobName, string runId) { string triggeredJobRunPath = Path.Combine(JobsDataPath, jobName, runId); DirectoryInfoBase triggeredJobRunDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(triggeredJobRunPath); return(BuildJobRun(triggeredJobRunDirectory, jobName, isLatest: true)); }
public LogFileFinder(IEnvironment env, ITracer tracer, LogFileAccessStats stats = null) { ExcludedFiles = new HashSet <string>(); IncludedFiles = new HashSet <string>(); _stats = stats; _tracer = tracer; _directory = FileSystemHelpers.DirectoryInfoFromDirectoryName(env.ApplicationLogFilesPath); }
internal static Dictionary <string, FileInfoBase> GetJobDirectoryFileMap(string sourceDirectory) { DirectoryInfoBase jobBinariesDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(sourceDirectory); FileInfoBase[] files = jobBinariesDirectory.GetFiles("*.*", SearchOption.AllDirectories); int sourceDirectoryPathLength = sourceDirectory.Length + 1; return(files.ToDictionary(p => p.FullName.Substring(sourceDirectoryPathLength), q => q, StringComparer.OrdinalIgnoreCase)); }
private async Task LocalZipFetch(IRepository repository, DeploymentInfoBase deploymentInfo, string targetBranch, ILogger logger, ITracer tracer) { var zipDeploymentInfo = (ZipDeploymentInfo)deploymentInfo; // If this was a request with a Zip URL in the JSON, we need to deploy the zip locally and get the path // Otherwise, for this kind of deployment, RepositoryUrl is a local path. var sourceZipFile = !string.IsNullOrEmpty(zipDeploymentInfo.ZipURL) ? await DeployZipLocally(zipDeploymentInfo, tracer) : zipDeploymentInfo.RepositoryUrl; var extractTargetDirectory = repository.RepositoryPath; var info = FileSystemHelpers.FileInfoFromFileName(sourceZipFile); var sizeInMb = (info.Length / (1024f * 1024f)).ToString("0.00", CultureInfo.InvariantCulture); var message = String.Format( CultureInfo.InvariantCulture, "Cleaning up temp folders from previous zip deployments and extracting pushed zip file {0} ({1} MB) to {2}", info.FullName, sizeInMb, extractTargetDirectory); logger.Log(message); using (tracer.Step(message)) { // If extractTargetDirectory already exists, rename it so we can delete it concurrently with // the unzip (along with any other junk in the folder) var targetInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(extractTargetDirectory); if (targetInfo.Exists) { var moveTarget = Path.Combine(targetInfo.Parent.FullName, Path.GetRandomFileName()); using (tracer.Step(string.Format("Renaming extractTargetDirectory({0}) to tempDirectory({1})", targetInfo.FullName, moveTarget))) { targetInfo.MoveTo(moveTarget); } } var cleanTask = Task.Run(() => DeleteFilesAndDirsExcept(sourceZipFile, extractTargetDirectory, tracer)); var extractTask = Task.Run(() => { FileSystemHelpers.CreateDirectory(extractTargetDirectory); using (var file = info.OpenRead()) using (var zip = new ZipArchive(file, ZipArchiveMode.Read)) { zip.Extract(extractTargetDirectory, tracer, _settings.GetZipDeployDoNotPreserveFileTime()); } }); await Task.WhenAll(cleanTask, extractTask); } CommitRepo(repository, zipDeploymentInfo); }
// OneDeploy Fetch handler for non-zip artifacts. // For zip files, OneDeploy uses the LocalZipHandler Fetch handler // NOTE: Do not access the request stream as it may have been closed during asynchronous scenarios private async Task OneDeployFetch(IRepository repository, DeploymentInfoBase deploymentInfo, string targetBranch, ILogger logger, ITracer tracer) { var artifactDeploymentInfo = (ArtifactDeploymentInfo)deploymentInfo; // This is the path where the artifact being deployed is staged, before it is copied to the final target location var artifactDirectoryStagingPath = repository.RepositoryPath; var targetInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(artifactDirectoryStagingPath); if (targetInfo.Exists) { // If tempDirPath already exists, rename it so we can delete it later var moveTarget = Path.Combine(targetInfo.Parent.FullName, Path.GetRandomFileName()); using (tracer.Step(string.Format("Renaming ({0}) to ({1})", targetInfo.FullName, moveTarget))) { targetInfo.MoveTo(moveTarget); } } // Create artifact staging directory before later use Directory.CreateDirectory(artifactDirectoryStagingPath); var artifactFileStagingPath = Path.Combine(artifactDirectoryStagingPath, deploymentInfo.TargetFileName); // If RemoteUrl is non-null, it means the content needs to be downloaded from the Url source to the staging location // Else, it had been downloaded already so we just move the downloaded file to the staging location if (!string.IsNullOrWhiteSpace(artifactDeploymentInfo.RemoteURL)) { using (tracer.Step("Saving request content to {0}", artifactFileStagingPath)) { var content = await DeploymentHelper.GetArtifactContentFromURL(artifactDeploymentInfo, tracer); var copyTask = content.CopyToAsync(artifactFileStagingPath, tracer); // Deletes all files and directories except for artifactFileStagingPath and artifactDirectoryStagingPath var cleanTask = Task.Run(() => DeleteFilesAndDirsExcept(artifactFileStagingPath, artifactDirectoryStagingPath, tracer)); // Lets the copy and cleanup tasks to run in parallel and wait for them to finish await Task.WhenAll(copyTask, cleanTask); } } else { var srcInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(deploymentInfo.RepositoryUrl); using (tracer.Step(string.Format("Moving {0} to {1}", targetInfo.FullName, artifactFileStagingPath))) { srcInfo.MoveTo(artifactFileStagingPath); } // Deletes all files and directories except for artifactFileStagingPath and artifactDirectoryStagingPath DeleteFilesAndDirsExcept(artifactFileStagingPath, artifactDirectoryStagingPath, tracer); } // The deployment flow expects at least 1 commit in the IRepository commit, refer to CommitRepo() for more info CommitRepo(repository, artifactDeploymentInfo); }
private FileInfoBase[] ListLogFiles() { try { return(FileSystemHelpers.DirectoryInfoFromDirectoryName(_directoryPath).GetFiles(SiteExtensionLogSearchPattern)); } catch { return(new FileInfoBase[0]); } }
public virtual Task <HttpResponseMessage> DeleteItem(bool recursive = false) { string localFilePath = GetLocalFilePath(); HttpResponseMessage response; if (VfsSpecialFolders.TryHandleRequest(Request, localFilePath, out response)) { return(Task.FromResult(response)); } DirectoryInfoBase dirInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(localFilePath); if (dirInfo.Attributes < 0) { HttpResponseMessage notFoundResponse = Request.CreateErrorResponse(HttpStatusCode.NotFound, String.Format("'{0}' not found.", dirInfo.FullName)); return(Task.FromResult(notFoundResponse)); } else if ((dirInfo.Attributes & FileAttributes.Directory) != 0) { try { dirInfo.Delete(recursive); } catch (Exception ex) { Tracer.TraceError(ex); HttpResponseMessage conflictDirectoryResponse = Request.CreateErrorResponse( HttpStatusCode.Conflict, Resources.VfsControllerBase_CannotDeleteDirectory); return(Task.FromResult(conflictDirectoryResponse)); } // Delete directory succeeded. HttpResponseMessage successResponse = Request.CreateResponse(HttpStatusCode.OK); return(Task.FromResult(successResponse)); } else { // If request URI ends in a "/" then redirect to one that does not if (localFilePath[localFilePath.Length - 1] == Path.DirectorySeparatorChar) { HttpResponseMessage redirectResponse = Request.CreateResponse(HttpStatusCode.TemporaryRedirect); UriBuilder location = new UriBuilder(Request.RequestUri); location.Path = location.Path.TrimEnd(_uriSegmentSeparator); redirectResponse.Headers.Location = location.Uri; return(Task.FromResult(redirectResponse)); } // We are ready to delete the file var fileInfo = FileSystemHelpers.FileInfoFromFileName(localFilePath); return(CreateFileDeleteResponse(fileInfo)); } }
private DirectoryInfoBase[] GetJobRunsDirectories(string jobName) { string jobHistoryPath = Path.Combine(JobsDataPath, jobName); DirectoryInfoBase jobHistoryDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(jobHistoryPath); if (!jobHistoryDirectory.Exists) { return(null); } return(jobHistoryDirectory.GetDirectories("*", SearchOption.TopDirectoryOnly)); }
private static int CalculateHashForJob(string jobBinariesPath) { var updateDatesString = new StringBuilder(); DirectoryInfoBase jobBinariesDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(jobBinariesPath); FileInfoBase[] files = jobBinariesDirectory.GetFiles("*.*", SearchOption.AllDirectories); foreach (FileInfoBase file in files) { updateDatesString.Append(file.LastWriteTimeUtc.Ticks); } return(updateDatesString.ToString().GetHashCode()); }
private Task LocalZipFetch(IRepository repository, DeploymentInfoBase deploymentInfo, string targetBranch, ILogger logger, ITracer tracer) { var zipDeploymentInfo = (ZipDeploymentInfo)deploymentInfo; // For this kind of deployment, RepositoryUrl is a local path. var sourceZipFile = zipDeploymentInfo.RepositoryUrl; var extractTargetDirectory = repository.RepositoryPath; var info = FileSystemHelpers.FileInfoFromFileName(sourceZipFile); var sizeInMb = (info.Length / (1024f * 1024f)).ToString("0.00", CultureInfo.InvariantCulture); var message = String.Format( CultureInfo.InvariantCulture, "Cleaning up temp folders from previous zip deployments and extracting pushed zip file {0} ({1} MB) to {2}", info.FullName, sizeInMb, extractTargetDirectory); logger.Log(message); using (tracer.Step(message)) { // If extractTargetDirectory already exists, rename it so we can delete it concurrently with // the unzip (along with any other junk in the folder) var targetInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(extractTargetDirectory); if (targetInfo.Exists) { var moveTarget = Path.Combine(targetInfo.Parent.FullName, Path.GetRandomFileName()); targetInfo.MoveTo(moveTarget); } DeleteFilesAndDirsExcept(sourceZipFile, extractTargetDirectory, tracer); FileSystemHelpers.CreateDirectory(extractTargetDirectory); using (var file = info.OpenRead()) using (var zip = new ZipArchive(file, ZipArchiveMode.Read)) { deploymentInfo.repositorySymlinks = zip.Extract(extractTargetDirectory, preserveSymlinks: ShouldPreserveSymlinks()); CreateZipSymlinks(deploymentInfo.repositorySymlinks, extractTargetDirectory); PermissionHelper.ChmodRecursive("777", extractTargetDirectory, tracer, TimeSpan.FromMinutes(1)); } } CommitRepo(repository, zipDeploymentInfo); return(Task.CompletedTask); }
private async Task LocalZipFetch(IRepository repository, DeploymentInfoBase deploymentInfo, string targetBranch, ILogger logger, ITracer tracer) { var zipDeploymentInfo = (ZipDeploymentInfo)deploymentInfo; // For this kind of deployment, RepositoryUrl is a local path. var sourceZipFile = zipDeploymentInfo.RepositoryUrl; var extractTargetDirectory = repository.RepositoryPath; var info = FileSystemHelpers.FileInfoFromFileName(sourceZipFile); var sizeInMb = (info.Length / (1024f * 1024f)).ToString("0.00", CultureInfo.InvariantCulture); var message = String.Format( CultureInfo.InvariantCulture, "Cleaning up temp folders from previous zip deployments and extracting pushed zip file {0} ({1} MB) to {2}", info.FullName, sizeInMb, extractTargetDirectory); logger.Log(message); using (tracer.Step(message)) { // If extractTargetDirectory already exists, rename it so we can delete it concurrently with // the unzip (along with any other junk in the folder) var targetInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(extractTargetDirectory); if (targetInfo.Exists) { var moveTarget = Path.Combine(targetInfo.Parent.FullName, Path.GetRandomFileName()); targetInfo.MoveTo(moveTarget); } var cleanTask = Task.Run(() => DeleteFilesAndDirsExcept(sourceZipFile, extractTargetDirectory, tracer)); var extractTask = Task.Run(() => { FileSystemHelpers.CreateDirectory(extractTargetDirectory); using (var file = info.OpenRead()) using (var zip = new ZipArchive(file, ZipArchiveMode.Read)) { zip.Extract(extractTargetDirectory); } }); await Task.WhenAll(cleanTask, extractTask); } // Needed in order for repository.GetChangeSet() to work. // Similar to what OneDriveHelper and DropBoxHelper do. repository.Commit(zipDeploymentInfo.Message, zipDeploymentInfo.Author, zipDeploymentInfo.AuthorEmail); }
public virtual Task <HttpResponseMessage> GetItem() { string localFilePath = GetLocalFilePath(); HttpResponseMessage response; if (VfsSpecialFolders.TryHandleRequest(Request, localFilePath, out response)) { return(Task.FromResult(response)); } DirectoryInfoBase info = FileSystemHelpers.DirectoryInfoFromDirectoryName(localFilePath); if (info.Attributes < 0) { HttpResponseMessage notFoundResponse = Request.CreateErrorResponse(HttpStatusCode.NotFound, String.Format("'{0}' not found.", info.FullName)); return(Task.FromResult(notFoundResponse)); } else if ((info.Attributes & FileAttributes.Directory) != 0) { // If request URI does NOT end in a "/" then redirect to one that does if (localFilePath[localFilePath.Length - 1] != Path.DirectorySeparatorChar) { HttpResponseMessage redirectResponse = Request.CreateResponse(HttpStatusCode.TemporaryRedirect); UriBuilder location = new UriBuilder(Request.RequestUri); location.Path += "/"; redirectResponse.Headers.Location = location.Uri; return(Task.FromResult(redirectResponse)); } else { return(CreateDirectoryGetResponse(info, localFilePath)); } } else { // If request URI ends in a "/" then redirect to one that does not if (localFilePath[localFilePath.Length - 1] == Path.DirectorySeparatorChar) { HttpResponseMessage redirectResponse = Request.CreateResponse(HttpStatusCode.TemporaryRedirect); UriBuilder location = new UriBuilder(Request.RequestUri); location.Path = location.Path.TrimEnd(_uriSegmentSeparator); redirectResponse.Headers.Location = location.Uri; return(Task.FromResult(redirectResponse)); } // We are ready to get the file return(CreateItemGetResponse(info, localFilePath)); } }
private static IEnumerable <SemanticVersion> GetSemanticVersionsFromFolder(string folder) { var directoryInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(folder); if (directoryInfo.Exists) { foreach (var dir in directoryInfo.GetDirectories()) { if (SemanticVersion.TryParse(dir.Name, out SemanticVersion semver)) { yield return(semver); } } } }
private static IEnumerable <Dictionary <string, string> > GetNodeVersions() { string nodeRoot = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "nodejs"); var directoryInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(nodeRoot); if (directoryInfo.Exists) { return(directoryInfo.GetDirectories() .Where(dir => _versionRegex.IsMatch(dir.Name)) .Select(dir => new Dictionary <string, string> { { VersionKey, dir.Name }, { "npm", TryReadNpmVersion(dir) } })); } return(Enumerable.Empty <Dictionary <string, string> >()); }
public virtual Task <IActionResult> DeleteItem(bool recursive = false) { string localFilePath = GetLocalFilePath(); if (VfsSpecialFolders.TryHandleRequest(Request, localFilePath, out IActionResult response)) { return(Task.FromResult(response)); } DirectoryInfoBase dirInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(localFilePath); if (dirInfo.Attributes < 0) { return(Task.FromResult((IActionResult)NotFound(String.Format("'{0}' not found.", dirInfo.FullName)))); } else if ((dirInfo.Attributes & FileAttributes.Directory) != 0) { try { dirInfo.Delete(recursive); } catch (Exception ex) { Tracer.TraceError(ex); return(Task.FromResult((IActionResult)StatusCode(StatusCodes.Status409Conflict, Resources.VfsControllerBase_CannotDeleteDirectory))); } // Delete directory succeeded. return(Task.FromResult((IActionResult)Ok())); } else { // If request URI ends in a "/" then redirect to one that does not if (localFilePath[localFilePath.Length - 1] == Path.DirectorySeparatorChar) { UriBuilder location = new UriBuilder(UriHelper.GetRequestUri(Request)); location.Path = location.Path.TrimEnd(_uriSegmentSeparator); return(Task.FromResult((IActionResult)RedirectPreserveMethod(location.Uri.ToString()))); } // We are ready to delete the file var fileInfo = FileSystemHelpers.FileInfoFromFileName(localFilePath); return(CreateFileDeleteResponse(fileInfo)); } }
public static void CleanupDeletedJobs(IEnumerable <string> existingJobs, string jobsDataPath, ITracer tracer) { DirectoryInfoBase jobsDataDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(jobsDataPath); if (jobsDataDirectory.Exists) { DirectoryInfoBase[] jobDataDirectories = jobsDataDirectory.GetDirectories("*", SearchOption.TopDirectoryOnly); IEnumerable <string> allJobDataDirectories = jobDataDirectories.Select(j => j.Name); IEnumerable <string> directoriesToRemove = allJobDataDirectories.Except(existingJobs, StringComparer.OrdinalIgnoreCase); foreach (string directoryToRemove in directoriesToRemove) { using (tracer.Step("CleanupDeletedJobs")) { tracer.Trace("Removed job data path as the job was already deleted: " + directoryToRemove); FileSystemHelpers.DeleteDirectorySafe(Path.Combine(jobsDataPath, directoryToRemove)); } } } }
public virtual Task <IActionResult> GetItem() { string localFilePath = GetLocalFilePath(); if (VfsSpecialFolders.TryHandleRequest(Request, localFilePath, out IActionResult response)) { return(Task.FromResult(response)); } DirectoryInfoBase info = FileSystemHelpers.DirectoryInfoFromDirectoryName(localFilePath); if (info.Attributes < 0) { return(Task.FromResult((IActionResult)NotFound(String.Format("'{0}' not found.", info.FullName)))); } else if ((info.Attributes & FileAttributes.Directory) != 0) { // If request URI does NOT end in a "/" then redirect to one that does if (localFilePath[localFilePath.Length - 1] != Path.DirectorySeparatorChar) { UriBuilder location = new UriBuilder(UriHelper.GetRequestUri(Request)); location.Path += "/"; return(Task.FromResult((IActionResult)RedirectPreserveMethod(location.Uri.ToString()))); } else { return(CreateDirectoryGetResponse(info, localFilePath)); } } else { // If request URI ends in a "/" then redirect to one that does not if (localFilePath[localFilePath.Length - 1] == Path.DirectorySeparatorChar) { UriBuilder location = new UriBuilder(UriHelper.GetRequestUri(Request)); location.Path = location.Path.TrimEnd(_uriSegmentSeparator); return(Task.FromResult((IActionResult)RedirectPreserveMethod(location.Uri.ToString()))); } // We are ready to get the file return(CreateItemGetResponse(info, localFilePath)); } }
private static string GetPreInstalledLatestVersion(string directory) { IEnumerable <string> pathStrings = FileSystemHelpers.GetDirectories(directory); SemanticVersion maxVersion = pathStrings.Max(path => { string versionString = FileSystemHelpers.DirectoryInfoFromDirectoryName(path).Name; SemanticVersion semVer; if (SemanticVersion.TryParse(versionString, out semVer)) { return(semVer); } else { return(new SemanticVersion(0, 0, 0, 0)); } }); return(maxVersion.ToString()); }
private DirectoryInfoBase[] GetJobRunsDirectories(string jobName) { string jobHistoryPath = Path.Combine(JobsDataPath, jobName); DirectoryInfoBase jobHistoryDirectory = FileSystemHelpers.DirectoryInfoFromDirectoryName(jobHistoryPath); if (!jobHistoryDirectory.Exists) { return(null); } try { return(jobHistoryDirectory.GetDirectories("*", SearchOption.TopDirectoryOnly)); } catch (Exception ex) { Analytics.UnexpectedException(ex); return(null); } }
private static void SetPreInstalledExtensionInfo(SiteExtensionInfo info) { try { string directory = GetPreInstalledDirectory(info.Id); if (info.Type == SiteExtensionInfo.SiteExtensionType.PreInstalledNonKudu) { IEnumerable <string> pathStrings = FileSystemHelpers.GetDirectories(directory); SemanticVersion maxVersion = pathStrings.Max(path => { string versionString = FileSystemHelpers.DirectoryInfoFromDirectoryName(path).Name; SemanticVersion semVer; if (SemanticVersion.TryParse(versionString, out semVer)) { return(semVer); } else { return(new SemanticVersion(0, 0, 0, 0)); } }); info.Version = maxVersion.ToString(); } else if (info.Type == SiteExtensionInfo.SiteExtensionType.PreInstalledKuduModule) { info.Version = typeof(SiteExtensionManager).Assembly.GetName().Version.ToString(); } } catch (IOException) { info.Version = null; } info.LocalIsLatestVersion = true; }
/// <summary> /// Populates a <see cref="ZipArchive"/> with the content of the function app. /// It can also include local.settings.json and .csproj files for a full Visual Studio project. /// sln file is not included since it changes between VS versions and VS can auto-generate it from the csproj. /// All existing functions are added as content with "Always" copy to output. /// </summary> /// <param name="zip">the <see cref="ZipArchive"/> to be populated with function app content.</param> /// <param name="includeAppSettings">Optional: indicates whether to add local.settings.json or not to the archive. Default is false.</param> /// <param name="includeCsproj">Optional: indicates whether to add a .csproj to the archive. Default is false.</param> /// <param name="projectName">Optional: the name for *.csproj file if <paramref name="includeCsproj"/> is true. Default is appName.</param> public void CreateArchive(ZipArchive zip, bool includeAppSettings = false, bool includeCsproj = false, string projectName = null) { var tracer = _traceFactory.GetTracer(); var directoryInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(_environment.FunctionsPath); // First add the entire wwwroot folder at the root of the zip. IList <ZipArchiveEntry> files; zip.AddDirectory(directoryInfo, tracer, string.Empty, out files); if (includeAppSettings) { // include local.settings.json if needed. files.Add(AddAppSettingsFile(zip)); } if (includeCsproj) { // include .csproj for Visual Studio if needed. projectName = projectName ?? ServerConfiguration.GetApplicationName(); AddCsprojFile(zip, files, projectName); } }
private async Task OneDeployFetch(IRepository repository, DeploymentInfoBase deploymentInfo, string targetBranch, ILogger logger, ITracer tracer) { var artifactDeploymentInfo = (ArtifactDeploymentInfo)deploymentInfo; // For this kind of deployment, RepositoryUrl is a local path. var sourceZipFile = artifactDeploymentInfo.RepositoryUrl; // This is the path where the artifact being deployed is staged, before it is copied to the final target location var artifactDirectoryStagingPath = repository.RepositoryPath; var info = FileSystemHelpers.FileInfoFromFileName(sourceZipFile); var sizeInMb = (info.Length / (1024f * 1024f)).ToString("0.00", CultureInfo.InvariantCulture); var message = String.Format( CultureInfo.InvariantCulture, "Cleaning up temp folders from previous zip deployments and extracting pushed zip file {0} ({1} MB) to {2}", info.FullName, sizeInMb, artifactDirectoryStagingPath); using (tracer.Step(message)) { var targetInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(artifactDirectoryStagingPath); if (targetInfo.Exists) { // If the staging path already exists, rename it so we can delete it later var moveTarget = Path.Combine(targetInfo.Parent.FullName, Path.GetRandomFileName()); using (tracer.Step(string.Format("Renaming ({0}) to ({1})", targetInfo.FullName, moveTarget))) { targetInfo.MoveTo(moveTarget); } } // // We want to create a directory structure under 'extractTargetDirectory' // such that it exactly matches the directory structure specified // by deploymentInfo.TargetSubDirectoryRelativePath // string stagingSubDirPath = artifactDirectoryStagingPath; if (!string.IsNullOrWhiteSpace(artifactDeploymentInfo.TargetSubDirectoryRelativePath)) { stagingSubDirPath = Path.Combine(artifactDirectoryStagingPath, artifactDeploymentInfo.TargetSubDirectoryRelativePath); } // Create artifact staging directory hierarchy before later use Directory.CreateDirectory(stagingSubDirPath); var artifactFileStagingPath = Path.Combine(stagingSubDirPath, deploymentInfo.TargetFileName); var srcInfo = FileSystemHelpers.DirectoryInfoFromDirectoryName(deploymentInfo.RepositoryUrl); using (tracer.Step(string.Format("Moving {0} to {1}", targetInfo.FullName, artifactFileStagingPath))) { srcInfo.MoveTo(artifactFileStagingPath); } // Deletes all files and directories except for artifactFileStagingPath and artifactDirectoryStagingPath DeleteFilesAndDirsExcept(artifactFileStagingPath, artifactDirectoryStagingPath, tracer); // The deployment flow expects at least 1 commit in the IRepository commit, refer to CommitRepo() for more info CommitRepo(repository, artifactDeploymentInfo); } }