private AnalyzeRequest GenerateRequest(IApiPortOptions options, IDependencyInfo dependencyInfo) { return(new AnalyzeRequest { Targets = options.Targets.SelectMany(_targetMapper.GetNames).ToList(), Dependencies = dependencyInfo.Dependencies, AssembliesToIgnore = _assembliesToIgnore, // We pass along assemblies to ignore instead of filtering them from Dependencies at this point // because breaking change analysis and portability analysis will likely want to filter dependencies // in different ways for ignored assemblies. // For breaking changes, we should show breaking changes for // an assembly if it is un-ignored on any of the user-specified targets and we should hide breaking changes // for an assembly if it ignored on all user-specified targets. // For portability analysis, on the other hand, we will want to show portability for precisely those targets // that a user specifies that are not on the ignore list. In this case, some of the assembly's dependency // information will be needed. UnresolvedAssemblies = dependencyInfo.UnresolvedAssemblies.Keys.ToList(), UnresolvedAssembliesDictionary = dependencyInfo.UnresolvedAssemblies, UserAssemblies = dependencyInfo.UserAssemblies.ToList(), AssembliesWithErrors = dependencyInfo.AssembliesWithErrors.ToList(), ApplicationName = options.Description, Version = AnalyzeRequest.CurrentVersion, RequestFlags = options.RequestFlags, BreakingChangesToSuppress = options.BreakingChangeSuppressions }); }
/// <summary> /// Resolve the specified bean. /// </summary> /// <returns>The instance of the resolved dependency.</returns> /// <param name="beanName">The bean name.</param> public object Resolve(string beanName = null) { string beanKey = !String.IsNullOrEmpty(beanName) ? beanName : String.Empty; if (instances.ContainsKey(beanKey)) { return(instances[beanKey]); } if (String.IsNullOrEmpty(beanKey)) { IDependencyInfo info = primary ?? (beans.Count == 1 ? beans.Values.First() : throw new BeanCreationException(String.Format(beans.Count > 1 ? "Multiple beans found for {0}, none marked as primary." : "No primary bean found for {0}.", type.Name))); return(Create(info, String.Empty)); } if (!beans.ContainsKey(beanKey)) { throw new BeanNotFoundException(String.Format("No bean found under the name of {0} for type {1}", beanKey, type.Name)); } return(Create(beans[beanKey], beanKey)); }
/// <summary> /// Implement the on build method that will be called for each definition added. /// </summary> /// <param name="definition">The dependency info that describes what is required.</param> protected override void OnBuild(IDependencyInfo definition) { if (!TryRegisterTypeTo(definition as IDependencyTypeInfo) && !TryRegisterMethod(definition as IDependencyMethodInfo) && !TryRegisterInstance(definition as IDependencyInstanceInfo) && !TryRegisterFactory(definition as IDependencyFactoryInfo)) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The binding for the type '{0}' is invalid. The binding has not been configured correctly", definition.ResolvedTypes.ToArray())); } }
public async Task ExecuteAsync() { IEnumerable <IDependencyInfo> dependencyInfos = new IDependencyInfo[] { CreateBuildInfo(RuntimeImageVariant, this.options.DateStampRuntime ?? this.options.DateStampAll ?? String.Empty), CreateBuildInfo(SdkImageVariant, this.options.DateStampSdk ?? this.options.DateStampAll ?? String.Empty), CreateBuildInfo(AspnetImageVariant, this.options.DateStampAspnet ?? this.options.DateStampAll ?? String.Empty), CreateBuildInfo(WcfImageVariant, this.options.DateStampWcf ?? this.options.DateStampAll ?? String.Empty), }; DependencyUpdateResults updateResults = UpdateFiles(dependencyInfos); if (updateResults.ChangesDetected()) { if (this.options.UpdateOnly) { Trace.TraceInformation($"Changes made but no GitHub credentials specified, skipping PR creation"); } else { await CreatePullRequestAsync(dependencyInfos); } } }
protected override void OnBuild(IDependencyInfo info) { if (!TryRegisterTypeTo(Builder, info as IDependencyTypeInfo) && !TryRegisterMethod(Builder, info as IDependencyMethodInfo) && !TryRegisterInstance(Builder, info as IDependencyInstanceInfo) && !TryRegisterFactory(Builder, info)) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The binding for the type '{0}' is invalid. The binding has not been configured correctly", info)); } }
protected override string TryGetDesiredValue( IEnumerable <IDependencyInfo> dependencyBuildInfos, out IEnumerable <IDependencyInfo> usedBuildInfos) { IDependencyInfo productInfo = dependencyBuildInfos.First(info => info.SimpleName == _productName); usedBuildInfos = new IDependencyInfo[] { productInfo }; string version; switch (_versionType) { case VersionType.Build: version = GetBuildVersion(productInfo); break; case VersionType.Product: version = GetProductVersion(productInfo); break; default: throw new NotSupportedException($"Unsupported VersionType: {_versionType}"); } return(version); }
protected override string TryGetDesiredValue( IEnumerable <IDependencyInfo> dependencyBuildInfos, out IEnumerable <IDependencyInfo> usedBuildInfos) { IDependencyInfo productInfo = dependencyBuildInfos.First(info => info.SimpleName == _productName); usedBuildInfos = new IDependencyInfo[] { productInfo }; const string RtmSubstring = "-rtm."; string versionDir = _buildVersion; string versionFile = _buildVersion; if (versionFile.Contains(RtmSubstring)) { versionFile = versionFile.Substring(0, versionFile.IndexOf(RtmSubstring)); } string downloadUrl = s_urls[_productName] .Replace("$ARCHIVE_EXT", _os.Contains("win") ? "zip" : "tar.gz") .Replace("$VERSION_DIR", versionDir) .Replace("$VERSION_FILE", versionFile) .Replace("$OS", _os) .Replace("$ARCH", _arch) .Replace("..", "."); return(GetArtifactShaAsync(downloadUrl).Result); }
private static void Validate(IDependencyInfo definition) { if (definition.ResolvedTypes?.Count > 0) { return; } throw new InvalidOperationException($"The definition '{definition}', does not contain any resolve types."); }
public DependencyFactoryInfo(Type factoryType, string methodName, IDependencyInfo info) : base(info) { if (string.IsNullOrWhiteSpace(methodName)) { throw new ArgumentException($"'{nameof(methodName)}' cannot be null or whitespace.", nameof(methodName)); } FactoryType = factoryType ?? throw new ArgumentNullException(nameof(factoryType)); MethodName = methodName; }
protected override void OnBuild(IDependencyInfo info) { IBindingToSyntax <object> initial = Kernel.Bind(info.ResolvedTypes.ToArray()); IBindingWhenInNamedWithOrOnSyntax <object> binding = BuildTo(info, initial); BindScope(info, binding); BindNamedIfConfigured(info, binding); Definitions.Add(info); }
public IRuntimeResolutionPlan FromInfo(IDependencyInfo info) { if (info is IDependencyTypeInfo typeInfo) { return(CreateTypedPlan(typeInfo.ResolutionType)); } var resolver = Ioc.Container.Resolver(); return(new RuntimeResolutionPlanResolution(resolver.TryGetResolution(info.ResolvedTypes.First(), info.Key))); }
protected override string TryGetDesiredValue( IEnumerable <IDependencyInfo> dependencyBuildInfos, out IEnumerable <IDependencyInfo> usedBuildInfos) { IDependencyInfo productInfo = dependencyBuildInfos.First(info => info.SimpleName == _productName); usedBuildInfos = new IDependencyInfo[] { productInfo }; return(_versionType switch { VersionType.Build => GetBuildVersion(productInfo), VersionType.Product => GetProductVersion(productInfo), _ => throw new NotSupportedException($"Unsupported VersionType: {_versionType}"), });
private static void BindScope(IDependencyInfo info, IBindingWhenInNamedWithOrOnSyntax <object> binding) { switch (info.Scope) { case DependyBuilderScope.Transient: binding.InTransientScope(); break; case DependyBuilderScope.Singleton: binding.InSingletonScope(); break; } }
public void Add(IDependencyInfo dependency) { var keys = dependency.ResolvedTypes; foreach (var key in keys) { if (!Definitions.TryGetValue(key, out IList <IDependencyInfo> definitions)) { Definitions[key] = definitions = new List <IDependencyInfo>(); } definitions.Add(dependency); } }
/// <summary> /// Create the new bean by the specified key. /// </summary> /// <returns>The create.</returns> /// <param name="beanKey">Bean key.</param> private object Create(IDependencyInfo info, string beanKey) { object val = context.Autowire(info.Create()); instances.Add(beanKey, val); val.GetType() .GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) .ToList() .FindAll(x => x.Name.Equals(info.InitMethod) || x.GetCustomAttributes <PostConstructAttribute>().Any()) .ForEach(x => InvokeInitMethod(x, val)); return(val); }
/// <summary> /// Convert a generic type info into a concrete type info /// </summary> /// <param name="info">The current dependency info</param> /// <param name="genericTypeArguments">The generic type arguments.</param> /// <returns>A new instance of the dependency info with the concrete information set.</returns> public static IDependencyInfo As(this IDependencyInfo info, params Type[] genericTypeArguments) { if (info is IDependencyTypeInfo typeInfo) { return(As(typeInfo, genericTypeArguments)); } if (info is IDependencyFactoryInfo factoryInfo) { return(As(factoryInfo, genericTypeArguments)); } throw new NotSupportedException($"The dependency info {info} is not currently supported."); }
public static IDependencyInfo As(this IDependencyInfo info, Type concreteRequestType) { if (info is IDependencyTypeInfo typeInfo) { return(As(typeInfo, concreteRequestType)); } if (info is IDependencyFactoryInfo factoryInfo) { return(As(factoryInfo, concreteRequestType)); } throw new NotSupportedException($"The dependency info {info} is not currently supported."); }
private static void Build <TActivatorData, TRegistrationStyle>(IDependencyInfo info, IRegistrationBuilder <object, TActivatorData, TRegistrationStyle> binding) { binding.As(info.ResolvedTypes.ToArray()); switch (info.Scope) { case DependyBuilderScope.Transient: binding.InstancePerDependency(); break; case DependyBuilderScope.Singleton: binding.SingleInstance(); break; } }
/// <summary> /// Create a new instance with copied values. /// </summary> /// <param name="copy">The base instance to copy from.</param> protected DependencyInfo(IDependencyInfo copy) : this() { if (copy == null) { return; } Key = copy.Key; Scope = copy.Scope; foreach (var resolvedType in copy.ResolvedTypes) { ResolvedTypes.Add(resolvedType); } }
protected override string TryGetDesiredValue( IEnumerable <IDependencyInfo> dependencyBuildInfos, out IEnumerable <IDependencyInfo> usedBuildInfos) { IDependencyInfo productInfo = dependencyBuildInfos.First(info => info.SimpleName == _productName); usedBuildInfos = new IDependencyInfo[] { productInfo }; string downloadUrl = s_urls[_productName] .Replace("$ARCHIVE_EXT", _os.Contains("win") ? "zip" : "tar.gz") .Replace("$VERSION", _buildVersion) .Replace("$OS", _os) .Replace("$ARCH", _arch) .Replace("..", "."); return(GetArtifactShaAsync(downloadUrl).Result); }
private AnalyzeRequest GenerateRequest(IApiPortOptions options, IDependencyInfo dependencyInfo) { // Match the dependencyInfo for each user assembly to the given // input assemblies to see whether or not the assembly was explicitly // specified. foreach (var assembly in dependencyInfo.UserAssemblies) { // Windows's file paths are case-insensitive var matchingAssembly = options.InputAssemblies.FirstOrDefault(x => x.Key.Name.Equals(assembly.Location, StringComparison.OrdinalIgnoreCase)); // AssemblyInfo is explicitly specified if we found a matching // assembly location in the input dictionary AND the value is // true. assembly.IsExplicitlySpecified = matchingAssembly.Key != default(IAssemblyFile) && matchingAssembly.Value; } return(new AnalyzeRequest { Entrypoints = new[] { options.Entrypoint }, Targets = options.Targets.SelectMany(_targetMapper.GetNames).ToList(), Dependencies = dependencyInfo.Dependencies, // We pass along assemblies to ignore instead of filtering them from Dependencies at this point // because breaking change analysis and portability analysis will likely want to filter dependencies // in different ways for ignored assemblies. // For breaking changes, we should show breaking changes for // an assembly if it is un-ignored on any of the user-specified targets and we should hide breaking changes // for an assembly if it ignored on all user-specified targets. // For portability analysis, on the other hand, we will want to show portability for precisely those targets // that a user specifies that are not on the ignore list. In this case, some of the assembly's dependency // information will be needed. AssembliesToIgnore = _assembliesToIgnore, UnresolvedAssemblies = dependencyInfo.UnresolvedAssemblies.Keys.ToList(), UnresolvedAssembliesDictionary = dependencyInfo.UnresolvedAssemblies, UserAssemblies = dependencyInfo.UserAssemblies.ToList(), NonUserAssemblies = dependencyInfo.NonUserAssemblies.ToList(), AssembliesWithErrors = dependencyInfo.AssembliesWithErrors.ToList(), ApplicationName = options.Description, Version = AnalyzeRequest.CurrentVersion, RequestFlags = options.RequestFlags, BreakingChangesToSuppress = options.BreakingChangeSuppressions, ReferencedNuGetPackages = options.ReferencedNuGetPackages }); }
private string GetProductVersion(IDependencyInfo productInfo) { // Derive the Docker tag version from the product build version. // 5.0.0-preview.2.19530.9 => 5.0.0-preview.2 string versionRegexPattern = "[\\d]+.[\\d]+.[\\d]+(-[\\w]+(.[\\d]+)?)?"; Match versionMatch = Regex.Match(productInfo.SimpleVersion, versionRegexPattern); string version = versionMatch.Success ? versionMatch.Value : productInfo.SimpleVersion; foreach (string excludedMoniker in s_excludedMonikers) { int monikerIndex = version.IndexOf($"-{excludedMoniker}", StringComparison.OrdinalIgnoreCase); if (monikerIndex != -1) { version = version.Substring(0, monikerIndex); } } return(version); }
/// <summary> /// Adds the bean. /// </summary> /// <param name="name">The bean name.</param> /// <param name="mInfo">The Method info.</param> /// <param name="isPrimary">If set to <c>true</c> is primary.</param> public void AddBean(string name, MemberInfo mInfo, bool isPrimary, string initMethod = null) { if (isPrimary && primary != null) { throw new InjectStartupException(String.Format("Multiple primary beans detected for type: {0}. Bean names: {1}, {2}", type.Name, primary.Name, name)); } if (beans.ContainsKey(name)) { throw new InjectStartupException(String.Format("Duplicated bean found for type: {0}. Bean name: {1}", type.Name, name)); } IDependencyInfo info = CreateDependencyInfo(name, mInfo, isPrimary, initMethod); if (isPrimary) { primary = info; } beans.Add(name, info); }
private static void BindNamedIfConfigured(IDependencyInfo info, IBindingWhenInNamedWithOrOnSyntax <object> binding) { string named; if (info.Key is Enum enumKey) { named = enumKey.GetBindingName(); } else if (info.Key is string name) { named = name; } else { named = info.Key?.ToString(); } if (!string.IsNullOrWhiteSpace(named)) { binding.Named(named); } }
private IBindingWhenInNamedWithOrOnSyntax <object> BuildTo(IDependencyInfo info, IBindingToSyntax <object> initial) { if (info is IDependencyMethodInfo methodInfo) { return(initial.ToMethod(ctx => ExecuteMethod(methodInfo, ctx))); } if (info is IDependencyTypeInfo typeInfo) { return(initial.To(typeInfo.ResolutionType)); } if (info is IDependencyInstanceInfo instanceInfo) { return(initial.ToConstant(instanceInfo.Instance)); } if (info is IDependencyFactoryInfo factoryInfo) { return(initial.ToMethod(ctx => ExecuteFactory(factoryInfo, ctx))); } throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The binding for the types '{0}' is invalid. The binding has not been configured correctly", info)); }
public IDependencyBuilderBindingMetaData WithFactory(Type factoryType, string methodName) { _info = new DependencyFactoryInfo(factoryType, methodName, _info); return(this); }
public IDependencyBuilderBindingMetaData WithFactory <T>(string methodName) { _info = new DependencyFactoryInfo(typeof(T), methodName, _info); return(this); }
public IDependencyBuilderBindingMetaData With <T>(T instance) { _info = new DependencyInstanceInfo(instance, _info); return(this); }
public IDependencyBuilderBindingMetaData With(Func <IDependencyContext, object> method) { _info = new DependencyMethodInfo(method, _info); return(this); }
public IDependencyBuilderBindingMetaData With(Type type) { _info = new DependencyTypeInfo(type, _info); return(this); }
/// <summary> /// Gets the Portability of an application as a ReportingResult. /// </summary> /// <returns>Set of APIs/assemblies that are not portable/missing.</returns> private async Task<ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo) { var fullResponse = await RetrieveResultAsync(request); CheckEndpointStatus(fullResponse.Headers.Status); return GetReportingResult(request, fullResponse.Response, dependencyInfo); }
/// <summary> /// Gets the Portability of an application as a ReportingResult. /// </summary> /// <returns>Set of APIs/assemblies that are not portable/missing.</returns> private async Task<ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo) { var fullResponse = await RetrieveResultAsync(request); CheckEndpointStatus(fullResponse.Headers.Status); using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport)) { try { var response = fullResponse.Response; return _reportGenerator.ComputeReport( response.Targets, response.SubmissionId, request.RequestFlags, dependencyInfo?.Dependencies, response.MissingDependencies, dependencyInfo?.UnresolvedAssemblies, response.UnresolvedUserAssemblies, dependencyInfo?.AssembliesWithErrors ); } catch (Exception) { progressTask.Abort(); throw; } } }
private AnalyzeRequest GenerateRequest(IApiPortOptions options, IDependencyInfo dependencyInfo) { return new AnalyzeRequest { Targets = options.Targets.SelectMany(_targetMapper.GetNames).ToList(), Dependencies = dependencyInfo.Dependencies, AssembliesToIgnore = _assembliesToIgnore, // We pass along assemblies to ignore instead of filtering them from Dependencies at this point // because breaking change analysis and portability analysis will likely want to filter dependencies // in different ways for ignored assemblies. // For breaking changes, we should show breaking changes for // an assembly if it is un-ignored on any of the user-specified targets and we should hide breaking changes // for an assembly if it ignored on all user-specified targets. // For portability analysis, on the other hand, we will want to show portability for precisely those targets // that a user specifies that are not on the ignore list. In this case, some of the assembly's dependency // information will be needed. UnresolvedAssemblies = dependencyInfo.UnresolvedAssemblies.Keys.ToList(), UnresolvedAssembliesDictionary = dependencyInfo.UnresolvedAssemblies, UserAssemblies = dependencyInfo.UserAssemblies.ToList(), AssembliesWithErrors = dependencyInfo.AssembliesWithErrors.ToList(), ApplicationName = options.Description, Version = AnalyzeRequest.CurrentVersion, RequestFlags = options.RequestFlags, BreakingChangesToSuppress = options.BreakingChangeSuppressions }; }
private ReportingResult GetReportingResult(AnalyzeRequest request, AnalyzeResponse response, IDependencyInfo dependencyInfo) { if (response == null) { return null; } using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport)) { try { return _reportGenerator.ComputeReport( response.Targets, response.SubmissionId, request.RequestFlags, dependencyInfo?.Dependencies, response.MissingDependencies, dependencyInfo?.UnresolvedAssemblies, response.UnresolvedUserAssemblies, dependencyInfo?.AssembliesWithErrors ); } catch (Exception) { progressTask.Abort(); throw; } } }
public ICodeFileInfo FindCodeFileFor(IDependencyInfo dependencyInfo) { return projects.SelectMany(p => p.CodeFiles) .FirstOrDefault(c => c.Declerations.Any(d => d.Name == dependencyInfo.Name)); }