public ValidationResult Run(ValidationConfig config, ILambdaContext context) { string snsTopicArn = null; try { LogUtilities.UpdateLogger(context.Logger, null); LogUtilities.LogLambdaInfo(context, CommandLineUtilities.InformationalVersion); LogUtilities.LogObject("Config", config); LogUtilities.Log(new[] { LambdaUrlHelper.UrlBaseEnvironmentVariableName, LambdaUtilities.SnsTopicKey }); LambdaUtilities.GarbageCollect(); snsTopicArn = LambdaUtilities.GetEnvironmentVariable(LambdaUtilities.SnsTopicKey); config.Validate(); GenomeAssembly genomeAssembly = GenomeAssemblyHelper.Convert(config.genomeAssembly); string nirvanaS3Ref = LambdaUrlHelper.GetRefUrl(genomeAssembly); var refProvider = ProviderUtilities.GetSequenceProvider(nirvanaS3Ref); using (var stream = PersistentStreamUtils.GetReadStream(config.customStrUrl)) TryLoadStrFile(stream, genomeAssembly, refProvider); } catch (Exception exception) { return(HandleException(config.id, exception, snsTopicArn)); } return(GetSuccessOutput(config.id)); }
public override SyntaxNode TryGetCorrespondingLambdaBody( SyntaxNode previousLambdaSyntax, SyntaxNode lambdaOrLambdaBodySyntax) { return(LambdaUtilities.TryGetCorrespondingLambdaBody( lambdaOrLambdaBodySyntax, previousLambdaSyntax)); }
protected override async Task <bool> PerformActionAsync() { var currentConfiguration = await GetFunctionConfigurationAsync(); if (currentConfiguration == null) { this.Logger.WriteLine($"Could not find existing Lambda function {this.GetStringValueOrDefault(this.FunctionName, LambdaDefinedCommandOptions.ARGUMENT_FUNCTION_NAME, true)}"); return(false); } var layerVersionArns = this.GetStringValuesOrDefault(this.LayerVersionArns, LambdaDefinedCommandOptions.ARGUMENT_FUNCTION_LAYERS, false); var layerPackageInfo = await LambdaUtilities.LoadLayerPackageInfos(this.Logger, this.LambdaClient, this.S3Client, layerVersionArns); await UpdateConfigAsync(currentConfiguration, layerPackageInfo.GenerateDotnetSharedStoreValue()); await ApplyTags(currentConfiguration.FunctionArn); var publish = this.GetBoolValueOrDefault(this.Publish, LambdaDefinedCommandOptions.ARGUMENT_FUNCTION_PUBLISH, false).GetValueOrDefault(); if (publish) { await PublishFunctionAsync(currentConfiguration.FunctionName); } return(true); }
private static IEnumerable <AnnotationRange> GetAnnotationRanges(NirvanaConfig config, GenomeAssembly genomeAssembly) { string cachePathPrefix = LambdaUtilities.GetCachePathPrefix(genomeAssembly); IntervalForest <IGene> geneIntervalForest; IDictionary <string, IChromosome> refNameToChromosome; List <long> blockOffsets; using (var tabixStream = PersistentStreamUtils.GetReadStream(config.tabixUrl)) using (var tabixReader = new BinaryReader(new BlockGZipStream(tabixStream, CompressionMode.Decompress))) using (var referenceStream = PersistentStreamUtils.GetReadStream(LambdaUrlHelper.GetRefUrl(genomeAssembly))) using (var sequenceProvider = new ReferenceSequenceProvider(referenceStream)) using (var taProvider = new TranscriptAnnotationProvider(cachePathPrefix, sequenceProvider, null)) { long vcfSize = HttpUtilities.GetLength(config.vcfUrl); int numPartitions = Math.Max(Math.Min((int)((vcfSize - 1) / MinPartitionSize + 1), MaxNumPartitions), MinNumPartitions); var tabixIndex = Reader.Read(tabixReader, sequenceProvider.RefNameToChromosome); blockOffsets = PartitionUtilities.GetFileOffsets(config.vcfUrl, numPartitions, tabixIndex); IntervalArray <ITranscript>[] transcriptIntervalArrays = taProvider.TranscriptIntervalArrays; geneIntervalForest = GeneForestGenerator.GetGeneForest(transcriptIntervalArrays); refNameToChromosome = sequenceProvider.RefNameToChromosome; } IEnumerable <AnnotationRange> annotationRanges = PartitionUtilities.GenerateAnnotationRanges(blockOffsets, config.vcfUrl, geneIntervalForest, refNameToChromosome); return(annotationRanges); }
/// <summary> /// There are a few places where we allow breakpoints on expressions. /// /// 1) When the expression is the body of a lambda/method/operator/property/indexer. /// 2) The expression is a breakable expression inside a query expression. /// 3) The expression is in a for statement initializer, condition or incrementor. /// 4) The expression is a foreach initializer. /// </summary> private static bool IsBreakableExpression(ExpressionSyntax expression) { if (expression == null || expression.Parent == null) { return false; } var parent = expression.Parent; switch (parent.Kind()) { case SyntaxKind.ArrowExpressionClause: Debug.Assert(((ArrowExpressionClauseSyntax)parent).Expression == expression); return true; case SyntaxKind.ForStatement: var forStatement = (ForStatementSyntax)parent; return forStatement.Initializers.Contains(expression) || forStatement.Condition == expression || forStatement.Incrementors.Contains(expression); case SyntaxKind.ForEachStatement: case SyntaxKind.ForEachComponentStatement: var forEachStatement = (CommonForEachStatementSyntax)parent; return forEachStatement.Expression == expression; default: return LambdaUtilities.IsLambdaBodyStatementOrExpression(expression); } }
private static AnnotationResources GetAnnotationResources(AnnotationConfig annotationConfig) { var genomeAssembly = GenomeAssemblyHelper.Convert(annotationConfig.genomeAssembly); string cachePathPrefix = LambdaUrlHelper.GetCacheFolder().UrlCombine(genomeAssembly.ToString()).UrlCombine(LambdaUrlHelper.DefaultCacheSource); string nirvanaS3Ref = LambdaUrlHelper.GetRefUrl(genomeAssembly); string saManifestUrl = LambdaUtilities.GetManifestUrl(annotationConfig.supplementaryAnnotations ?? "latest", genomeAssembly); var metrics = new PerformanceMetrics(); var annotationResources = new AnnotationResources(nirvanaS3Ref, cachePathPrefix, saManifestUrl == null? null: new List <string> { saManifestUrl }, annotationConfig.customAnnotations, annotationConfig.customStrUrl, false, false, false, metrics); using (var tabixStream = PersistentStreamUtils.GetReadStream(annotationConfig.tabixUrl)) { annotationResources.InputStartVirtualPosition = GetTabixVirtualPosition(annotationConfig.annotationRange, tabixStream, annotationResources.SequenceProvider.RefNameToChromosome); } Logger.WriteLine($"Tabix position :{annotationResources.InputStartVirtualPosition}"); return(annotationResources); }
public async Task FunctionImmediateAvailable() { var functionName = "fakeFunction"; var mockLambda = new Mock <IAmazonLambda>(); mockLambda.Setup(client => client.GetFunctionConfigurationAsync(It.IsAny <GetFunctionConfigurationRequest>(), It.IsAny <CancellationToken>())) .Callback <GetFunctionConfigurationRequest, CancellationToken>((request, token) => { Assert.Equal(functionName, request.FunctionName); }) .Returns((GetFunctionConfigurationRequest r, CancellationToken token) => { return(Task.FromResult(new GetFunctionConfigurationResponse { State = State.Active, LastUpdateStatus = LastUpdateStatus.Successful })); }); var logger = new TestToolLogger(); await LambdaUtilities.WaitTillFunctionAvailableAsync(logger, mockLambda.Object, functionName); Assert.Equal(0, logger.Buffer.Length); }
private void ValidateTargetFrameworkAndLambdaRuntime() { string runtimeName = this.GetStringValueOrDefault(this.Runtime, LambdaDefinedCommandOptions.ARGUMENT_FUNCTION_RUNTIME, true); string frameworkName = this.GetStringValueOrDefault(this.TargetFramework, CommonDefinedCommandOptions.ARGUMENT_FRAMEWORK, true); LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime(runtimeName, frameworkName); }
public void ConvertAspNetCoreProject() { var testManifest = File.ReadAllText("./TestFiles/ManifestAspNetCoreProject.xml"); var result = LambdaUtilities.ConvertManifestContentToSdkManifest("netcoreapp2.1", testManifest); Assert.True(result.Updated); Assert.False(object.ReferenceEquals(testManifest, result.UpdatedContent)); var xmlDoc = XDocument.Parse(result.UpdatedContent); Assert.Equal("Microsoft.NET.Sdk", xmlDoc.Root.Attribute("Sdk")?.Value); var packageReferences = xmlDoc.XPathSelectElements("//ItemGroup/PackageReference").ToList(); Func <string, XElement> findRef = (name) => { return(packageReferences.FirstOrDefault(x => string.Equals(name, x.Attribute("Include")?.Value, StringComparison.OrdinalIgnoreCase))); }; var netCoreAppRef = packageReferences.FirstOrDefault(x => string.Equals("Microsoft.NETCore.App", x.Attribute("Update")?.Value, StringComparison.OrdinalIgnoreCase)); Assert.NotNull(netCoreAppRef); Assert.Equal("false", netCoreAppRef.Attribute("Publish")?.Value); Assert.NotNull(findRef("Microsoft.AspNetCore.App")); Assert.NotNull(findRef("Amazon.Lambda.AspNetCoreServer")); Assert.NotNull(findRef("AWSSDK.S3")); Assert.NotNull(findRef("AWSSDK.Extensions.NETCore.Setup")); }
public BoundLambda(SyntaxNode syntax, BoundBlock body, ImmutableArray <Diagnostic> diagnostics, Binder binder, TypeSymbol delegateType, bool inferReturnType) : this(syntax, (LambdaSymbol)binder.ContainingMemberOrLambda, body, diagnostics, binder, delegateType) { if (inferReturnType) { this._inferredReturnType = InferReturnType( this.Body, this.Binder, delegateType, this.Symbol.IsAsync, ref this._inferredReturnTypeUseSiteDiagnostics, out this._refKind, out this._inferredFromSingleType); #if DEBUG _hasInferredReturnType = true; #endif } Debug.Assert( syntax.IsAnonymousFunction() || // lambda expressions syntax is ExpressionSyntax && LambdaUtilities.IsLambdaBody(syntax, allowReducedLambdas: true) || // query lambdas LambdaUtilities.IsQueryPairLambda(syntax) // "pair" lambdas in queries ); }
// ReSharper disable once UnusedMember.Global public Stream Run(GeneConfig config, ILambdaContext context) { string snsTopicArn = null; var runLog = new StringBuilder(); try { LogUtilities.UpdateLogger(context.Logger, runLog); LogUtilities.LogLambdaInfo(context, CommandLineUtilities.InformationalVersion); LogUtilities.LogObject("Config", config); LogUtilities.Log(new[] { LambdaUrlHelper.UrlBaseEnvironmentVariableName, LambdaUtilities.SnsTopicKey }); LambdaUtilities.GarbageCollect(); snsTopicArn = LambdaUtilities.GetEnvironmentVariable(LambdaUtilities.SnsTopicKey); config.Validate(); string result = GetGeneAnnotation(config, _saManifestUrl, _saPathPrefix); return(LambdaResponse.Create(config.id, LambdaUrlHelper.SuccessMessage, result)); } catch (Exception e) { return(HandleException(config.id, snsTopicArn, e)); } }
protected override async Task <bool> PerformActionAsync() { var layerVersionArn = this.GetStringValueOrDefault(this.LayerVersionArn, LambdaDefinedCommandOptions.ARGUMENT_LAYER_VERSION_ARN, true); var results = LambdaUtilities.ParseLayerVersionArn(layerVersionArn); var deleteRequest = new DeleteLayerVersionRequest { LayerName = results.Name, VersionNumber = results.VersionNumber }; try { await this.LambdaClient.DeleteLayerVersionAsync(deleteRequest); } catch (Exception e) { throw new LambdaToolsException("Error deleting Lambda layer version: " + e.Message, LambdaToolsException.LambdaErrorCode.LambdaDeleteLayerVersion, e); } this.Logger?.WriteLine($"Deleted version {results.VersionNumber} for layer {results.Name}"); return(true); }
protected internal sealed override IEnumerable <SyntaxNode> GetDescendants(SyntaxNode node) { if (node == _oldRoot || node == _newRoot) { RoslynDebug.Assert(_oldRoot != null); RoslynDebug.Assert(_newRoot != null); RoslynDebug.Assert(_oldRootChild != null); RoslynDebug.Assert(_newRootChild != null); var rootChild = (node == _oldRoot) ? _oldRootChild : _newRootChild; if (HasLabel(rootChild)) { yield return(rootChild); } node = rootChild; } // TODO: avoid allocation of closure foreach (var descendant in node.DescendantNodes(descendIntoChildren: c => !IsLeaf(c) && (c == node || !LambdaUtilities.IsLambdaBodyStatementOrExpression(c)))) { if (!LambdaUtilities.IsLambdaBodyStatementOrExpression(descendant) && HasLabel(descendant)) { yield return(descendant); } } }
public void NETCore_2_1_AllWithTooNewVersionNumber() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest-v2.1.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/NETCore_2_1_AllWithTooNewVersionNumber.xml"); try { LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); Assert.True(true, "Missing LambdaToolsException thrown"); } catch (LambdaToolsException e) { Assert.Contains("which is newer than", e.Message); } projectFile = projectFile.Replace("Microsoft.AspNetCore.All", "Microsoft.AspNetCore.App"); try { LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); Assert.True(true, "Missing LambdaToolsException thrown"); } catch (LambdaToolsException e) { Assert.Contains("which is newer than", e.Message); } }
private IEnumerable <SyntaxNode> EnumerateNonRootChildren(SyntaxNode node) { foreach (var child in node.ChildNodes()) { if (LambdaUtilities.IsLambdaBodyStatementOrExpression(child)) { continue; } if (HasLabel(child)) { yield return(child); } else { foreach (var descendant in child.DescendantNodes(DescendIntoChildren)) { if (HasLabel(descendant)) { yield return(descendant); } } } } }
protected override async Task <bool> PerformActionAsync() { EnsureInProjectDirectory(); // Disable interactive since this command is intended to be run as part of a pipeline. DisableInteractive = true; string projectLocation = this.GetStringValueOrDefault(this.ProjectLocation, CommonDefinedCommandOptions.ARGUMENT_PROJECT_LOCATION, false); string s3Bucket = this.GetStringValueOrDefault(this.S3Bucket, LambdaDefinedCommandOptions.ARGUMENT_S3_BUCKET, true); string s3Prefix = this.GetStringValueOrDefault(this.S3Prefix, LambdaDefinedCommandOptions.ARGUMENT_S3_PREFIX, false); string templatePath = this.GetStringValueOrDefault(this.CloudFormationTemplate, LambdaDefinedCommandOptions.ARGUMENT_CLOUDFORMATION_TEMPLATE, true); string outputTemplatePath = this.GetStringValueOrDefault(this.CloudFormationOutputTemplate, LambdaDefinedCommandOptions.ARGUMENT_OUTPUT_CLOUDFORMATION_TEMPLATE, true); if (!Path.IsPathRooted(templatePath)) { templatePath = Path.Combine(Utilities.DetermineProjectLocation(this.WorkingDirectory, projectLocation), templatePath); } if (!File.Exists(templatePath)) { throw new LambdaToolsException($"Template file {templatePath} cannot be found.", LambdaToolsException.LambdaErrorCode.ServerlessTemplateNotFound); } await Utilities.ValidateBucketRegionAsync(this.S3Client, s3Bucket); string zipArchivePath = null; var configuration = this.GetStringValueOrDefault(this.Configuration, CommonDefinedCommandOptions.ARGUMENT_CONFIGURATION, true); var targetFramework = this.GetStringValueOrDefault(this.TargetFramework, CommonDefinedCommandOptions.ARGUMENT_FRAMEWORK, true); var msbuildParameters = this.GetStringValueOrDefault(this.MSBuildParameters, CommonDefinedCommandOptions.ARGUMENT_MSBUILD_PARAMETERS, false); var disableVersionCheck = this.GetBoolValueOrDefault(this.DisableVersionCheck, LambdaDefinedCommandOptions.ARGUMENT_DISABLE_VERSION_CHECK, false).GetValueOrDefault(); string publishLocation; LambdaPackager.CreateApplicationBundle(this.DefaultConfig, this.Logger, this.WorkingDirectory, projectLocation, configuration, targetFramework, msbuildParameters, disableVersionCheck, out publishLocation, ref zipArchivePath); if (string.IsNullOrEmpty(zipArchivePath)) { return(false); } string s3KeyApplicationBundle; using (var stream = new MemoryStream(File.ReadAllBytes(zipArchivePath))) { s3KeyApplicationBundle = await Utilities.UploadToS3Async(this.Logger, this.S3Client, s3Bucket, s3Prefix, Path.GetFileName(zipArchivePath), stream); } this.Logger.WriteLine($"Updating CloudFormation template to point to application bundle: s3://{s3Bucket}/{s3KeyApplicationBundle}"); var templateBody = File.ReadAllText(templatePath); // Process any template substitutions templateBody = LambdaUtilities.ProcessTemplateSubstitions(this.Logger, templateBody, this.GetKeyValuePairOrDefault(this.TemplateSubstitutions, LambdaDefinedCommandOptions.ARGUMENT_CLOUDFORMATION_TEMPLATE_SUBSTITUTIONS, false), Utilities.DetermineProjectLocation(this.WorkingDirectory, projectLocation)); var transformedBody = LambdaUtilities.UpdateCodeLocationInTemplate(templateBody, s3Bucket, s3KeyApplicationBundle); this.Logger.WriteLine($"Writing updated template: {outputTemplatePath}"); File.WriteAllText(outputTemplatePath, transformedBody); return(true); }
public void FindProjFiles(string projectDirectory) { var logger = new TestToolLogger(); string manifest = LambdaUtilities.LoadPackageStoreManifest(logger, "netcoreapp2.0"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectPath(logger, "netcoreapp2.0", manifest, projectDirectory); Assert.DoesNotContain("error", logger.Buffer.ToLower()); }
public void NETCore_2_0_NotUsingAspNetCore() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/CurrentAspNetCoreReference.xml"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.0", manifest, projectFile); Assert.DoesNotContain("error", logger.Buffer.ToLower()); }
public int Update(T entity, Expression <Func <T, object> >[] properties) { DatabaseContext.Entry(entity).State = System.Data.Entity.EntityState.Unchanged; foreach (var property in properties) { var propertyName = LambdaUtilities.GetExpressionText(property); DatabaseContext.Entry(entity).Property(propertyName).IsModified = true; } return(DatabaseContext.SaveChangesWithoutValidation()); }
/// <summary> /// Executes the package command to create the deployment bundle for the .NET project and returns the path. /// </summary> /// <param name="field"></param> /// <param name="location"></param> /// <returns></returns> /// <exception cref="LambdaToolsException"></exception> private async Task <UpdateResourceResults> PackageDotnetProjectAsync(IUpdateResourceField field, string location) { var command = new Commands.PackageCommand(this.Logger, location, null); command.LambdaClient = this.OriginatingCommand?.LambdaClient; command.S3Client = this.OriginatingCommand?.S3Client; command.IAMClient = this.OriginatingCommand?.IAMClient; command.CloudFormationClient = this.OriginatingCommand?.CloudFormationClient; command.DisableRegionAndCredentialsCheck = true; var outputPackage = GenerateOutputZipFilename(field); command.OutputPackageFileName = outputPackage; command.TargetFramework = LambdaUtilities.DetermineTargetFrameworkFromLambdaRuntime(field.Resource.LambdaRuntime, location); command.LayerVersionArns = field.Resource.LambdaLayers; // If the project is in the same directory as the CloudFormation template then use any parameters // there were specified on the command to build the project. if (IsCurrentDirectory(field.GetLocalPath())) { if (!string.IsNullOrEmpty(this.DefaultOptions.TargetFramework)) { command.TargetFramework = this.DefaultOptions.TargetFramework; } command.Configuration = this.DefaultOptions.Configuration; command.DisableVersionCheck = this.DefaultOptions.DisableVersionCheck; command.MSBuildParameters = this.DefaultOptions.MSBuildParameters; } if (!await command.ExecuteAsync()) { var message = $"Error packaging up project in {location} for CloudFormation resource {field.Resource.Name}"; if (command.LastToolsException != null) { message += $": {command.LastToolsException.Message}"; } throw new LambdaToolsException(message, ToolsException.CommonErrorCode.DotnetPublishFailed); } var results = new UpdateResourceResults() { ZipArchivePath = outputPackage }; if (!string.IsNullOrEmpty(command.NewDotnetSharedStoreValue)) { results.DotnetShareStoreEnv = command.NewDotnetSharedStoreValue; } return(results); }
public void DeployServerlessWithSwaggerWithTemplateSubstitution() { var assembly = this.GetType().GetTypeInfo().Assembly; var fullPath = Path.GetFullPath(Path.GetDirectoryName(assembly.Location) + "../../../../../../test/Amazon.Lambda.Tools.Test/TestFiles/testtemplate.yaml"); var template = File.ReadAllText(fullPath); //Does not throw an error when parsing template var updateTemplateBody = LambdaUtilities.UpdateCodeLocationInYamlTemplate(template, S3_BUCKET, S3_OBJECT); }
public BoundLambda(SyntaxNode syntax, UnboundLambda unboundLambda, BoundBlock body, ImmutableArray <Diagnostic> diagnostics, Binder binder, TypeSymbol delegateType, InferredLambdaReturnType inferredReturnType) : this(syntax, unboundLambda, (LambdaSymbol)binder.ContainingMemberOrLambda, body, diagnostics, binder, delegateType) { InferredReturnType = inferredReturnType; Debug.Assert( syntax.IsAnonymousFunction() || // lambda expressions syntax is ExpressionSyntax && LambdaUtilities.IsLambdaBody(syntax, allowReducedLambdas: true) || // query lambdas LambdaUtilities.IsQueryPairLambda(syntax) // "pair" lambdas in queries ); }
public void NETCore_2_1_AllWithSupportedVersionNumber() { var logger = new TestToolLogger(); var manifest = File.ReadAllText(@"ManifestTestFiles/SampleManifest-v2.1.xml"); var projectFile = File.ReadAllText(@"ManifestTestFiles/NETCore_2_1_AllWithSupportedVersionNumber.xml"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); projectFile = projectFile.Replace("Microsoft.AspNetCore.All", "Microsoft.AspNetCore.App"); LambdaUtilities.ValidateMicrosoftAspNetCoreAllReferenceFromProjectContent(logger, "netcoreapp2.1", manifest, projectFile); }
public void ValidateCompatibleLambdaRuntimesAndTargetFrameworks() { // Validate that newer versions of the framework then what the current and possible future lambda runtimes throw an error. LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore1.0", "netcoreapp1.0"); LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore1.1", "netcoreapp1.0"); LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore1.1", "netcoreapp1.1"); LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore2.0", "netcoreapp1.0"); Assert.Throws(typeof(LambdaToolsException), (() => LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore1.0", "netcoreapp1.1"))); Assert.Throws(typeof(LambdaToolsException), (() => LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore1.0", "netcoreapp2.0"))); Assert.Throws(typeof(LambdaToolsException), (() => LambdaUtilities.ValidateTargetFrameworkAndLambdaRuntime("dotnetcore1.1", "netcoreapp2.0"))); }
public void Convert31SDKWebProjectToManifest() { var originalContent = "<Project Sdk=\"Microsoft.NET.Sdk.Web\"></Project>"; var result = LambdaUtilities.ConvertManifestContentToSdkManifest("netcoreapp3.1", originalContent); Assert.True(result.Updated); Assert.Contains("<Project Sdk=\"Microsoft.NET.Sdk\">", result.UpdatedContent); Assert.Contains("<PackagesToPrune Include=\"Microsoft.CSharp\" />", result.UpdatedContent); Assert.Contains("Microsoft.AspNetCore.App", result.UpdatedContent); }
public void ReplaceServerlessApiCodeLocation() { var updateTemplateBody = LambdaUtilities.UpdateCodeLocationInTemplate(SERVERLESS_FUNCTION, S3_BUCKET, S3_OBJECT); var root = new Deserializer().Deserialize(new StringReader(updateTemplateBody)) as IDictionary <object, object>; var resources = root["Resources"] as IDictionary <object, object>; var resource = resources["TheServerlessFunction"] as IDictionary <object, object>; var properties = resource["Properties"] as IDictionary <object, object>; Assert.Equal(S3_URL, properties["CodeUri"]); }
public void SubstituteNullString() { var templateBody = "{'Name':'test', 'Data' : {'MyString': null}}"; var swapData = "100"; var substitutions = new Dictionary <string, string> { { "$.Data.MyString", swapData } }; Assert.Throws <LambdaToolsException>(() => LambdaUtilities.ProcessTemplateSubstitions(null, templateBody, substitutions, null)); }
protected override int ExecuteDockerBuild(DockerCLIWrapper dockerCli, string dockerBuildWorkingDirectory, string fullDockerfilePath, string dockerImageTag, string dockerBuildOptions) { var architecture = this.GetStringValueOrDefault(this.Architecture, LambdaDefinedCommandOptions.ARGUMENT_FUNCTION_ARCHITECTURE, false); var arm64Build = false; if (string.Equals(LambdaConstants.RUNTIME_LINUX_ARM64, LambdaUtilities.DetermineRuntimeParameter(null, architecture))) { arm64Build = true; } return(dockerCli.Build(dockerBuildWorkingDirectory, fullDockerfilePath, dockerImageTag, dockerBuildOptions, arm64Build)); }
protected override async Task <bool> PerformActionAsync() { var layerVersionArn = this.GetStringValueOrDefault(this.LayerVersionArn, LambdaDefinedCommandOptions.ARGUMENT_LAYER_VERSION_ARN, true); var result = LambdaUtilities.ParseLayerVersionArn(layerVersionArn); var getRequest = new GetLayerVersionRequest { LayerName = result.Name, VersionNumber = result.VersionNumber }; try { var response = await this.LambdaClient.GetLayerVersionAsync(getRequest); this.Logger.WriteLine("Layer ARN:".PadRight(PAD_SIZE) + response.LayerArn); this.Logger.WriteLine("Version Number:".PadRight(PAD_SIZE) + response.Version); this.Logger.WriteLine("Created:".PadRight(PAD_SIZE) + DateTime.Parse(response.CreatedDate).ToString("g")); this.Logger.WriteLine("License Info:".PadRight(PAD_SIZE) + response.LicenseInfo); this.Logger.WriteLine("Compatible Runtimes:".PadRight(PAD_SIZE) + string.Join(", ", response.CompatibleRuntimes.ToArray())); LayerDescriptionManifest manifest; if (!LambdaUtilities.AttemptToParseLayerDescriptionManifest(response.Description, out manifest)) { this.Logger.WriteLine("Description:".PadRight(PAD_SIZE) + response.Description); } else { switch (manifest.Nlt) { case LayerDescriptionManifest.ManifestType.RuntimePackageStore: this.Logger.WriteLine("Layer Type:".PadRight(PAD_SIZE) + LambdaConstants.LAYER_TYPE_RUNTIME_PACKAGE_STORE_DISPLAY_NAME); await GetRuntimePackageManifest(manifest); break; default: this.Logger.WriteLine("Layer Type:".PadRight(PAD_SIZE) + manifest.Nlt); break; } } } catch (Exception e) { throw new LambdaToolsException("Error getting layer version details: " + e.Message, LambdaToolsException.LambdaErrorCode.LambdaGetLayerVersionDetails, e); } return(true); }
public void CheckIfWebProject() { var originalContent = "<Project Sdk=\"Microsoft.NET.Sdk.Web\"></Project>"; var result = LambdaUtilities.ConvertManifestContentToSdkManifest("netcoreapp2.1", originalContent); Assert.True(result.Updated); Assert.False(object.ReferenceEquals(originalContent, result.UpdatedContent)); originalContent = "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"; result = LambdaUtilities.ConvertManifestContentToSdkManifest("netcoreapp2.1", "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>"); Assert.False(result.Updated); Assert.True(object.ReferenceEquals(originalContent, result.UpdatedContent)); }