protected override IEnumerable <CommandParameters> Execute(IEnumerable <CommandParameters> inParametersList)
{
foreach (var inParameters in inParametersList)
{
//inParameters = GetCurrentInParameters();
string sourceDirectory = inParameters.GetValue <string>("SourceDirectory");
string targetDirectory = inParameters.GetValueOrDefault <string>("TargetDirectory",
Path.Combine(sourceDirectory, @"\{yyyy}\{MM}\"));
string zipName = inParameters.GetValueOrDefault <string>("ZipName", "data" + ".zip");
string password = inParameters.GetValue <string>("Password");
bool removeSourceFiles = inParameters.GetValueOrDefault <bool>("RemoveSourceFiles", true);
string fileFiler = inParameters.GetValueOrDefault <string>("FileFilter", "*.*");
DirectoryUtil.CreateDirectoryIfNotExists(targetDirectory);
var targetFile = Path.Combine(targetDirectory, zipName);
this.ZipDirectory(sourceDirectory, password, targetFile, fileFiler);
if (removeSourceFiles)
{
this.DeleteFilesInDirectory(sourceDirectory, fileFiler);
}
this.LogDebug(string.Format("Zipping archive='{0}'", targetFile));
var outParameters = this.GetCurrentOutParameters();
outParameters.SetOrAddValue("File", targetFile);
yield return(outParameters);
}
}
public void WriteBinaryData(byte[] data, bool deleteBefore = false)
{
this.ValidateAndThrow();
var fileName = this.FileName;
if (!string.IsNullOrEmpty(fileName))
{
DirectoryUtil.CreateDirectoryIfNotExists(Path.GetDirectoryName(fileName));
if (deleteBefore)
{
FileUtil.DeleteFileIfExists(fileName);
}
}
BinaryWriter writer = null;
if (!string.IsNullOrEmpty(fileName))
{
writer = new BinaryWriter(File.Open(fileName, FileMode.Create));
}
else if (this.DataStream != null)
{
writer = new BinaryWriter(this.DataStream);
}
if (writer != null)
{
writer.Write(data);
writer.Close();
writer.Dispose();
}
}
private void WriteData(DataTable table, string file, string tableName, bool deleteBefore = false)
{
if (string.IsNullOrEmpty(file))
{
file = table.TableName;
}
DirectoryUtil.CreateDirectoryIfNotExists(Path.GetDirectoryName(file));
if (deleteBefore)
{
FileUtil.DeleteFileIfExists(file);
}
this.accessAdapter.FileName = file;
this.accessAdapter.TableName = !string.IsNullOrEmpty(tableName) ? tableName : "Table1";
if (this.IsFirstExecution && !System.IO.File.Exists(file))
{
this.accessAdapter.CreateNewFile();
}
if (this.accessAdapter.Connect())
{
this.accessAdapter.WriteAllData(table);
this.accessAdapter.Disconnect();
}
}
protected override IEnumerable <CommandParameters> Execute(IEnumerable <CommandParameters> inParametersList)
{
foreach (var inParameters in inParametersList)
{
//inParameters = GetCurrentInParameters();
string sourceFile = inParameters.GetValue <string>("SourceFile");
string targetDirectory = inParameters.GetValueOrDefault <string>("TargetDirectory", Path.Combine(Path.GetDirectoryName(sourceFile), @"\{yyyy}\{MM}\"));
string zipName = inParameters.GetValueOrDefault <string>("ZipName", Path.GetFileNameWithoutExtension(sourceFile) + ".zip");
string password = inParameters.GetValue <string>("Password");
bool removeSourceFile = inParameters.GetValueOrDefault <bool>("RemoveSourceFile", true);
zipName = TokenProcessor.ReplaceToken(zipName, "SourceFileName", Path.GetFileName(sourceFile));
DirectoryUtil.CreateDirectoryIfNotExists(targetDirectory);
var targetFile = Path.Combine(targetDirectory, zipName);
this.ZipFile(sourceFile, targetFile, password);
if (removeSourceFile)
{
File.Delete(sourceFile);
}
this.LogDebug(string.Format("Zipping archive='{0}'", targetFile));
var outParameters = this.GetCurrentOutParameters();
outParameters.SetOrAddValue("File", targetFile);
yield return(outParameters);
}
}
public string InstallService(string serviceName, string physicalLocation, string userName, string password, string serviceSourceDirectory, bool autoRestartOption = true)
{
if (string.IsNullOrEmpty(userName))
{
userName = "******";
}
if (userName.IndexOf('\\') < 0)
{
userName = "******" + userName;
}
string errorMsg;
string installerDir = this.GetInstallerDirectory(out errorMsg);
if (string.IsNullOrEmpty(installerDir))
{
return(errorMsg);
}
string serviceTargetDir = Path.GetDirectoryName(physicalLocation);
DirectoryUtil.CreateDirectoryIfNotExists(serviceTargetDir);
Environment.CurrentDirectory = serviceTargetDir;
FileUtil.CopyDirectory(serviceSourceDirectory, serviceTargetDir, true);
// var installParams = new[]
//{
// "/ServiceAccount=" + ServiceAccount.LocalSystem,
// "/UserName="******"/Password="******"/ServiceName=\"" + serviceName + "\"",
// "\""+ physicalLocation + "\""
// };
// // ManagedInstallerClass.InstallHelper(installParams);
// string installStmt = installerDir + INSTALLEREXE + " " + string.Join(" ", installParams);
string installStmt = installerDir + string.Format(INSTALLEREXE + " /ServiceAccount={0} /UserName={1} /Password={2} /ServiceName=\"{3}\" \"{4}\" ", ServiceAccount.LocalSystem, userName, password, serviceName, physicalLocation);
var process = new ProcessHandler("cmd");
var isOk = process.Execute(installStmt);
string result = process.OutputString;
if (!isOk || result.ContainsAny("Error", "Exception", "Rollback"))
{
errorMsg = "Error: An error occured during installing the service." + Environment.NewLine + Environment.NewLine + result;
}
else if (autoRestartOption)
{
this.SetServiceRecovery(serviceName);
}
return(errorMsg);
}
protected override IEnumerable <CommandParameters> Execute(IEnumerable <CommandParameters> inParametersList)
{
foreach (var inParameters in inParametersList)
{
//inParameters = GetCurrentInParameters();
var sourceFile = inParameters.GetValue <string>("SourceFile");
var targetDirectory = inParameters.GetValue <string>("TargetDirectory");
var mode = inParameters.GetValue <FileMoveModes>("Mode");
var targetFilename = Path.GetFileName(sourceFile);
var targetFile = Path.Combine(targetDirectory, targetFilename);
DirectoryUtil.CreateDirectoryIfNotExists(targetDirectory);
var retryInterval = TimeSpan.FromSeconds(1);
var maxRetries = 3;
switch (mode)
{
case FileMoveModes.Copy:
RetryHandler.Execute(() => File.Copy(sourceFile, targetFile, true), retryInterval, maxRetries,
(retry) =>
{
this.LogDebugFormat("Next try ({0}) to copy SourceFile='{0}', TargetFile='{1}'",
sourceFile, targetFile);
});
this.LogDebugFormat("Copying SourceFile='{0}', TargetFile='{1}'", sourceFile, targetFile);
break;
case FileMoveModes.Move:
RetryHandler.Execute(() => FileUtil.DeleteFileIfExists(targetFile), retryInterval, maxRetries);
RetryHandler.Execute(() => File.Move(sourceFile, targetFile), retryInterval, maxRetries,
(retry) =>
{
this.LogDebugFormat("Next try ({0}) to move SourceFile='{0}', TargetFile='{1}'",
sourceFile, targetFile);
});
this.LogDebugFormat("Moving SourceFile='{0}', TargetFile='{1}'", sourceFile, targetFile);
break;
}
var outParameters = this.GetCurrentOutParameters();
outParameters.AddOrUpdate(new CommandParameter()
{
Name = "File", Value = targetFile
});
yield return(outParameters);
}
}
private IEnumerable <string> ReadData(string remoteDirectory, string localDirectory)
{
DirectoryUtil.CreateDirectoryIfNotExists(localDirectory);
var remoteFileNames = this.ftp.GetDirectoryList(remoteDirectory);
foreach (var remoteFileName in remoteFileNames)
{
string localFileName = Path.Combine(localDirectory, remoteFileName.Name);
this.ftp.DownloadFile(remoteFileName.FullName, localFileName);
yield return(localFileName);
}
}
private string InstallService(string serviceName, string serviceDir, string adminUser = "", string adminPassword = "")
{
string installerDir = RuntimeEnvironment.GetRuntimeDirectory();
string errorMsg = "";
if (!File.Exists(Path.Combine(installerDir, installerExe)))
{
installerDir = this.WorkDir;
}
if (!File.Exists(Path.Combine(installerDir, installerExe)))
{
errorMsg = string.Format(@"'{0}' was not found in '{1}'", installerExe, installerDir);
return(errorMsg);
}
DirectoryUtil.CreateDirectoryIfNotExists(serviceDir);
Environment.CurrentDirectory = serviceDir;
FileUtil.CopyDirectory(this.ServiceSourceDir, serviceDir, true);
var process = new ProcessHandler("cmd");
if (!string.IsNullOrEmpty(adminUser))
{
process.SetExecUser(adminUser, adminPassword);
}
string systemUser = "******" + this.settings.SystemUser;
if (!string.IsNullOrEmpty(this.settings.SystemDomain))
{
systemUser = "******" + this.settings.SystemUser + "@" + this.settings.SystemDomain;
}
string stmt = installerDir + string.Format(installerExe + " /ServiceAccount={0} /UserName={1} /Password={2} /ServiceName={3} \"{4}\" ", ServiceAccount.LocalSystem, systemUser, this.settings.SystemPassword, serviceName, Path.Combine(serviceDir, this.ServiceExecutableName));
process.Execute(stmt);
string result = process.OutputString;
if (result.Contains("Fehler") || result.Contains("Exception") || result.Contains("Rollback"))
{
errorMsg = "ERROR: Beim Installieren des Dienstes, bitte Logs überprüfen" + Environment.NewLine + Environment.NewLine + result;
}
return(errorMsg);
}
private IEnumerable <string> ReadData(string remoteDirectory, string localDirectory)
{
DirectoryUtil.CreateDirectoryIfNotExists(localDirectory);
var directory = this.cloudStorage.GetFolder(remoteDirectory);
foreach (var entry in directory.ToList())
{
if (!(entry is ICloudDirectoryEntry))
{
string remoteFileName = (entry as ICloudFileSystemEntry).Name;
string localFileName = Path.Combine(localDirectory, remoteFileName);
this.cloudStorage.DownloadFile(directory, remoteFileName, localDirectory);
yield return(localFileName);
}
}
}
public DataBridgeInfo CreateNewDataBridge(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
return(null);
}
var dataBridgeInfo = new DataBridgeInfo();
dataBridgeInfo.SetDefaultValues();
var configDirectory = Path.GetDirectoryName(fileName);
DirectoryUtil.CreateDirectoryIfNotExists(configDirectory);
this.SaveDataBridge(fileName, dataBridgeInfo);
var defaultPipeline = this.CreateDefaultPipeline();
Pipeline.Save(dataBridgeInfo.PipelineInfos.First().FileName, defaultPipeline);
return(dataBridgeInfo);
}
protected override IEnumerable <CommandParameters> Execute(IEnumerable <CommandParameters> inParametersList)
{
foreach (var inParameters in inParametersList)
{
//inParameters = GetCurrentInParameters();
string file = inParameters.GetValue <string>("SourceFile");
string targetDirectory = inParameters.GetValue <string>("TargetDirectory");
string password = inParameters.GetValue <string>("Password");
DirectoryUtil.CreateDirectoryIfNotExists(targetDirectory);
int numUnzipped = 0;
using (var zipFile = ZipFile.Read(file))
{
foreach (ZipEntry entry in zipFile)
{
entry.ExtractWithPassword(targetDirectory, password);
string unzipFile = Path.Combine(targetDirectory, entry.FileName);
numUnzipped++;
var outParameters = this.GetCurrentOutParameters();
outParameters.SetOrAddValue("File", unzipFile);
yield return(outParameters);
}
}
if (numUnzipped > 0)
{
yield break;
}
var defaultOutParameters = this.GetCurrentOutParameters();
yield return(this.TransferOutParameters(defaultOutParameters));
}
}
public void TestInitialize()
{
DirectoryUtil.CreateDirectoryIfNotExists(this.resultPath);
DirectoryUtil.ClearDirectory(this.resultPath);
}
public override bool WriteData(IEnumerable <DataTable> tables, bool deleteBefore = false)
{
this.ValidateAndThrow();
string lastFileName = "";
string fileName = "";
bool isNewFile = true;
StreamWriter writer = null;
foreach (DataTable table in tables)
{
if (writer == null || lastFileName != this.FileName)
{
fileName = this.FileName;
if (string.IsNullOrEmpty(fileName))
{
fileName = table.TableName;
}
if (string.IsNullOrEmpty(fileName))
{
return(false);
}
DirectoryUtil.CreateDirectoryIfNotExists(Path.GetDirectoryName(fileName));
if (deleteBefore)
{
FileUtil.DeleteFileIfExists(fileName);
}
isNewFile = this.IsNewFile(fileName);
if (writer != null)
{
writer.Flush();
writer.Close();
writer.Dispose();
}
if (!string.IsNullOrEmpty(fileName))
{
writer = new StreamWriter(fileName, !isNewFile, this.Encoding);
}
else if (this.DataStream != null)
{
writer = new StreamWriter(this.DataStream, this.Encoding);
}
lastFileName = fileName;
}
writer.NewLine = this.recordSeperator;
var lines = this.WriteFormatter.Format(table) as IEnumerable <string>;
int writtenRows = 0;
int rowIdx = 0;
if (lines != null)
{
foreach (var line in lines)
{
if (!isNewFile && rowIdx == 0)
{
// skip header when it is no new fileName
rowIdx++;
continue;
}
writer.WriteLine(line);
if (writtenRows % 100 == 0)
{
writer.Flush();
}
writtenRows++;
rowIdx++;
}
writer.Flush();
}
isNewFile = this.IsNewFile(fileName);
}
if (writer != null)
{
writer.Close();
writer.Dispose();
}
return(true);
}
public override bool WriteData(IEnumerable <DataTable> tables, bool deleteBefore = false)
{
this.ValidateAndThrow();
var xmlDoc = new XmlDocument();
var namespaceMgr = new XmlNamespaceManager(xmlDoc.NameTable);
if (!string.IsNullOrEmpty(this.FileName))
{
DirectoryUtil.CreateDirectoryIfNotExists(Path.GetDirectoryName(this.FileName));
if (deleteBefore)
{
FileUtil.DeleteFileIfExists(this.FileName);
}
if (this.IsNewFile(this.FileName))
{
// add Declaration
XmlNode docNode = xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
xmlDoc.AppendChild(docNode);
// create base Path
XPathUtil.CreateXPath(xmlDoc, this.XPath);
}
else
{
xmlDoc.Load(this.FileName);
}
}
foreach (DataTable table in tables)
{
var xmlLines = this.WriteFormatter.Format(table, null) as IEnumerable <string>;
int writtenRows = 0;
int rowIdx = 0;
if (xmlLines != null)
{
foreach (var xmlLine in xmlLines)
{
var lastNode = xmlDoc.SelectSingleNode(this.XPath + "[last()]", namespaceMgr);
if (lastNode != null)
{
// Append xml to the last node
var xmlDocFragment = xmlDoc.CreateDocumentFragment();
xmlDocFragment.InnerXml = xmlLine;
lastNode.AppendChild(xmlDocFragment);
writtenRows++;
}
rowIdx++;
}
}
}
var settings = new XmlWriterSettings {
Indent = true
};
XmlWriter writer = null;
if (!string.IsNullOrEmpty(this.FileName))
{
writer = XmlWriter.Create(this.FileName, settings);
}
else if (this.DataStream != null)
{
writer = XmlWriter.Create(this.DataStream, settings);
}
else
{
return(false);
}
xmlDoc.Save(writer);
writer.Close();
writer.Dispose();
return(true);
}