public override void LoadConfig(string configString)
{
Dictionary<string, string> config = BusinessObject.GetConfigValues(configString);
FTPSettings = new FtpSettings();
FTPSettings.ServerAddress = config["FTPServer"];
FTPSettings.User = config["FTPUser"];
FTPSettings.Password = config["FTPPassword"];
FTPSettings.Directory = config["FTPDirectory"];
}
private async Task UploadToFtp(
FtpSettings settings,
Stream stream,
string folderName,
string fileName,
Progress progress)
{
using (var client = new RavenFtpClient(settings.Url, settings.Port, settings.UserName,
settings.Password, settings.CertificateAsBase64, settings.CertificateFileName, progress, TaskCancelToken.Token))
{
await client.UploadFile(folderName, fileName, stream);
if (_logger.IsInfoEnabled)
{
_logger.Info($"Successfully uploaded backup file '{fileName}' to an ftp server");
}
}
}
public async Task PublishFilesShouldSyncFiles()
{
var logger = Context.Logger;
var(source, deployTargetDirectory, temp) = TestDataHelper.CopyTestData(logger);
var ftpSettings = new FtpSettings(
new FtpPath("/", FileSystemType.Directory),
publicRootPath: new FtpPath("/", FileSystemType.Directory),
isSecure: false);
FtpHandler handler = await FtpHandler.Create(new Uri("ftp://127.0.0.1:30021"),
ftpSettings, new NetworkCredential("testuser", "testpw"), logger);
var sourceDirectory = new DirectoryInfo(source);
var ruleConfiguration = new RuleConfiguration {
AppOfflineEnabled = true
};
using var initialCancellationTokenSource =
new CancellationTokenSource(TimeSpan.FromSeconds(50));
DeploySummary initialSummary = await handler.PublishAsync(ruleConfiguration,
deployTargetDirectory,
initialCancellationTokenSource.Token);
logger.Information("Initial: {Initial}", initialSummary.ToDisplayValue());
using var cancellationTokenSource =
new CancellationTokenSource(TimeSpan.FromSeconds(50));
DeploySummary summary = await handler.PublishAsync(ruleConfiguration,
sourceDirectory,
cancellationTokenSource.Token);
logger.Information("Result: {Result}", summary.ToDisplayValue());
var fileSystemItems = await handler.ListDirectoryAsync(FtpPath.Root, cancellationTokenSource.Token);
foreach (FtpPath fileSystemItem in fileSystemItems)
{
logger.Information("{Item}", fileSystemItem.Path);
}
temp.Dispose();
}
private void UploadToFtp(FtpSettings settings, Stream stream, Progress progress)
{
using (var client = new RavenFtpClient(settings, progress, TaskCancelToken.Token))
{
client.UploadFile(_settings.FolderName, _settings.FileName, stream);
if (_logger.IsInfoEnabled)
{
_logger.Info($"{ReportSuccess(FtpName)} server");
}
if (_retentionPolicyParameters == null)
{
return;
}
var runner = new FtpRetentionPolicyRunner(_retentionPolicyParameters, client);
runner.Execute();
}
}
public IHttpActionResult PostFile(
string url,
bool useSsh,
string username,
string password,
string subFolder,
bool checkForFile,
bool renameAfterUpload,
ConnectMode connectMode,
TransferType transferType,
string localFilePath)
{
var settings = new FtpSettings();
settings.Url = url;
settings.UseSsh = useSsh;
settings.Username = username;
settings.Password = password;
settings.SubFolder = subFolder;
settings.CheckForFile = checkForFile;
settings.RenameAfterUpload = renameAfterUpload;
settings.ConnectMode = connectMode;
settings.TransferType = transferType;
var client = new Client();
client.StatusChanged += Client_StatusChanged;
client.ProgressChanged += Client_ProgressChanged;
var result = client.Upload(settings, localFilePath);
if (client.ErrorMessage != null && client.ErrorMessage != string.Empty)
{
return(InternalServerError(new System.Exception(client.ErrorMessage)));
}
return(Ok(result));
}
/// <summary>
/// Gets the directory listing from the endpoint.
/// </summary>
/// <param name="settings">Ftp Settinfs.</param>
/// <returns>Returns a list of files and directories.</returns>
public List <string> GetDirectoryContents(FtpSettings settings)
{
this.RaiseLog("Getting FTP directory contents...");
List <string> response = new List <string>();
FtpWebRequest ftp = this.GetFtpWebRequest(settings.Path, FtpOperation.List, settings, false);
using (FtpWebResponse ftpResponse = (FtpWebResponse)ftp.GetResponse())
using (Stream responseStream = ftpResponse.GetResponseStream())
{
this.RaiseLog(Resources.INFO_GETTINGDIRECTORY);
StreamReader reader = new StreamReader(responseStream);
while (!reader.EndOfStream)
{
string file = reader.ReadLine();
if (!string.IsNullOrWhiteSpace(Path.GetExtension(file)))
{
response.Add(file);
}
}
}
return(response);
}
public ProxiedDeleteFileFTPRequest(FtpSettings settings) : base(settings)
{
}
public static void InitializeFtpSettings(FtpSettings settings)
{
Settings = settings;
}
public FtpLoader(FtpSettings settings)
{
this.Settings = settings;
this.Client = new FtpClient(settings.Ip);
this.Client.Credentials = new NetworkCredential(settings.User, settings.Password);
}
public CustomErrorsService(FtpSettings ftpSettings)
{
_ftpSettings = ftpSettings;
_credentials = new NetworkCredential(ftpSettings.User, ftpSettings.Password);
}
private async Task <ExitCode> InternalDeployAsync(
ImmutableArray <DeploymentExecutionDefinition> deploymentExecutionDefinitions,
SemanticVersion explicitVersion,
CancellationToken cancellationToken = default)
{
var tempDirectoriesToClean = new List <DirectoryInfo>();
var tempFilesToClean = new List <string>();
try
{
_logger.Verbose("Executing deployment execution definitions [{Length}]: {Executions}",
deploymentExecutionDefinitions.Length,
string.Join($"{Environment.NewLine}\t", deploymentExecutionDefinitions.Select(_ => $"'{_}'")));
foreach (DeploymentExecutionDefinition deploymentExecutionDefinition in deploymentExecutionDefinitions)
{
if (string.IsNullOrWhiteSpace(deploymentExecutionDefinition.TargetDirectoryPath) &&
string.IsNullOrWhiteSpace(deploymentExecutionDefinition.PublishSettingsFile))
{
throw new InvalidOperationException($"{nameof(deploymentExecutionDefinition.TargetDirectoryPath)} and {nameof(deploymentExecutionDefinition.PublishSettingsFile)} are both not set");
}
string asJson = JsonConvert.SerializeObject(deploymentExecutionDefinition, Formatting.Indented);
_logger.Information("Executing deployment execution definition: '{DeploymentExecutionDefinition}'",
asJson);
const string TempPrefix = "MD-";
string uniqueSuffix = DateTime.Now.ToString("MMddHHmmssfff", CultureInfo.InvariantCulture);
string tempPath = Path.Combine(
Path.GetTempPath(),
$"{TempPrefix}{uniqueSuffix}{Guid.NewGuid().ToString().Substring(0, 6)}");
var tempWorkingDirectory = new DirectoryInfo(tempPath);
DirectoryInfo packageInstallTempDirectory = tempWorkingDirectory;
tempDirectoriesToClean.Add(packageInstallTempDirectory);
MayBe <InstalledPackage> installedMainPackage =
await _packageInstaller.InstallPackageAsync(
deploymentExecutionDefinition,
packageInstallTempDirectory,
false,
explicitVersion,
cancellationToken).ConfigureAwait(false);
if (!installedMainPackage.HasValue)
{
_logger.Error(
"Could not install package defined in deployment execution definition {DeploymentExecutionDefinition}",
deploymentExecutionDefinition);
return(ExitCode.Failure);
}
InstalledPackage installedPackage = installedMainPackage.Value;
_logger.Information(
"Successfully installed NuGet package '{PackageId}' version '{Version}' to path '{NugetPackageFullPath}'",
installedPackage.PackageId,
installedPackage.Version.ToNormalizedString(),
installedPackage.NugetPackageFullPath);
tempWorkingDirectory.Refresh();
DirectoryInfo[] packagesDirectory = tempWorkingDirectory.GetDirectories();
DirectoryInfo packageDirectory =
packagesDirectory.Single(directory =>
directory.Name.Equals(installedPackage.PackageId, StringComparison.OrdinalIgnoreCase));
SemanticVersion version = explicitVersion ?? GetSemanticVersionFromDefinition(
deploymentExecutionDefinition,
packageDirectory,
installedPackage.Version);
_logger.Verbose("Package version is {Version}", version.ToNormalizedString());
var possibleXmlTransformations = new List <FileMatch>();
var replaceFiles = new List <FileMatch>();
var environmentPackageResult = new EnvironmentPackageResult(true);
var contentDirectory =
new DirectoryInfo(Path.Combine(packageDirectory.FullName, "Content"));
if (!contentDirectory.Exists)
{
_logger.Error("Content directory '{FullName}' does not exist", contentDirectory.FullName);
return(ExitCode.Failure);
}
FileInfo contentFilesJson = packageDirectory.GetFiles("contentFiles.json").SingleOrDefault();
if (contentFilesJson?.Exists == true)
{
ExitCode exitCode = VerifyFiles(contentFilesJson.FullName, contentDirectory);
if (!exitCode.IsSuccess)
{
return(exitCode);
}
}
else
{
_logger.Debug("No file contentFiles.json was found in package directory {PackageDirectory}",
packageDirectory.FullName);
}
if (!string.IsNullOrWhiteSpace(deploymentExecutionDefinition.EnvironmentConfig))
{
_logger.Information(
"Fetching environment packages for package {Package} and environment {Environment}",
deploymentExecutionDefinition.PackageId, deploymentExecutionDefinition.EnvironmentConfig);
environmentPackageResult = await AddEnvironmentPackageAsync(deploymentExecutionDefinition,
packageInstallTempDirectory,
possibleXmlTransformations,
replaceFiles,
tempDirectoriesToClean,
version,
cancellationToken).ConfigureAwait(false);
if (!environmentPackageResult.IsSuccess)
{
return(ExitCode.Failure);
}
if (environmentPackageResult.Version != null)
{
_logger.Information("Installed environment package version {Version}",
environmentPackageResult.Version.ToNormalizedString());
}
else
{
_logger.Information("No environment package was installed");
}
}
else
{
_logger.Debug("Definition has no environment configuration specified");
}
if (possibleXmlTransformations.Any())
{
_logger.Debug("Possible Xml transformation files {V}",
string.Join(", ",
possibleXmlTransformations.Select(fileMatch =>
$"'{fileMatch.TargetName}' replaced by --> '{fileMatch.ActionFile.FullName}'")));
}
var xmlTransformedFiles = new List <string>();
foreach (FileMatch possibleXmlTransformation in possibleXmlTransformations)
{
TransformationResult result = _xmlTransformer.TransformMatch(possibleXmlTransformation,
contentDirectory);
if (!result.IsSuccess)
{
return(ExitCode.Failure);
}
xmlTransformedFiles.AddRange(result.TransformedFiles);
}
if (replaceFiles.Any())
{
_logger.Debug("Possible replacing files {Files}",
string.Join(", ",
replaceFiles.Select(fileMatch =>
$"'{fileMatch.TargetName}' replaced by --> '{fileMatch.ActionFile.FullName}'")));
}
var replacedFiles = new List <string>();
foreach (FileMatch replacement in replaceFiles)
{
ReplaceResult result = ReplaceFileIfMatchingFiles(replacement, contentDirectory);
if (!result.IsSuccess)
{
return(ExitCode.Failure);
}
replacedFiles.AddRange(result.ReplacedFiles);
}
if (!string.IsNullOrWhiteSpace(deploymentExecutionDefinition.WebConfigTransformFile))
{
DeploymentTransformation.Transform(deploymentExecutionDefinition, contentDirectory, _logger);
}
string uniqueTargetTempSuffix =
DateTime.Now.ToString("MMddHHmmssfff", CultureInfo.InvariantCulture);
string uniqueTargetTempPath = Path.Combine(
Path.GetTempPath(),
$"{TempPrefix}t{uniqueTargetTempSuffix}{Guid.NewGuid().ToString().Substring(0, 6)}");
var targetTempDirectoryInfo =
new DirectoryInfo(uniqueTargetTempPath);
if (!targetTempDirectoryInfo.Exists)
{
_logger.Debug("Creating temp target directory '{FullName}'",
packageInstallTempDirectory.FullName);
targetTempDirectoryInfo.Create();
}
string wwwrootPath = Path.Combine(contentDirectory.FullName, "wwwroot");
var wwwRootDirectory = new DirectoryInfo(wwwrootPath);
DirectoryInfo applicationMetadataTargetDirectory =
wwwRootDirectory.Exists ? wwwRootDirectory : contentDirectory;
string versionFile = ApplicationMetadataCreator.SetVersionFile(
installedMainPackage.Value,
applicationMetadataTargetDirectory,
deploymentExecutionDefinition,
xmlTransformedFiles,
replacedFiles,
environmentPackageResult,
_logger);
_logger.Information("Successfully wrote metadata file {Path}", versionFile);
_logger.Verbose("Copying content files to '{FullName}'", targetTempDirectoryInfo.FullName);
bool usePublishSettingsFile =
!string.IsNullOrWhiteSpace(deploymentExecutionDefinition.PublishSettingsFile);
var targetAppOffline = new FileInfo(Path.Combine(targetTempDirectoryInfo.FullName,
DeploymentConstants.AppOfflineHtm));
var ruleConfiguration = RuleConfiguration.Get(deploymentExecutionDefinition,
DeployerConfiguration,
_logger);
if (ruleConfiguration.AppOfflineEnabled && usePublishSettingsFile)
{
string sourceAppOffline =
Path.Combine(contentDirectory.FullName, DeploymentConstants.AppOfflineHtm);
if (!File.Exists(sourceAppOffline) && !targetAppOffline.Exists)
{
using var _ = File.Create(targetAppOffline.FullName);
_logger.Debug("Created offline file '{File}'", targetAppOffline.FullName);
if (DeployerConfiguration.DefaultWaitTimeAfterAppOffline > TimeSpan.Zero)
{
await Task.Delay(DeployerConfiguration.DefaultWaitTimeAfterAppOffline,
cancellationToken)
.ConfigureAwait(false);
}
tempFilesToClean.Add(targetAppOffline.FullName);
}
}
RecursiveIO.RecursiveCopy(contentDirectory,
targetTempDirectoryInfo,
_logger,
deploymentExecutionDefinition.ExcludedFilePatterns);
tempDirectoriesToClean.Add(targetTempDirectoryInfo);
_logger.Debug("Copied content files from '{ContentDirectory}' to '{FullName}'",
contentDirectory,
targetTempDirectoryInfo.FullName);
tempDirectoriesToClean.Add(packageInstallTempDirectory);
bool hasPublishSettingsFile =
!string.IsNullOrWhiteSpace(deploymentExecutionDefinition.PublishSettingsFile) &&
File.Exists(deploymentExecutionDefinition.PublishSettingsFile);
if (hasPublishSettingsFile)
{
_logger.Debug("The publish settings file '{PublishSettingsFile}' exists",
deploymentExecutionDefinition.PublishSettingsFile);
}
else
{
_logger.Debug("The deployment definition has no publish setting file");
}
if (deploymentExecutionDefinition.PublishType == PublishType.WebDeploy)
{
_webDeployHelper.DeploymentTraceEventHandler += (sender, args) =>
{
if (string.IsNullOrWhiteSpace(args.Message))
{
return;
}
if (args.EventLevel == TraceLevel.Verbose)
{
_logger.Verbose("{Message}", args.Message);
return;
}
_logger.Information("{Message}", args.Message);
};
}
bool hasIisSiteName = deploymentExecutionDefinition.IisSiteName.HasValue();
IDeploymentChangeSummary summary;
try
{
IIisManager?manager = default;
if (!string.IsNullOrWhiteSpace(deploymentExecutionDefinition.IisSiteName))
{
manager = _iisManager(deploymentExecutionDefinition);
}
if (hasIisSiteName && manager is {})
{
bool stopped = manager.StopSiteIfApplicable();
if (!stopped)
{
_logger.Error(
"Could not stop IIS site for deployment execution definition {DeploymentExecutionDefinition}",
deploymentExecutionDefinition);
return(ExitCode.Failure);
}
}
try
{
if (deploymentExecutionDefinition.PublishType == PublishType.WebDeploy)
{
_logger.Information("Deploying {Target} with WebDeploy",
deploymentExecutionDefinition.TargetDirectoryPath);
summary = await _webDeployHelper.DeployContentToOneSiteAsync(
targetTempDirectoryInfo.FullName,
deploymentExecutionDefinition.PublishSettingsFile,
DeployerConfiguration.DefaultWaitTimeAfterAppOffline,
doNotDelete : ruleConfiguration.DoNotDeleteEnabled,
appOfflineEnabled : ruleConfiguration.AppOfflineEnabled,
useChecksum : ruleConfiguration.UseChecksumEnabled,
whatIf : ruleConfiguration.WhatIfEnabled,
traceLevel : TraceLevel.Verbose,
appDataSkipDirectiveEnabled : ruleConfiguration.AppDataSkipDirectiveEnabled,
applicationInsightsProfiler2SkipDirectiveEnabled :
ruleConfiguration.ApplicationInsightsProfiler2SkipDirectiveEnabled,
logAction : message => _logger.Debug("{Message}", message),
targetPath : hasPublishSettingsFile
?string.Empty
: deploymentExecutionDefinition.TargetDirectoryPath
).ConfigureAwait(false);
}
else if (deploymentExecutionDefinition.PublishType.IsAnyFtpType)
{
var basePath = deploymentExecutionDefinition.FtpPath;
bool isSecure = deploymentExecutionDefinition.PublishType == PublishType.Ftps;
var ftpSettings = new FtpSettings(basePath, isSecure);
_logger.Information("Deploying {Target} with {PublishType}",
deploymentExecutionDefinition.FtpPath?.Path,
deploymentExecutionDefinition.PublishType);
string publishSettingsFile = deploymentExecutionDefinition.PublishSettingsFile;
if (string.IsNullOrWhiteSpace(publishSettingsFile))
{
_logger.Error(
"Deployment target type is set to {Type} but no publish file is set",
deploymentExecutionDefinition.PublishTypeValue);
return(ExitCode.Failure);
}
using IFtpHandler ftpHandler = await _ftpHandlerFactory.CreateWithPublishSettings(
publishSettingsFile,
ftpSettings,
_logger, cancellationToken);
_logger.Verbose("Created FTP handler, starting publish");
summary = await ftpHandler.PublishAsync(
ruleConfiguration,
targetTempDirectoryInfo,
cancellationToken);
}
else
{
throw new InvalidOperationException(
$"Publish type {deploymentExecutionDefinition.PublishType} is not supported");
}
}
catch (Exception ex) when(!ex.IsFatal())
{
_logger.Error(ex,
"Could not deploy site {DeploymentExecutionDefinition}",
deploymentExecutionDefinition);
return(ExitCode.Failure);
}
finally
{
manager?.Dispose();
}
}
catch (Exception ex) when(!ex.IsFatal())
{
_logger.Error(ex,
"Could not handle start/stop for iis site {Site}",
deploymentExecutionDefinition.IisSiteName);
return(ExitCode.Failure);
}
_logger.Information("Summary: {Summary}", summary.ToDisplayValue());
}
public override void LoadConfig(string configString)
{
Dictionary<string, string> config = BusinessObject.GetConfigValues(configString);
MaxSubLevel = int.Parse(config["MaxSubLevel"]);
MaxFileSizeToGet = long.Parse(config["MaxFileSize"]);
FTPSettings = new FtpSettings();
FTPSettings.Directory = config["FTPDirectory"];
FTPSettings.Password = config["FTPPassword"];
FTPSettings.ServerAddress = config["FTPServer"];
FTPSettings.User = config["FTPUser"];
}
public ProxiedListDirectoryFTPRequest(FtpSettings settings) : base(settings)
{
}
public FileTransferEventArgs(string filePath, FtpSettings ftpSettings)
{
FilePath = filePath;
FtpSettings = ftpSettings;
}
public FtpRemoteClient(FtpSettings settings)
{
_settings = settings;
_client = new Lazy <FtpClient>(CreateClient);
}
public ProxiedRenameFileFTPRequest(FtpSettings settings, string newFileName) : base(settings)
{
NewFileName = newFileName;
}
public async Task <IFtpHandler> CreateWithPublishSettings(string publishSettingsFile,
FtpSettings ftpSettings,
ILogger logger,
CancellationToken cancellationToken = default) =>
await FtpHandler.CreateWithPublishSettings(publishSettingsFile, ftpSettings, logger);
public FtpDownloadRequest(FtpSettings settings)
{
this.Settings = settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="From"/> class.
/// </summary>
/// <param name="headers"></param>
public From(Dictionary <string, string> headers, IWebRequestUtility webRequestUtility)
{
this.ftpSettings = new FtpSettings(headers.ToFromConfig());
this.webRequestUtility = webRequestUtility;
}
public FrmCustomErrors(FtpSettings settings)
{
InitializeComponent();
_customErrors = new CustomErrorsService(settings);
}
public static async Task <FtpHandler> CreateWithPublishSettings(
[NotNull] string publishSettingsFile,
[NotNull] FtpSettings ftpSettings,
ILogger logger = default)
{
if (ftpSettings == null)
{
throw new ArgumentNullException(nameof(ftpSettings));
}
logger ??= Logger.None;
if (string.IsNullOrWhiteSpace(publishSettingsFile))
{
throw new ArgumentException(Resources.ValueCannotBeNullOrWhitespace, nameof(publishSettingsFile));
}
var ftpPublishSettings = FtpPublishSettings.Load(publishSettingsFile);
var credentials = new NetworkCredential(ftpPublishSettings.UserName, ftpPublishSettings.Password, "");
var fullUri = ftpPublishSettings.FtpBaseUri;
if (ftpSettings.BasePath != null)
{
var builder = new UriBuilder(fullUri)
{
Path = ftpSettings.BasePath.Path
};
fullUri = builder.Uri;
}
var ftpClient = new FtpClient(fullUri.Host, credentials)
{
SocketPollInterval = 1000,
ConnectTimeout = 2000,
ReadTimeout = 2000,
DataConnectionConnectTimeout = 2000,
DataConnectionReadTimeout = 2000,
DataConnectionType = FtpDataConnectionType.PASV
};
if (ftpSettings.IsSecure)
{
logger.Debug("Using secure FTP connection");
ftpClient.EncryptionMode = FtpEncryptionMode.Explicit;
ftpClient.SslProtocols = SslProtocols.Tls12;
}
try
{
logger.Debug("Connecting to FTP");
await ftpClient.ConnectAsync();
logger.Debug("Connected to FTP");
}
catch (Exception ex) when(!ex.IsFatal())
{
throw new FtpException($"Could not connect to FTP {fullUri.Host}", ex);
}
return(new FtpHandler(ftpClient, logger, ftpSettings));
}
/// <summary>
/// Initializes a new instance of the <see cref="FtpClient"/> class.
/// </summary>
/// <param name="ftpSettings">Ftp settings.</param>
/// <param name="webRequestUtility">Web request facility.</param>
public FtpClient(FtpSettings ftpSettings, IWebRequestUtility webRequestUtility)
{
this.settings = ftpSettings;
this.webRequestUtility = webRequestUtility;
}
private string GetSetting(FtpSettings setting) => _settingValues[setting.ToString()];
public ProxiedBaseFTPRequest(FtpSettings settings)
{
Settings = settings;
}
private void LoadSettings()
{
var path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
try {
path = !string.IsNullOrWhiteSpace(path) ? Path.Combine(path, "AuroraAssetEditor", "ftp.json") : "ftp.json";
using(var stream = File.OpenRead(path))
_settings = (FtpSettings)_serializer.ReadObject(stream);
_settings.Loaded = true;
}
catch {
_settings = new FtpSettings {
Loaded = false
};
}
}
