public void CreateFromRuntimeTest()
{
DatabaseSettings databaseSettings = DatabaseSettingsBuilder.Create(Host);
ParameterData data = databaseSettings.ConnectionStrings["Northwind"].Parameters["server"];
ParameterNode node = new ParameterNode(data);
CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
Assert.AreEqual(data.Name, node.Name);
Assert.AreEqual(data.Value, node.Value);
ValidateNodeCommand cmd = new ValidateNodeCommand(Host);
cmd.Execute(node);
Assert.AreEqual(0, ValidationErrorsCount);
}
public override void SetUp()
{
base.SetUp();
DatabaseSettingsNode databaseSettingsNode = new DatabaseSettingsNode(DatabaseSettingsBuilder.Create(Host));
IUIHierarchy hierarchy = CreateHierarchyAndAddToHierarchyService(databaseSettingsNode, CreateDefaultConfiguration());
ConfigurationNode[] nodes = hierarchy.FindNodesByType(typeof(ParameterNode));
foreach (ParameterNode node in nodes)
{
if (node.Name == "server")
{
parameterNode = node;
break;
}
}
}
public void Setup()
{
_person = new Person();
_ageAccessNode = new PropertyAccessNode(typeof(Person).GetProperty("Age"));
_brotherAccessNode = new PropertyAccessNode(typeof(Person).GetProperty("Brother")) { Children = new List<PropertyAccessTreeNode>() { _ageAccessNode } };
_parameterAccessNode = new ParameterNode(typeof(Person), "person") { Children = new List<PropertyAccessTreeNode>() { _brotherAccessNode } };
_brotherNode = new SubscriptionNode() { AccessNode = _brotherAccessNode };
_parameterNode = new SubscriptionNode() { AccessNode = _parameterAccessNode, Children = new List<SubscriptionNode>() { _brotherNode } };
_parameterNode.Subject = _person;
List<SubscriptionNode> nodes = new List<SubscriptionNode>() { _parameterNode };
_target = new SubscriptionTree(_person, nodes);
}
public void VisitParameter(ParameterNode node)
{
VisitParameterHandler(node);
}
//--- Methods ---
public void Process(ModuleNode module)
{
// find all parameters with an `Import` field
AtLocation("Parameters", () => FindAllParameterImports());
// resolve all imported values
_importer.BatchResolveImports();
// replace all parameters with an `Import` field
AtLocation("Parameters", () => ReplaceAllParameterImports());
// check if any imports were not found
foreach (var missing in _importer.MissingImports)
{
AddError($"import parameter '{missing}' not found");
}
return;
// local functions
void FindAllParameterImports(IEnumerable <ParameterNode> @params = null)
{
var paramIndex = 0;
foreach (var param in @params ?? module.Parameters)
{
++paramIndex;
var paramName = param.Name ?? $"#{paramIndex}";
AtLocation(paramName, () => {
if (param.Import != null)
{
AtLocation("Import", () => {
if (!Regex.IsMatch(param.Import, IMPORT_PATTERN))
{
AddError("import value is invalid");
return;
}
// check if import requires a deployment tier prefix
if (!param.Import.StartsWith("/"))
{
param.Import = $"/{Settings.Tier}/" + param.Import;
}
_importer.Add(param.Import);
});
}
// check if we need to import a custom resource handler topic
var resourceType = param?.Resource?.Type;
if ((resourceType != null) && !resourceType.StartsWith("AWS::"))
{
AtLocation("Resource", () => {
AtLocation("Type", () => {
// confirm the custom resource has a `ServiceToken` specified or imports one
if (resourceType.StartsWith("Custom::") || (resourceType == "AWS::CloudFormation::CustomResource"))
{
if (param.Resource.ImportServiceToken != null)
{
_importer.Add(param.Resource.ImportServiceToken);
}
else
{
AtLocation("Properties", () => {
if (param.Resource.Properties?.ContainsKey("ServiceToken") != true)
{
AddError("missing ServiceToken in custom resource properties");
}
});
}
return;
}
// parse resource name as `{MODULE}::{TYPE}` pattern to import the custom resource topic name
var customResourceHandlerAndType = resourceType.Split("::");
if (customResourceHandlerAndType.Length != 2)
{
AddError("custom resource type must have format {MODULE}::{TYPE}");
return;
}
if (!Regex.IsMatch(customResourceHandlerAndType[0], CLOUDFORMATION_ID_PATTERN))
{
AddError($"custom resource prefix must be alphanumeric: {customResourceHandlerAndType[0]}");
return;
}
if (!Regex.IsMatch(customResourceHandlerAndType[1], CLOUDFORMATION_ID_PATTERN))
{
AddError($"custom resource suffix must be alphanumeric: {customResourceHandlerAndType[1]}");
return;
}
param.Resource.Type = "Custom::" + param.Resource.Type.Replace("::", "");
// check if custom resource needs a service token to be retrieved
if (!(param.Resource.Properties?.ContainsKey("ServiceToken") ?? false))
{
var importServiceToken = $"/{Settings.Tier}"
+ $"/{customResourceHandlerAndType[0]}"
+ $"/{customResourceHandlerAndType[1]}CustomResourceTopic";
param.Resource.ImportServiceToken = importServiceToken;
_importer.Add(importServiceToken);
}
});
});
}
// check if we need to recurse into nested parameters
if (param.Parameters != null)
{
AtLocation("Parameters", () => {
FindAllParameterImports(param.Parameters);
});
}
});
}
}
// local functions
void ReplaceAllParameterImports(IList <ParameterNode> @params = null)
{
var parameterCollection = @params ?? module.Parameters;
for (var i = 0; i < parameterCollection.Count; ++i)
{
var parameter = parameterCollection[i];
var parameterName = parameter.Name ?? $"#{i + 1}";
AtLocation(parameterName, () => {
var resource = parameter.Resource;
if (resource != null)
{
AtLocation("Resource", () => {
if (resource.ImportServiceToken != null)
{
if (!_importer.TryGetValue(resource.ImportServiceToken, out string importedValue))
{
AddError("unable to find custom resource handler topic");
}
else
{
// add resolved `ServiceToken` to custom resource
if (resource.Properties == null)
{
resource.Properties = new Dictionary <string, object>();
}
resource.Properties["ServiceToken"] = importedValue;
}
}
});
}
// replace nested parameters
if (parameter.Parameters != null)
{
ReplaceAllParameterImports(parameter.Parameters);
}
// replace current parameter
if (parameter.Import != null)
{
// check if import is a parameter hierarchy
if (parameter.Import.EndsWith("/", StringComparison.Ordinal))
{
var imports = AtLocation("Import", () => {
_importer.TryGetValue(parameter.Import, out IEnumerable <ResolvedImport> found);
return(found);
}, null);
if (imports?.Any() == true)
{
parameterCollection[i] = ConvertImportedParameter(
parameter.Import.Substring(0, parameter.Import.Length - 1),
new ParameterNode(parameter)
);
}
else
{
AddError($"could not find import");
}
// local functions
ParameterNode ConvertImportedParameter(string path, ParameterNode node)
{
var current = imports.FirstOrDefault(import => import.Key == path);
SetImportedParameterNode(path, node, current);
// find nested, imported values
var subImports = imports.Where(import => import.Key.StartsWith(path + "/", StringComparison.Ordinal)).ToArray();
if (subImports.Any())
{
node.Parameters = subImports
.ToLookup(import => import.Key.Substring(path.Length + 1).Split('/', 2)[0])
.Select(child => ConvertImportedParameter(
path + "/" + child.Key,
new ParameterNode {
Name = child.Key
}
))
.ToArray();
}
return(node);
}
}
else
{
var import = AtLocation("Import", () => {
_importer.TryGetValue(parameter.Import, out ResolvedImport found);
return(found);
}, null);
if (import != null)
{
// check the imported parameter store type
parameterCollection[i] = new ParameterNode(parameter);
SetImportedParameterNode(parameter.Import, parameterCollection[i], import);
}
else
{
AddError($"import key not found '{parameter.Import}'");
}
}
}
});
}
}
}
public ProtectedRowNode(ParameterNode n, ProtectedRowKind kind) : base(n.Id, n.Parameter, n.Type)
{
this.RowKind = kind;
}
public virtual ParameterNode Visit(ParameterNode parameter)
{
return(parameter);
}
public UserFunction(ParameterNode parameters, BlockNode body, Environment father)
{
_parameters = parameters;
_body = body;
_father = father;
}
public ParameterMethod(ParameterNode parameter, MethodNode method)
{
Parameter = parameter;
Method = method;
}
public ParameterDirectInput(ParameterNode parameter, DirectInputNode constant)
{
Parameter = parameter;
DirectInput = constant;
}
public void Setup()
{
_source = ClinqTestFactory.CreateTwoPersonSource();
_propertyAccessTree = new PropertyAccessTree();
ParameterNode parameterNode = new ParameterNode(typeof(Person), "person");
_propertyAccessTree.Children.Add(parameterNode);
var agePropertyAccessNode = new PropertyAccessNode(typeof(Person).GetProperty("Age"));
parameterNode.Children.Add(agePropertyAccessNode);
_target = new NotifyCollectionChangedMonitor<Person>(_propertyAccessTree, _source);
}
public override dynamic Visit(ParameterNode node)
{
return(null);
}
internal override void Visit(ParameterNode node)
{
}
protected virtual void VisitParameterNode(ParameterNode node)
{
}
public LanguageType Visit(ParameterNode node)
{
return(node.Type);
}
private void InitializeTargetBrothersAgeAccess()
{
ParameterNode parameterNode = new ParameterNode(typeof(Person), "person");
_target.Children.Add(parameterNode);
_brotherPropertyAccessNode = new PropertyAccessNode(_brotherProperty);
parameterNode.Children.Add(_brotherPropertyAccessNode);
_agePropertyAccessNode = new PropertyAccessNode(_ageProperty);
_brotherPropertyAccessNode.Children.Add(_agePropertyAccessNode);
}
private void InitializeTargetJustAgeAccess()
{
ParameterNode parameterNode = new ParameterNode(typeof(NotifyingPerson), "person");
_target.Children.Add(parameterNode);
_agePropertyAccessNode = new PropertyAccessNode(_ageProperty);
parameterNode.Children.Add(_agePropertyAccessNode);
}
private void ProcessParameter(ParameterNode parameter)
{
var files = new List <string>();
AtLocation("Package", () => {
// find all files that need to be part of the package
string folder;
string filePattern;
SearchOption searchOption;
var packageFiles = Path.Combine(Settings.WorkingDirectory, parameter.Package.Files);
if ((packageFiles.EndsWith("/", StringComparison.Ordinal) || Directory.Exists(packageFiles)))
{
folder = Path.GetFullPath(packageFiles);
filePattern = "*";
searchOption = SearchOption.AllDirectories;
}
else
{
folder = Path.GetDirectoryName(packageFiles);
filePattern = Path.GetFileName(packageFiles);
searchOption = SearchOption.TopDirectoryOnly;
}
files.AddRange(Directory.GetFiles(folder, filePattern, searchOption));
files.Sort();
// compute MD5 hash for package
string package;
using (var md5 = MD5.Create()) {
var bytes = new List <byte>();
foreach (var file in files)
{
using (var stream = File.OpenRead(file)) {
var relativeFilePath = Path.GetRelativePath(folder, file);
bytes.AddRange(Encoding.UTF8.GetBytes(relativeFilePath));
var fileHash = md5.ComputeHash(stream);
bytes.AddRange(fileHash);
if (Settings.VerboseLevel >= VerboseLevel.Detailed)
{
Console.WriteLine($"... computing md5: {relativeFilePath} => {fileHash.ToHexString()}");
}
}
}
package = Path.Combine(Settings.OutputDirectory, $"{_module.Name}-{parameter.Name}-Package-{md5.ComputeHash(bytes.ToArray()).ToHexString()}.zip");
}
// create zip package
Console.WriteLine($"=> Building {parameter.Name} package");
if (Directory.Exists(Settings.OutputDirectory))
{
foreach (var file in Directory.GetFiles(Settings.OutputDirectory, $"{_module.Name}-{parameter.Name}-Package-*.zip"))
{
try {
File.Delete(file);
} catch { }
}
}
using (var zipArchive = ZipFile.Open(package, ZipArchiveMode.Create)) {
foreach (var file in files)
{
var filename = Path.GetRelativePath(folder, file);
zipArchive.CreateEntryFromFile(file, filename);
}
}
parameter.Package.PackagePath = package;
});
}
public void Visit(ParameterNode node)
{
CurrentSymbolTable.Insert(node.Identifier, node.Type, node);
}
private bool ResolvePropertyParameter(Type targetType, PathElement[] elements, int position, ParameterNode node, string source)
{
var pi = targetType.GetProperty(elements[position].Name, BindingFlags.Instance | BindingFlags.Public);
if (pi == null)
{
return(false);
}
var type = pi.PropertyType;
for (var i = 0; i < elements[position].Indexed; i++)
{
type = GetNestedValueType(type);
}
if (position < elements.Length - 1)
{
return(ResolvePropertyParameter(type, elements, position + 1, node, source));
}
var direction = GetParameterDirection(pi);
var isMultiple = ParameterHelper.IsMultipleParameter(type);
if (isMultiple && (direction != ParameterDirection.Input))
{
throw new AccessorGeneratorException($"DB parameter argument is not valid. type=[{method.DeclaringType.FullName}], method=[{method.Name}], source=[{node.Name}]");
}
parameters.Add(new ParameterEntry(
node.Name,
index++,
source,
-1,
pi.DeclaringType,
pi.Name,
type,
direction,
node.ParameterName,
isMultiple));
return(true);
}
public virtual Value evaluate(Context cx, ParameterNode node)
{
if ((0 <= node.kind) && (node.kind < Tokens.tokenClassNames.length))
{
output("<ParameterNode kind=\"" + Tokens.tokenClassNames[node.kind] + "\">");
}
else
{
output("<ParameterNode kind=\"" + node.kind + "\">");
}
indent_Renamed_Field++;
if (node.identifier != null)
{
node.identifier.evaluate(cx, this);
}
if (node.type != null)
{
node.type.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</ParameterNode>");
return null;
}
public override void Visit(ParameterNode node)
{
if (processed.Contains(node.Name))
{
return;
}
processed.Add(node.Name);
// [MEMO] Simple property only
var parser = new PathElementParser(node.Name);
var elements = parser.Parse();
for (var i = 0; i < method.GetParameters().Length; i++)
{
var pmi = method.GetParameters()[i];
if (!ParameterHelper.IsSqlParameter(pmi))
{
continue;
}
var type = pmi.ParameterType.IsByRef ? pmi.ParameterType.GetElementType() : pmi.ParameterType;
if (pmi.Name == elements[0].Name)
{
for (var j = 0; j < elements[0].Indexed; j++)
{
type = GetNestedValueType(type);
}
if (elements.Length == 1)
{
var direction = GetParameterDirection(pmi);
var isMultiple = ParameterHelper.IsMultipleParameter(type);
if (isMultiple && (direction != ParameterDirection.Input))
{
throw new AccessorGeneratorException($"DB parameter argument is not valid. type=[{method.DeclaringType.FullName}], method=[{method.Name}], source=[{node.Name}]");
}
parameters.Add(new ParameterEntry(
node.Name,
index++,
node.Name,
i,
null,
null,
type,
direction,
node.ParameterName,
isMultiple));
return;
}
if (ResolvePropertyParameter(type, elements, 1, node, node.Name))
{
return;
}
}
if (ParameterHelper.IsNestedParameter(pmi) &&
ResolvePropertyParameter(type, elements, 0, node, $"{pmi.Name}.{node.Name}"))
{
return;
}
}
// Dynamic
dynamicParameters.Add(new DynamicParameterEntry(node.Name, index++, node.IsMultiple));
}
public virtual void VisitParameterNode(ParameterNode node)
{
Visit(node.ModifierNode);
Visit(node.NameListNode);
Visit(node.ColonNode);
Visit(node.TypeNode);
Visit(node.EqualSignNode);
Visit(node.DefaultValueNode);
}
//private void Flow(SimplePointsToGraph ptg, Instruction instruction)
//{
// var ptaVisitor = new PTAVisitor(ptg, this);
// ptaVisitor.Visit(instruction);
//}
private void CreateInitialGraph(bool createNodeForParams = true, SimplePointsToGraph initialGraph = null)
{
this.ReturnVariable = new LocalVariable(this.method.Name + "_" + "$RV", method)
{
Type = this.method.Type.PlatformType.SystemObject
};
//IteratorPointsToAnalysis.GlobalVariable= new LocalVariable("$Global");
//IteratorPointsToAnalysis.GlobalVariable.Type = MyLoader.PlatformTypes.SystemObject;
var ptg = initialGraph == null ? new SimplePointsToGraph() : initialGraph.Clone();
var variables = cfg.GetVariables();
var body = MethodBodyProvider.Instance.GetBody(this.method);
var parameters = body.Parameters;
if (parameters != null)
{
variables.AddRange(parameters);
}
int counter = -1;
IVariable thisVariable = null;
SimplePTGNode thisNode = null;
foreach (var variable in variables)
{
// TODO: replace when Egdardo fixes type inferece
if (variable.Type == null || !variable.Type.IsClassOrStruct())
{
continue;
}
// if (variable.Type.TypeKind == TypeKind.ValueType) continue;
if (variable.IsParameter)
{
var isThisParameter = variable.Name == "this";
var kind = isThisParameter ? SimplePTGNodeKind.Object : SimplePTGNodeKind.Unknown;
if (createNodeForParams)
{
var ptgId = new PTGID(new MethodContex(this.method), counter--);
var node = new ParameterNode(ptgId, variable.Name, variable.Type);
ptg.Add(node);
ptg.PointsTo(variable, node);
if (isThisParameter)
{
thisVariable = variable;
thisNode = node;
}
}
if (isThisParameter)
{
this.ThisVariable = variable;
}
ptg.Add(variable);
}
else
{
//ptg.Add(variable);
ptg.PointsTo(variable, SimplePointsToGraph.NullNode);
}
}
//foreach(var specialField in specialFields)
//{
// counter = -1000;
// var variable = specialField.Value;
// var fieldName = specialField.Key;
// var ptgId = new PTGID(new MethodContex(this.method), counter--);
// var node = new SimplePTGNode(ptgId, variable.Type);
// ptg.Add(node);
// ptg.PointsTo(thisNode, new FieldReference(fieldName, variable.Type, method.ContainingType), node);
//}
ptg.Add(this.ReturnVariable);
ptg.Add(SimplePointsToAnalysis.GlobalVariable);
ptg.PointsTo(SimplePointsToAnalysis.GlobalVariable, SimplePointsToGraph.GlobalNode);
this.initialGraph = ptg;
}
