private XDocument GetDocument()
{
if (!FileSystemHelpers.FileExists(_path))
{
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(_path));
return(CreateDocumentRoot());
}
try
{
XDocument document;
using (var stream = FileSystemHelpers.OpenRead(_path))
{
document = XDocument.Load(stream);
}
return(document);
}
catch
{
// If the profile gets corrupted then delete it
FileSystemHelpers.DeleteFileSafe(_path);
// Return a new document
return(CreateDocumentRoot());
}
}
internal static void SetupFileServer(IApplicationBuilder app, string fileDirectoryPath, string requestPath)
{
// Create deployment logs directory if it doesn't exist
FileSystemHelpers.CreateDirectory(fileDirectoryPath);
// Set up custom content types - associating file extension to MIME type
var provider = new FileExtensionContentTypeProvider
{
Mappings =
{
[".py"] = "text/html",
[".env"] = "text/html",
[".cshtml"] = "text/html",
[".log"] = "text/html",
[".image"] = "image/png"
}
};
app.UseFileServer(new FileServerOptions
{
FileProvider = new PhysicalFileProvider(
fileDirectoryPath),
RequestPath = requestPath,
EnableDirectoryBrowsing = true,
StaticFileOptions =
{
ServeUnknownFileTypes = true,
DefaultContentType = "text/plain",
ContentTypeProvider = provider
}
});
}
private SiteExtensionInfo EnablePreInstalledExtension(SiteExtensionInfo info, ITracer tracer)
{
string id = info.Id;
string installationDirectory = GetInstallationDirectory(id);
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
if (ExtensionRequiresApplicationHost(info))
{
if (info.Type == SiteExtensionInfo.SiteExtensionType.PreInstalledMonaco)
{
GenerateApplicationHostXdt(installationDirectory,
_preInstalledExtensionDictionary[id].ExtensionUrl, isPreInstalled: true);
}
}
else
{
FileSystemHelpers.CreateDirectory(installationDirectory);
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
return(null);
}
return(GetPreInstalledExtension(id));
}
/// <summary>
/// <para>1. Download package</para>
/// <para>2. Generate xdt file if not exist</para>
/// <para>3. Deploy site extension job</para>
/// <para>4. Execute install.cmd if exist</para>
/// </summary>
private async Task <UIPackageMetadata> InstallExtension(UIPackageMetadata package, string installationDirectory, string feedUrl)
{
ITracer tracer = _traceFactory.GetTracer();
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
SourceRepository remoteRepo = GetRemoteRepository(feedUrl);
// Copy content folder
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
// package path from local repo
string packageLocalFilePath = GetNuGetPackageFile(package.Identity.Id, package.Identity.Version.ToString());
using (tracer.Step("Download site extension: {0}", package.Identity))
{
await remoteRepo.DownloadPackageToFolder(package.Identity, installationDirectory, pathToLocalCopyOfNudpk : packageLocalFilePath);
}
// If there is no xdt file, generate default.
using (tracer.Step("Check if applicationhost.xdt file existed."))
{
GenerateApplicationHostXdt(installationDirectory, '/' + package.Identity.Id, isPreInstalled: false, tracer: tracer);
}
using (tracer.Step("Trigger site extension job"))
{
OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Identity.Id));
}
var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
string installScript = Path.Combine(installationDirectory, _installScriptName);
if (FileSystemHelpers.FileExists(installScript))
{
using (tracer.Step("Execute install.cmd"))
{
OperationManager.Attempt(() =>
{
Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
installationDirectory,
_settings.GetCommandIdleTimeout(), NullLogger.Instance);
exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
});
}
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
throw;
}
return(await _localRepository.GetLatestPackageById(package.Identity.Id));
}
private IPackage InstallExtension(IPackage package, string installationDirectory)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
foreach (IPackageFile file in package.GetContentFiles())
{
// It is necessary to place applicationHost.xdt under site extension root.
string contentFilePath = file.Path.Substring("content/".Length);
string fullPath = Path.Combine(installationDirectory, contentFilePath);
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
// If there is no xdt file, generate default.
GenerateApplicationHostXdt(installationDirectory, '/' + package.Id, isPreInstalled: false);
OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Id));
var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
string installScript = Path.Combine(installationDirectory, _installScriptName);
if (FileSystemHelpers.FileExists(installScript))
{
OperationManager.Attempt(() =>
{
Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
installationDirectory,
_settings.GetCommandIdleTimeout(), NullLogger.Instance);
exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
});
}
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
string packageFilePath = GetNuGetPackageFile(package.Id, package.Version.ToString());
using (
Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
catch (Exception ex)
{
ITracer tracer = _traceFactory.GetTracer();
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
throw;
}
return(_localRepository.FindPackage(package.Id));
}
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);
}
private static async Task WriteExtensionsJson()
{
var file = Path.Combine(Environment.CurrentDirectory, ".vscode", "extensions.json");
if (!FileSystemHelpers.DirectoryExists(Path.GetDirectoryName(file)))
{
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(file));
}
await WriteFiles(file, await StaticResources.VsCodeExtensionsJson);
}
private static void GenerateApplicationHostXdt(string installationDirectory, string relativeUrl, bool isPreInstalled)
{
// If there is no xdt file, generate default.
FileSystemHelpers.CreateDirectory(installationDirectory);
string xdtPath = Path.Combine(installationDirectory, _applicationHostFile);
if (!FileSystemHelpers.FileExists(xdtPath))
{
string xdtContent = CreateDefaultXdtFile(relativeUrl, isPreInstalled);
OperationManager.Attempt(() => FileSystemHelpers.WriteAllText(xdtPath, xdtContent));
}
}
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 static void CreateLockInfoFile(string operationName)
{
FileSystemHelpers.CreateDirectory(locksPath + "/deployment");
var lockInfo = new LinuxLockInfo();
lockInfo.heldByPID = Process.GetCurrentProcess().Id;
lockInfo.heldByTID = Thread.CurrentThread.ManagedThreadId;
lockInfo.heldByWorker = System.Environment.GetEnvironmentVariable(Constants.AzureWebsiteInstanceId);
lockInfo.heldByOp = operationName;
lockInfo.lockExpiry = DateTime.UtcNow.AddSeconds(defaultLockTimeout);
var json = JsonConvert.SerializeObject(lockInfo);
FileSystemHelpers.WriteAllText(locksPath + "/deployment/info.lock", json);
}
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 IPackage InstallExtension(IPackage package, string installationDirectory)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
foreach (IPackageFile file in package.GetContentFiles())
{
// It is necessary to place applicationHost.xdt under site extension root.
string contentFilePath = file.Path.Substring("content/".Length);
string fullPath = Path.Combine(installationDirectory, contentFilePath);
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
// If there is no xdt file, generate default.
string xdtPath = Path.Combine(installationDirectory, "applicationHost.xdt");
if (!FileSystemHelpers.FileExists(xdtPath))
{
string xdtContent = CreateDefaultXdtFile(package.Id);
OperationManager.Attempt(() => FileSystemHelpers.WriteAllText(xdtPath, xdtContent));
}
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
string packageFilePath = Path.Combine(installationDirectory,
String.Format("{0}.{1}.nupkg", package.Id, package.Version));
using (
Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
catch (Exception ex)
{
ITracer tracer = _traceFactory.GetTracer();
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
return(null);
}
return(_localRepository.FindPackage(package.Id));
}
private static void CreateLockInfoFile(string operationName)
{
FileSystemHelpers.CreateDirectory(locksPath + "/deployment");
//Console.WriteLine("CreatingLockDir - Created Actually");
var lockInfo = new LinuxLockInfo();
lockInfo.heldByPID = Process.GetCurrentProcess().Id;
lockInfo.heldByTID = Thread.CurrentThread.ManagedThreadId;
lockInfo.heldByWorker = System.Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID");
lockInfo.heldByOp = operationName;
lockInfo.lockExpiry = DateTime.UtcNow.AddSeconds(lockTimeout);
//Console.WriteLine("CreatingLockDir - LockInfoObj : "+lockInfo);
var json = JsonConvert.SerializeObject(lockInfo);
FileSystemHelpers.WriteAllText(locksPath + "/deployment/info.lock", json);
}
private static void GenerateApplicationHostXdt(string installationDirectory, string relativeUrl, ITracer tracer = null)
{
// If there is no xdt file, generate default.
FileSystemHelpers.CreateDirectory(installationDirectory);
string xdtPath = Path.Combine(installationDirectory, Constants.ApplicationHostXdtFileName);
if (!FileSystemHelpers.FileExists(xdtPath))
{
if (tracer != null)
{
tracer.Trace("Missing xdt file, creating one.");
}
string xdtContent = CreateDefaultXdtFile(relativeUrl, "%XDT_EXTENSIONPATH%");
OperationManager.Attempt(() => FileSystemHelpers.WriteAllText(xdtPath, xdtContent));
}
}
private async Task WriteSample()
{
if (InitSample)
{
const string functionJson = @"{
""disabled"": false,
""bindings"": [
{
""authLevel"": ""anonymous"",
""type"": ""httpTrigger"",
""direction"": ""in"",
""name"": ""req""
},
{
""type"": ""http"",
""direction"": ""out"",
""name"": ""res""
}
]
}
";
const string indexJs = @"module.exports = function (context, req) {
context.log('JavaScript HTTP trigger function processed a request.');
if (req.query.name || (req.body && req.body.name)) {
context.res = {
// status: 200, /* Defaults to 200 */
body: 'Hello ' + (req.query.name || req.body.name)
};
}
else {
context.res = {
status: 400,
body: 'Please pass a name on the query string or in the request body'
};
}
context.done();
};";
FileSystemHelpers.CreateDirectory("HttpFunction");
await WriteFiles(Path.Combine("HttpFunction", "function.json"), functionJson);
await WriteFiles(Path.Combine("HttpFunction", "index.js"), indexJs);
}
}
public static async Task <NodeDebuggerStatus> TrySetupNodeDebuggerAsync()
{
try
{
var existingLaunchJson = await(FileSystemHelpers.FileExists(LaunchJsonPath)
? TaskUtilities.SafeGuardAsync(async() => JsonConvert.DeserializeObject <VsCodeLaunch>(await FileSystemHelpers.ReadAllTextFromFileAsync(LaunchJsonPath)))
: Task.FromResult <VsCodeLaunch>(null));
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(LaunchJsonPath));
if (existingLaunchJson == null)
{
await FileSystemHelpers.WriteAllTextToFileAsync(LaunchJsonPath, JsonConvert.SerializeObject(DefaultLaunchJson, Formatting.Indented));
return(NodeDebuggerStatus.Created);
}
var functionsDebugConfig = existingLaunchJson.Configurations
.FirstOrDefault(c => c.Type.Equals("node", StringComparison.OrdinalIgnoreCase) &&
c.Request.Equals("attach", StringComparison.OrdinalIgnoreCase));
if (functionsDebugConfig == null)
{
existingLaunchJson.Configurations = existingLaunchJson.Configurations.Concat(DefaultLaunchJson.Configurations);
await FileSystemHelpers.WriteAllTextToFileAsync(LaunchJsonPath, JsonConvert.SerializeObject(existingLaunchJson, Formatting.Indented));
return(NodeDebuggerStatus.Updated);
}
else
{
return(NodeDebuggerStatus.AlreadyCreated);
}
}
catch (Exception e)
{
if (StaticSettings.IsDebug)
{
ColoredConsole.Error.WriteLine(ErrorColor(e.ToString()));
}
return(NodeDebuggerStatus.Error);
}
}
protected override async Task <HttpResponseMessage> CreateDirectoryPutResponse(DirectoryInfoBase info, string localFilePath)
{
try
{
var isRequestJSON = Request.Content.Headers?.ContentType?.MediaType?.Equals("application/json", StringComparison.OrdinalIgnoreCase);
var targetPath = localFilePath;
var isArmTemplate = false;
JObject requestContent = null;
Uri packageUri = null;
if (isRequestJSON == true)
{
requestContent = await Request.Content.ReadAsAsync <JObject>();
var payload = requestContent;
if (ArmUtils.IsArmRequest(Request))
{
payload = payload.Value <JObject>("properties");
isArmTemplate = ArmUtils.IsAzureResourceManagerUserAgent(Request);
}
var uri = payload?.Value <string>("packageUri");
if (!Uri.TryCreate(uri, UriKind.Absolute, out packageUri))
{
throw new InvalidOperationException($"Payload contains invalid '{uri}' packageUri property");
}
var path = payload?.Value <string>("path");
if (!string.IsNullOrEmpty(path))
{
targetPath = Path.Combine(targetPath, path);
FileSystemHelpers.CreateDirectory(targetPath);
}
}
using (packageUri == null ? Tracer.Step($"Extracting content to {targetPath}")
: Tracer.Step("Extracting content from {0} to {1}", StringUtils.ObfuscatePath(packageUri.AbsoluteUri), targetPath))
{
var content = packageUri == null ? Request.Content
: await DeploymentHelper.GetArtifactContentFromURL(new ArtifactDeploymentInfo(null, null) { RemoteURL = packageUri.AbsoluteUri }, Tracer);
using (var stream = await content.ReadAsStreamAsync())
{
// The unzipping is done over the existing folder, without first removing existing files.
// Hence it's more of a PATCH than a PUT. We should consider supporting both with the right semantic.
// Though a true PUT at the root would be scary as it would wipe all existing files!
var zipArchive = new ZipArchive(stream, ZipArchiveMode.Read);
zipArchive.Extract(targetPath, Tracer);
}
}
if (isArmTemplate && requestContent != null)
{
requestContent.Value <JObject>("properties").Add("provisioningState", "Succeeded");
return(Request.CreateResponse(HttpStatusCode.OK, requestContent));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(ArmUtils.CreateErrorResponse(Request, HttpStatusCode.BadRequest, ex));
}
}
public async Task <ScanRequestResult> StartScan(String timeout, String mainScanDirPath, String id, String host)
{
using (_tracer.Step("Start scan in the background"))
{
String folderPath = Path.Combine(mainScanDirPath, Constants.ScanFolderName + id);
String filePath = Path.Combine(folderPath, Constants.ScanStatusFile);
Boolean hasFileModifcations = true;
if (_deploymentLock.IsHeld)
{
return(ScanRequestResult.ScanAlreadyInProgress);
}
//Create unique scan folder and scan status file
_deploymentLock.LockOperation(() =>
{
//Check if files are modified
if (CheckModifications(mainScanDirPath))
{
//Create unique scan directory for current scan
FileSystemHelpers.CreateDirectory(folderPath);
_tracer.Trace("Unique scan directory created for scan {0}", id);
//Create scan status file inside folder
FileSystemHelpers.CreateFile(filePath).Close();
//Create temp file to check if scan is still running
string tempScanFilePath = GetTempScanFilePath(mainScanDirPath);
tempScanFilePath = Path.Combine(mainScanDirPath, Constants.TempScanFile);
FileSystemHelpers.CreateFile(tempScanFilePath).Close();
UpdateScanStatus(folderPath, ScanStatus.Starting);
}
else
{
hasFileModifcations = false;
}
}, "Creating unique scan folder", TimeSpan.Zero);
if (!hasFileModifcations)
{
return(ScanRequestResult.NoFileModifications);
}
//Start Backgorund Scan
using (var timeoutCancellationTokenSource = new CancellationTokenSource())
{
var successfullyScanned = PerformBackgroundScan(_tracer, folderPath, timeoutCancellationTokenSource.Token, id, mainScanDirPath);
//Wait till scan task completes or the timeout goes off
if (await Task.WhenAny(successfullyScanned, Task.Delay(Int32.Parse(timeout), timeoutCancellationTokenSource.Token)) == successfullyScanned)
{
//If scan task completes before timeout
//Delete excess scan folders, just keep the maximum number allowed
await DeletePastScans(mainScanDirPath, _tracer);
//Create new Manifest file containing the modified timestamps
String manifestPath = Path.Combine(mainScanDirPath, Constants.ScanManifest);
if (FileSystemHelpers.FileExists(manifestPath))
{
FileSystemHelpers.DeleteFileSafe(manifestPath);
}
JObject manifestObj = new JObject();
//Write to the manifest with new timestamps of the modified file
ModifyManifestFile(manifestObj, Constants.ScanDir);
File.WriteAllText(manifestPath, JsonConvert.SerializeObject(manifestObj));
//Path to common log file for azure monitor
String aggrLogPath = Path.Combine(mainScanDirPath, Constants.AggregrateScanResults);
//This checks if result scan log is formed
//If yes, it will append necessary logs to the aggregrate log file
//Current appended logs will be "Scanned files","Infected files", and details of infected files
String currLogPath = Path.Combine(folderPath, Constants.ScanLogFile);
if (FileSystemHelpers.FileExists(currLogPath))
{
StreamReader file = new StreamReader(currLogPath);
string line;
while ((line = file.ReadLine()) != null)
{
if (line.Contains("FOUND") || line.Contains("Infected files") || line.Contains("Scanned files"))
{
//logType "Infected" means this log line represents details of infected files
String logType = "Infected";
if (line.Contains("Infected files") || line.Contains("Scanned files"))
{
//logType "Info" means this log line represents total number of scanned or infected files
logType = "Info";
}
FileSystemHelpers.AppendAllTextToFile(aggrLogPath, DateTime.UtcNow.ToString(@"M/d/yyyy hh:mm:ss tt") + "," + id + "," + logType + "," + host + "," + line + '\n');
}
}
}
return(successfullyScanned.Result
? ScanRequestResult.RunningAynschronously
: ScanRequestResult.AsyncScanFailed);
}
else
{
//Timeout went off before scan task completion
//Cancel scan task
timeoutCancellationTokenSource.Cancel();
//Scan process will be cancelled
//wait till scan status file is appropriately updated
await successfullyScanned;
//Delete excess scan folders, just keep the maximum number allowed
await DeletePastScans(mainScanDirPath, _tracer);
return(ScanRequestResult.AsyncScanFailed);
}
}
}
}
/// <summary>
/// <para>Handle both file and folder create/update</para>
/// <para>If local file timestamp the same as the file in server, assume file/folder unchanged, will skip action.</para>
/// </summary>
private async Task HandlingUpdateOrCreate(OneDriveModel.OneDriveChange change, string wwwroot, string accessToken)
{
if (change.IsDeleted)
{
return;
}
string fullPath = GetDestinationPath(wwwroot, change.Path);
if (fullPath == null)
{
TraceMessage("Ignore folder {0}", change.Path);
return;
}
if (change.IsFile)
{
// return "1/1/1601 12:00:00 AM" when file not existed
DateTime lastWriteTime = FileSystemHelpers.GetLastWriteTimeUtc(fullPath);
if (lastWriteTime != change.LastModifiedUtc)
{
string parentDir = Path.GetDirectoryName(fullPath);
FileSystemHelpers.EnsureDirectory(parentDir);
var now = DateTime.UtcNow;
var success = false;
try
{
using (var client = CreateHttpClient(accessToken))
using (HttpResponseMessage response = await client.GetAsync(change.ContentUri))
{
var fileResponse = await ProcessResponse <Dictionary <string, object> >("HandlingUpdateOrCreate", response);
string downloadUrl = (string)fileResponse["@content.downloadUrl"];
using (HttpResponseMessage downloadResponse = await client.GetAsync(downloadUrl))
using (Stream stream = await downloadResponse.EnsureSuccessStatusCode().Content.ReadAsStreamAsync())
{
await WriteToFile(stream, fullPath);
}
}
FileSystemHelpers.SetLastWriteTimeUtc(fullPath, change.LastModifiedUtc);
success = true;
}
finally
{
var elapse = (DateTime.UtcNow - now).TotalMilliseconds;
var result = success ? "successful" : "failed";
if (FileSystemHelpers.FileExists(fullPath))
{
TraceMessage("Update file {0} {1} ({2:0}ms)", fullPath, result, elapse);
}
else
{
TraceMessage("Create file {0} {1} ({2:0}ms)", fullPath, result, elapse);
}
}
}
else
{
_tracer.Trace("Timestamp not changed. Skip updating file {0}", fullPath);
}
}
else
{
if (FileSystemHelpers.DirectoryExists(fullPath))
{
TraceMessage("Directory {0} exists, no action performed.", fullPath);
}
else
{
TraceMessage("Creating directory {0} ...", fullPath);
FileSystemHelpers.CreateDirectory(fullPath);
}
}
}
/// <summary>
/// <para>1. Download package</para>
/// <para>2. Generate xdt file if not exist</para>
/// <para>3. Deploy site extension job</para>
/// <para>4. Execute install.cmd if exist</para>
/// </summary>
private async Task <UIPackageMetadata> InstallExtension(UIPackageMetadata package, string installationDirectory, string feedUrl, SiteExtensionInfo.SiteExtensionType type, ITracer tracer)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
SourceRepository remoteRepo = GetRemoteRepository(feedUrl);
// Copy content folder
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
// package path from local repo
string packageLocalFilePath = GetNuGetPackageFile(package.Identity.Id, package.Identity.Version.ToString());
using (tracer.Step("Download site extension: {0}", package.Identity))
{
string extractPath = installationDirectory;
if (SiteExtensionInfo.SiteExtensionType.WebRoot == type)
{
extractPath = _environment.WebRootPath;
FileSystemHelpers.EnsureDirectory(extractPath);
}
await remoteRepo.DownloadPackageToFolder(package.Identity, extractPath, pathToLocalCopyOfNudpk : packageLocalFilePath);
if (SiteExtensionInfo.SiteExtensionType.WebRoot == type)
{
// if install to WebRoot, check if there is any xdt file come with package
// if there is one, move it to site extension folder
string xdtFile = Path.Combine(extractPath, Constants.ApplicationHostXdtFileName);
if (File.Exists(xdtFile))
{
tracer.Trace("Use xdt file from package.");
string newXdtFile = Path.Combine(installationDirectory, Constants.ApplicationHostXdtFileName);
tracer.Trace("Moving {0} to {1}", xdtFile, newXdtFile);
FileSystemHelpers.MoveFile(xdtFile, newXdtFile);
}
else
{
tracer.Trace("No xdt file come with package.");
}
}
}
// ignore below action if we install packge to wwwroot
if (SiteExtensionInfo.SiteExtensionType.WebRoot != type)
{
// If there is no xdt file, generate default.
using (tracer.Step("Check if applicationhost.xdt file existed."))
{
GenerateApplicationHostXdt(installationDirectory, '/' + package.Identity.Id, isPreInstalled: false, tracer: tracer);
}
using (tracer.Step("Trigger site extension job"))
{
OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Identity.Id));
}
var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
string installScript = Path.Combine(installationDirectory, _installScriptName);
if (FileSystemHelpers.FileExists(installScript))
{
using (tracer.Step("Execute install.cmd"))
{
OperationManager.Attempt(() =>
{
Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
installationDirectory,
_settings.GetCommandIdleTimeout(), NullLogger.Instance);
exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
});
}
}
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
throw;
}
return(await _localRepository.GetLatestPackageById(package.Identity.Id));
}
/// <summary>
/// Helper function to download package from given url, and place package (only 'content' folder from package) to given folder
/// </summary>
/// <param name="identity">Package identity</param>
/// <param name="destinationFolder">Folder where we copy the package content (content folder only) to</param>
/// <param name="pathToLocalCopyOfNudpk">File path where we copy the nudpk to</param>
/// <returns></returns>
public static async Task DownloadPackageToFolder(this SourceRepository srcRepo, PackageIdentity identity, string destinationFolder, string pathToLocalCopyOfNudpk = null)
{
var downloadResource = await srcRepo.GetResourceAndValidateAsync <DownloadResource>();
using (Stream sourceStream = await downloadResource.GetStream(identity, CancellationToken.None))
{
if (sourceStream == null)
{
// package not exist from feed
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Package {0} - {1} not found when try to download.", identity.Id, identity.Version.ToNormalizedString()));
}
Stream packageStream = sourceStream;
try
{
if (!sourceStream.CanSeek)
{
// V3 DownloadResource.GetStream does not support seek operations.
// https://github.com/NuGet/NuGet.Protocol/issues/15
MemoryStream memStream = new MemoryStream();
try
{
byte[] buffer = new byte[2048];
int bytesRead = 0;
do
{
bytesRead = sourceStream.Read(buffer, 0, buffer.Length);
memStream.Write(buffer, 0, bytesRead);
} while (bytesRead != 0);
await memStream.FlushAsync();
memStream.Position = 0;
packageStream = memStream;
}
catch
{
memStream.Dispose();
throw;
}
}
if (!string.IsNullOrWhiteSpace(pathToLocalCopyOfNudpk))
{
string packageFolderPath = Path.GetDirectoryName(pathToLocalCopyOfNudpk);
FileSystemHelpers.CreateDirectory(packageFolderPath);
using (Stream writeStream = FileSystemHelpers.OpenWrite(pathToLocalCopyOfNudpk))
{
OperationManager.Attempt(() => packageStream.CopyTo(writeStream));
}
// set position back to the head of stream
packageStream.Position = 0;
}
using (ZipFile zipFile = ZipFile.Read(packageStream))
{
// we only care about stuff under "content" folder
int substringStartIndex = @"content/".Length;
IEnumerable <ZipEntry> contentEntries = zipFile.Entries.Where(e => e.FileName.StartsWith(@"content/", StringComparison.InvariantCultureIgnoreCase));
foreach (var entry in contentEntries)
{
string fullPath = Path.Combine(destinationFolder, entry.FileName.Substring(substringStartIndex));
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath))
{
// let the thread go with itself, so that once file finsihed writing, doesn`t need to request thread context from main thread
await entry.OpenReader().CopyToAsync(writeStream).ConfigureAwait(false);
}
}
}
}
finally
{
if (packageStream != null && !sourceStream.CanSeek)
{
// in this case, we created a copy of the source stream in memoery, need to manually dispose
packageStream.Dispose();
}
}
}
}