protected Pattern(Vulcan.Packages.VulcanPackage vulcanPackage,DTS.IDTSSequence parentContainer)
{
_vulcanPackage = vulcanPackage;
_parentContainer = parentContainer;
_firstExecutableGeneratedByPattern = null;
_lastExecutableGeneratedByPattern = null;
}
public FileSystemTask(
Packages.VulcanPackage vulcanPackage,
string name,
string taskDescription,
DTS.IDTSSequence parentContainer,
string sourceConnection,
string destConnection,
Microsoft.SqlServer.Dts.Tasks.FileSystemTask.DTSFileSystemOperation operation
)
: base(vulcanPackage,
name,
taskDescription,
parentContainer)
{
Connection source = new Connection(vulcanPackage, sourceConnection, sourceConnection, "FILE",String.Format("\"{0}\"",ExpressionPathBuilder.EscapeBackslashes(sourceConnection)));
Connection dest = new Connection(vulcanPackage, destConnection, destConnection, "FILE",String.Format("\"{0}\"",ExpressionPathBuilder.EscapeBackslashes(destConnection)));
source.SetProperty("FileUsageType", 2);
dest.SetProperty("FileUsageType", 2);
fileSystemTask = (DTS.TaskHost)parentContainer.Executables.Add("STOCK:FileSystemTask");
fileSystemTask.Name = name;
this.Task.Operation = operation;
this.Task.Source = source.ConnectionManager.ID;
this.Task.Destination = dest.ConnectionManager.ID;
}
protected Task(Packages.VulcanPackage vulcanPackage ,string taskName, string taskDescription, DTS.IDTSSequence parentContainer)
{
_vulcanPackage = vulcanPackage;
_name = taskName;
_description = taskDescription;
_parentContainer = parentContainer;
}
public PrecedenceConstraint(Packages.VulcanPackage vulcanPackage, string from, string to, DTS.IDTSSequence parentContainer)
: base(vulcanPackage,
from + "_" + to,
"",
parentContainer)
{
this.from = from;
this.to = to;
}
public SQLTask(Packages.VulcanPackage package, string name, string description, DTS.IDTSSequence parentContainer,Connection destinationConnection)
: this(package,
name,
description,
parentContainer,
destinationConnection,
null)
{
}
public SsisSequence(DTS.IDTSSequence dtsSequence, SequenceTask objContainer)
{
if (objContainer.ConstraintMode != "Linear" && objContainer.ConstraintMode != "Parallel")
{
MessageEngine.Global.Trace(Severity.Error, "Unknown ConstraintMode: {0} ", objContainer.ConstraintMode);
}
_constraintMode = objContainer.ConstraintMode;
_transactionMode = objContainer.TransactionMode;
_dtsSequence = dtsSequence;
}
public SsisVariable(string name, object value, DTS.DtsContainer parentContainer)
{
if (null == parentContainer)
{
this._parentContainer = (DTS.DtsContainer)SsisPackage.CurrentPackage.DTSPackage;
}
else
{
this._parentContainer = parentContainer;
}
_dtsVariable = _addVariable(name, value, _parentContainer);
}
public static string EvaluateSSISExpression(string expression, DTS.DtsContainer container)
{
var dtsVariable =
container.Variables.Add("__" + Guid.NewGuid().ToString("N"), false, "User", null);
dtsVariable.EvaluateAsExpression = true;
dtsVariable.Expression = expression;
string retval = dtsVariable.Value.ToString();
container.Variables.Remove(dtsVariable.ID);
return retval;
}
public override bool OnError(
DTS.DtsObject source,
int errorCode,
string subComponent,
string description,
string helpFile,
int helpContext,
string idofInterfaceWithError)
{
// Add application-specific diagnostics here.
MessageEngine.Trace(Severity.Debug, "Validation Error in {0}/{1} : {2} : {3}", source, subComponent, description, helpFile);
_validationErrorCount++;
return false;
}
private void SetVariablePath(DTS.DtsContainer dtsContainer)
{
StringBuilder sPath = new StringBuilder(dtsContainer.Name);
while (dtsContainer.Parent != null)
{
dtsContainer = dtsContainer.Parent;
sPath.Insert(0, "/");
sPath.Insert(0, dtsContainer.Name);
}
sPath.Insert(0, "/Root/");
_path = sPath.ToString();
}
public ExecutePackageTask(
Packages.VulcanPackage vulcanPackage,
string name,
string taskDescription,
DTS.IDTSSequence parentContainer,
Connection packageConnection
)
: base(vulcanPackage,
name,
taskDescription,
parentContainer)
{
executePackageTaskHost = (DTS.TaskHost)parentContainer.Executables.Add("STOCK:ExecutePackageTask");
executePackageTaskHost.Name = name;
Task.Connection = packageConnection.ConnectionManager.ID;
}
public SQLTask(Packages.VulcanPackage package, string name, string description, DTS.IDTSSequence parentContainer, Connection destinationConnection, Dictionary<string,object> propertiesDictionary)
: base(package,
name,
description,
parentContainer)
{
this._expressionBuilder = new Vulcan.Common.Helpers.ExpressionPathBuilder(package);
_sqlTask = (DTS.TaskHost)parentContainer.Executables.Add("STOCK:SQLTask");
_sqlTask.Name = name;
_sqlTask.Description = description;
SetProperties(propertiesDictionary);
if (destinationConnection != null)
{
SetProperty("Connection", destinationConnection.ConnectionManager.Name);
}
}
private void SetParameterMapping(IList<DataFlowSourceQueryParameter> parameters, DTS.Variables variables)
{
StringBuilder parameterBuilder = new StringBuilder();
foreach (DataFlowSourceQueryParameter param in parameters)
{
if (variables.Contains(param.VariableName))
{
DTS.Variable variable = variables[param.VariableName];
parameterBuilder.AppendFormat("\"{0}\",{1};", param.Name, variable.ID);
}
else
{
MessageEngine.Global.Trace(Severity.Error, Resources.DTSVariableNotExists, param.VariableName);
}
}
_instance.SetComponentProperty("ParameterMapping", parameterBuilder.ToString());
}
private DTS.Variable _addVariable(string name, object value, DTS.DtsContainer dtsContainer)
{
_name = name;
SetVariablePath(dtsContainer);
if (!dtsContainer.Variables.Contains(name))
{
MessageEngine.Global.Trace(Severity.Alert, "Creating variable {0} with value {1} in Container {2}", name, value, dtsContainer.Name);
DTS.Variable var = dtsContainer.Variables.Add(name, false, "User", value);
_dtsVariable = var;
return var;
}
else
{
_dtsVariable = dtsContainer.Variables[name];
return dtsContainer.Variables[name];
}
}
public void AddPrecedenceConstraint(DTS.Executable from, DTS.Executable to, DTS.IDTSSequence parentContainer)
{
if (from != null && to != null && parentContainer != null)
{
if (
parentContainer.Executables.Contains(this.ExtractNameFromDTSExecutable(from)) &&
parentContainer.Executables.Contains(this.ExtractNameFromDTSExecutable(to))
)
{
DTS.PrecedenceConstraint pc =
parentContainer.PrecedenceConstraints.Add(from, to);
pc.Name = ExtractNameFromDTSExecutable(from) + "_" + ExtractNameFromDTSExecutable(to);
}
}
}
public FTPTaskPattern(Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer)
: base(vulcanPackage, parentContainer)
{
}
protected void SafeExecute(DTS.Executable executable)
{
Vulcan.Common.ErrorEvents errorHandler = new Vulcan.Common.ErrorEvents();
DTS.DTSExecResult execResult = executable.Execute(null, null, errorHandler, null, null);
if (execResult == Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Success && errorHandler.ValidationErrorCount == 0)
{
Message.Trace(
Severity.Notification,
"Success executing Task {0}",
VulcanPackage.ExtractNameFromDTSExecutable(executable)
);
}
else
{
Message.Trace(
Severity.Error,
"Error executing Task {0}: Result = {1} (BugBug: SSIS always returns success) but ErrorCount = {2}",
VulcanPackage.ExtractNameFromDTSExecutable(executable),
execResult,errorHandler.ValidationErrorCount
);
}
}
public bool Edit(IWin32Window parentWindow, DTSRuntime.Variables variables, DTSRuntime.Connections connections)
{
ShowForm(parentWindow);
return true;
}
public SsisExecutable(DTS.Executable executable)
{
_executable = executable;
}
public DimensionsPattern(Vulcan.Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer)
: base(vulcanPackage,
parentContainer)
{
}
public FTPTask(
Packages.VulcanPackage vulcanPackage,
string name,
string taskDescription,
DTS.IDTSSequence parentContainer,
string serverName,
string port,
string userName,
string password,
string remotePath,
bool isRemotePathVariable,
string localPath,
bool isLocalPathVariable,
Microsoft.SqlServer.Dts.Tasks.FtpTask.DTSFTPOp operation
)
: base(vulcanPackage,
name,
taskDescription,
parentContainer)
{
fTPTask = (DTS.TaskHost)parentContainer.Executables.Add("STOCK:FTPTask");
fTPTask.Name = name;
fTPTask.Description = taskDescription;
this.Task.Operation = operation;
this.Task.IsRemotePathVariable = isRemotePathVariable;
this.Task.IsLocalPathVariable = isLocalPathVariable;
Connection fTPServerConnection = new Connection(vulcanPackage, serverName, serverName, "FTP", String.Format("\"{0}:{1}\"", serverName, port));
fTPServerConnection.SetProperty("ServerUserName", userName);
fTPServerConnection.SetProperty("ServerPassword", password);
this.Task.Connection = fTPServerConnection.ConnectionManager.ID;
if (this.Task.IsRemotePathVariable == true)
{
this.Task.RemotePath = remotePath;
}
else
{
this.Task.RemotePath = remotePath;
}
if (this.Task.IsLocalPathVariable == true)
{
this.Task.LocalPath = localPath;
}
else
{
Connection localConnection = new Connection(vulcanPackage, localPath, localPath, "File", String.Format("\"{0}\"", ExpressionPathBuilder.EscapeBackslashes(localPath)));
int intFileUsageType = 2;
switch (operation)
{
case Microsoft.SqlServer.Dts.Tasks.FtpTask.DTSFTPOp.Send:
intFileUsageType = 0;
break;
case Microsoft.SqlServer.Dts.Tasks.FtpTask.DTSFTPOp.Receive:
intFileUsageType = 2;
break;
default:
intFileUsageType = 2;
break;
}
localConnection.SetProperty("FileUsageType", intFileUsageType);
this.Task.LocalPath = localPath;
}
}
public StoredProcPattern(Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer)
: base(vulcanPackage, parentContainer)
{
}
private static void SetVariablePath(DTS.DtsContainer dtsContainer)
{
var path = new StringBuilder(dtsContainer.Name);
while (dtsContainer.Parent != null)
{
dtsContainer = dtsContainer.Parent;
path.Insert(0, "/");
path.Insert(0, dtsContainer.Name);
}
path.Insert(0, "/Root/");
}
public LogUpdatePattern(Vulcan.Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer)
: base(vulcanPackage,
parentContainer)
{
}
private void BindParameter(DTS.Variable variable, DTSTasks.ExecuteSQLTask.ParameterDirections direction, string parameterName, int dataType, int size)
{
DTSTasks.ExecuteSQLTask.IDTSParameterBinding binding = SSISTask.ParameterBindings.Add();
binding.DtsVariableName = variable.QualifiedName;
binding.ParameterDirection = direction;
binding.ParameterName = parameterName;
binding.ParameterSize = size;
binding.DataType = dataType;
}
public DTS.Sequence AddSequenceContainer(string name, DTS.IDTSSequence parentContainer)
{
if (name != null && parentContainer != null)
{
if (parentContainer.Executables.Contains(name))
{
if (parentContainer.Executables[name] is DTS.IDTSSequence)
{
return (DTS.Sequence)parentContainer.Executables[name];
}
}
DTS.Sequence sequence = (DTS.Sequence)parentContainer.Executables.Add("STOCK:Sequence");
sequence.Name = name;
return sequence;
}
return null;
}
public string ExtractNameFromDTSExecutable(DTS.Executable exec)
{
PropertyInfo namePropertyInfo = exec.GetType().GetProperty("Name");
if (namePropertyInfo != null)
{
return (string)namePropertyInfo.GetValue(exec, null);
}
else
{
return "";
}
}
public ExecuteSQLPattern(Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer)
: base(vulcanPackage, parentContainer)
{
}
public static Pattern ProcessPattern(Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer, XPathNavigator patternNavigator, Pattern previousPattern)
{
DTS.Executable lastExecutableInPattern = null;
if (previousPattern != null)
{
lastExecutableInPattern = previousPattern.FirstExecutableGeneratedByPattern;
}
Pattern p = null;
Message.Trace(Severity.Debug,"Emitting Pattern {0}", patternNavigator.Name);
try
{
switch (patternNavigator.Name)
{
case "HelperTables":
p = new HelperTablePattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "ETL":
p = new ETLPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "StoredProc":
p = new StoredProcPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "Dimensions":
p = new DimensionsPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "Logtainer":
p = new LogtainerPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "LogUpdate":
p = new LogUpdatePattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "Container":
p = new ContainerPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "FileSystemTask":
p = new FileSystemTaskPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "ExecuteSQL":
p = new ExecuteSQLPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "FactTable":
p = new FactTablePattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "ExecutePackage":
p = new ExecutePackagePattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
case "FTPTask":
p = new FTPTaskPattern(vulcanPackage, parentContainer);
p.Emit(patternNavigator);
break;
default:
break;
}
}
catch (System.Runtime.InteropServices.COMException ce)
{
Message.Trace(Severity.Error,ce,"Exception in Pattern {0}\n {1}\n", patternNavigator.Name, ce.Message);
}
catch (Exception e)
{
Message.Trace(Severity.Error,e,"Exception in Pattern {0}\n {1}\n", patternNavigator.Name, e.Message);
}
return p;
}
public HelperTablePattern(Packages.VulcanPackage vulcanPackage, DTS.IDTSSequence parentContainer)
: base(vulcanPackage,
parentContainer)
{
}
