public static async Task <LayerPackageInfo> LoadLayerPackageInfos(IToolLogger logger, IAmazonLambda lambdaClient, IAmazonS3 s3Client, IEnumerable <string> layerVersionArns)
        {
            var info = new LayerPackageInfo();

            if (layerVersionArns == null || !layerVersionArns.Any())
            {
                return(info);
            }

            logger.WriteLine("Inspecting Lambda layers for runtime package store manifests");
            foreach (var arn in layerVersionArns)
            {
                try
                {
                    var p = ParseLayerVersionArn(arn);
                    var getLayerResponse = await lambdaClient.GetLayerVersionAsync(new GetLayerVersionRequest { LayerName = p.Name, VersionNumber = p.VersionNumber });

                    LayerDescriptionManifest manifest;
                    if (!LambdaUtilities.AttemptToParseLayerDescriptionManifest(getLayerResponse.Description, out manifest))
                    {
                        logger.WriteLine($"... {arn}: Skipped, does not contain a layer description manifest");
                        continue;
                    }
                    if (manifest.Nlt != LayerDescriptionManifest.ManifestType.RuntimePackageStore)
                    {
                        logger.WriteLine($"... {arn}: Skipped, layer is of type {manifest.Nlt.ToString()}, not {LayerDescriptionManifest.ManifestType.RuntimePackageStore}");
                        continue;
                    }

                    string filePath = Path.GetTempFileName();
                    using (var getResponse = await s3Client.GetObjectAsync(manifest.Buc, manifest.Key))
                        using (var reader = new StreamReader(getResponse.ResponseStream))
                        {
                            await getResponse.WriteResponseStreamToFileAsync(filePath, false, default(System.Threading.CancellationToken));
                        }

                    logger.WriteLine($"... {arn}: Downloaded package manifest for runtime package store layer");
                    info.Items.Add(new LayerPackageInfo.LayerPackageInfoItem
                    {
                        Directory    = manifest.Dir,
                        ManifestPath = filePath
                    });
                }
                catch (Exception e)
                {
                    logger.WriteLine($"... {arn}: Skipped, error inspecting layer. {e.Message}");
                }
            }

            return(info);
        }
 private Amazon.Lambda.Model.GetLayerVersionResponse CallAWSServiceOperation(IAmazonLambda client, Amazon.Lambda.Model.GetLayerVersionRequest request)
 {
     Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "AWS Lambda", "GetLayerVersion");
     try
     {
         #if DESKTOP
         return(client.GetLayerVersion(request));
         #elif CORECLR
         return(client.GetLayerVersionAsync(request).GetAwaiter().GetResult());
         #else
                 #error "Unknown build edition"
         #endif
     }
     catch (AmazonServiceException exc)
     {
         var webException = exc.InnerException as System.Net.WebException;
         if (webException != null)
         {
             throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
         }
         throw;
     }
 }