Debugging in Visual Studio about terraformplugindotnet HOT 5 CLOSED

  "AppSettings": {
    "PortNumber": 5000,
    "DebugMode":  true
  }

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Serilog;
using TerraformPluginDotNet.ResourceProvider;

namespace TerraformPluginDotNet
{
    public class Program
    {
        public static X509Certificate2 Cert { get; private set; }

        public static void Run(string[] args, Action<IServiceCollection, TerraformConstructRegistry> configure)
        {
            Cert = CertificateGenerator.GenerateSelfSignedCertificate("CN=127.0.0.1", "CN=root ca", CertificateGenerator.GeneratePrivateKey());

            var appSettings = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true)
                .Build();

            Log.Logger = new LoggerConfiguration()
                .ReadFrom.Configuration(appSettings)
                .CreateLogger();

            try
            {
                CreateHostBuilder(args, appSettings, configure).Build().Run();
            }
            catch (Exception ex)
            {
                Log.Logger.Fatal(ex, "Fatal error occurred.");
                Environment.Exit(1);
            }
            finally
            {
                Log.Logger.Information("Application terminated.");
                Log.CloseAndFlush();
            }
        }

        public static IHostBuilder CreateHostBuilder(string[] args, IConfiguration appSettings, Action<IServiceCollection, TerraformConstructRegistry> configure) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder
                        .UseConfiguration(appSettings)
                        .ConfigureKestrel(x =>
                        {
                            int portNumber = appSettings.GetValue<int>("AppSettings:PortNumber");
                            bool debugMode = appSettings.GetValue<bool>("AppSettings:DebugMode");

                            // HTTP2.0 required for Terraform 1.0
                            x.ConfigureEndpointDefaults(lo => lo.Protocols = Microsoft.AspNetCore.Server.Kestrel.Core.HttpProtocols.Http2);
                            if (debugMode)
                            {
                                x.ListenLocalhost(portNumber);
                            }
                            else
                            {
                                x.ListenLocalhost(portNumber, x => x.UseHttps(x =>
                                {
                                    x.ServerCertificate = Cert;
                                    x.AllowAnyClientCertificate();
                                }));
                            }
                        })
                        .UseStartup<Startup>()
                        .ConfigureLogging((_, x) => x.ClearProviders().AddSerilog())
                        .ConfigureServices(services =>
                        {
                            var registry = new TerraformConstructRegistry();
                            services.AddSingleton(registry);
                            configure(services, registry);
                        });
                });
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using TerraformPluginDotNet.DataSourceProvider;
using TerraformPluginDotNet.ResourceProvider;
using TerraformPluginDotNet.Serialization;
using TerraformPluginDotNet.Services;

namespace TerraformPluginDotNet
{
    public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddGrpc();

            services.AddTransient(typeof(DataSourceProviderHost<>));
            services.AddTransient(typeof(ResourceProviderHost<>));
            services.AddTransient(typeof(IResourceUpgrader<>), typeof(DefaultResourceUpgrader<>));
            services.AddTransient<IDynamicValueSerializer, DefaultDynamicValueSerializer>();
        }

        public void Configure(IApplicationBuilder app, IHostApplicationLifetime lifetime, IWebHostEnvironment env, ILogger<Startup> logger)
        {
            lifetime.ApplicationStarted.Register(() =>
            {
                logger.LogInformation("Application started.");
                string endPoint = $"127.0.0.1:{Configuration.GetValue<int>("AppSettings:PortNumber")}";
                if (Configuration.GetValue<bool>("AppSettings:DebugMode"))
                {
                    // Need this info so we can connect Terraform in debugging mode
                    Console.WriteLine("Provider started, to attach Terraform set the TF_REATTACH_PROVIDERS env var:\n\n");
                    Console.WriteLine($"SET TF_REATTACH_PROVIDERS={{\"mywebsite.com/mysubdir/terraformdeploy\":{{\"Protocol\":\"grpc\",\"Pid\":{Process.GetCurrentProcess().Id},\"Test\":true,\"Addr\":{{\"Network\":\"tcp\",\"String\":\"{endPoint}\"}}}}}}");
                }
                else
                {
                    Console.WriteLine($"1|5|tcp|{endPoint}|grpc|{Convert.ToBase64String(Program.Cert.RawData)}");
                }
            });

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapGrpcService<Terraform5ProviderService>();

                endpoints.MapGet("/", async context =>
                {
                    await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
                });
            });
        }
    }
}

Provider started, to attach Terraform set the TF_REATTACH_PROVIDERS env var:

SET TF_REATTACH_PROVIDERS={"mywebsite.com/mysubdir/terraformdeploy":{"Protocol":"grpc","Pid":68092,"Test":true,"Addr":{"Network":"tcp","String":"127.0.0.1:5000"}}}

terraform {
  required_providers {
    fusiondeploy = {
      source = "mywebsite.com/mysubdir/terraformdeploy"
      version = "1.0.0"
    }
  }
}