dev

Author: Robinson Aizprua

src/GOC.ApiGateway/AppSettings.cs

@@ -30,13 +30,21 @@ public class IdentitySettings
     {
         public string Authority { get; set; }
         public string ApiName { get; set; }
-        public string ApiSecret { get; set; }
-        public IList<DownstreamClient> DownstreamClients { get; set; }
-    }
+        public string ApiSecret { get; set; }
+        public string TokenEndpoint { get; set; }
+
+        public string TokenEndpointUrl
+        {
+            get => $"{Authority}/{TokenEndpoint}";
+        }
+        public IList<DownstreamClient> DownstreamClients { get; set; }
+    }
+    //TODO do this in json config file
     public class DownstreamClient
     {
-        public string ApiName { get; set; }
-        public string ApiSecret { get; set; }
+        public string ClientId { get; set; }
+        public string ClientSecret { get; set; }
+        public string ResourceName { get; set; }
     }
     public class RabbitMQSettings
     {

src/GOC.ApiGateway/Controllers/BaseController.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace GOC.ApiGateway.Controllers
+{
+    public class BaseController : Controller
+    {
+
+    }
+}

src/GOC.ApiGateway/Controllers/ValuesController.cs

@@ -1,24 +1,21 @@
-using System;
-using System.Net.Http;
-using System.Threading.Tasks;
-using EasyNetQ;
-using GOC.ApiGateway.Interfaces;
-using IdentityModel.Client;
+using GOC.ApiGateway.Interfaces;
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 
 namespace GOC.ApiGateway.Controllers
 {
     [Route("api/[controller]")]
-    //[Authorize]
-    public class ValuesController : Controller
+    [Authorize]
+    public class ValuesController : BaseController
     {
         private readonly IInventoryService _service;
 
-        public ValuesController(IInventoryService service, IBus bus, IGocHttpBasicClient http)
-        {
+        public ValuesController(IInventoryService service, IGocHttpClient k)
+        {
             _service = service;
-        }
+        }
+
         // GET api/values
         [HttpGet]
         public IActionResult Get()

src/GOC.ApiGateway/GOC.ApiGateway.csproj

@@ -9,6 +9,7 @@
     <Folder Include="wwwroot\" />
     <Folder Include="Services\" />
     <Folder Include="Handlers\" />
+    <Folder Include="Repositories\InventoryService\" />
   </ItemGroup>
 
   <ItemGroup>

src/GOC.ApiGateway/Interfaces/IGocHttpClient.cs

@@ -1,6 +1,6 @@
 namespace GOC.ApiGateway
 {
-    public interface IGocHttpBasicClient
+    public interface IGocHttpClient
     {
     }
 }

src/GOC.ApiGateway/Program.cs

@@ -13,7 +13,7 @@ public static void Main(string[] args)
         public static IWebHost BuildWebHost(string[] args) =>
             WebHost.CreateDefaultBuilder(args)
                    .UseStartup<Startup>()
-                   .UseUrls("http://*:5001")
+                   .UseUrls("http://*:5060")
                 .Build();
     }
 }

src/GOC.ApiGateway/Repositories/HttpClientWrapper.cs

@@ -1,23 +1,22 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using IdentityModel.Client;
 
 namespace GOC.ApiGateway
 {
-    public class HttpClientWrapper : IGocHttpBasicClient
+    public class HttpClientWrapper : IGocHttpClient
     {
         private readonly HttpClient _httpClient;
         private readonly Func<string, string, Uri> _relativeUriResolver;
-        private readonly Action<HttpRequestMessage> _httpRequestMessageDecorator;
+        private IHttpTokenAuthorizationContext _authContext { get; set; }
 
-        public HttpClientWrapper(HttpClient client, Func<string, string, Uri> serviceUriResolver = null, Action<HttpRequestMessage> httpRequestMessageDecorator = null)
+        public HttpClientWrapper(HttpClient client, IHttpTokenAuthorizationContext authContext,Func<string, string, Uri> serviceUriResolver = null)
         {
+            _authContext = authContext;
             _httpClient = client;
             _relativeUriResolver = serviceUriResolver ?? ((sn, s) => new Uri(s));
-            _httpRequestMessageDecorator = httpRequestMessageDecorator ?? (m => { });
         }
 
         /// <summary>
@@ -32,19 +31,39 @@ public Uri ResolveRelativeUri(string serviceName, string relativeUri)
             return _relativeUriResolver(serviceName, relativeUri);
         }
 
-        public async Task<HttpResponseMessage> GetAsync(string serviceName, string relativeUri, CancellationToken cancellationToken)
+        public async Task<HttpResponseMessage> GetAsync(string serviceName, DownstreamClient downstreamClient, string relativeUri, CancellationToken cancellationToken)
         {
+            await SetAccessToken(downstreamClient);
             var request = CreateRequestMessage(HttpMethod.Get, serviceName, relativeUri);
             return await _httpClient.SendAsync(request, cancellationToken);
         }
 
-        private HttpRequestMessage CreateRequestMessage(HttpMethod method, string serviceName, string relativeUri)
+        HttpRequestMessage CreateRequestMessage(HttpMethod method, string serviceName, string relativeUri)
         {
             var uri = _relativeUriResolver.Invoke(serviceName, relativeUri);
             var request = new HttpRequestMessage(method, uri);
-            _httpRequestMessageDecorator.Invoke(request);
             return request;
         }
 
+        async Task SetAccessToken(DownstreamClient downstreamClient)
+        {
+            var delegateToken = await DelegateAsync(_authContext.AccessToken, downstreamClient.ClientId, downstreamClient.ClientSecret, downstreamClient.ResourceName);
+            _httpClient.SetBearerToken(delegateToken.AccessToken);
+        }
+
+        async Task<TokenResponse> DelegateAsync(string userToken, string clientId, string clientSecret, string resourceName)
+        {
+            var payload = new
+            {
+                token = userToken
+            };
+
+            // create token client
+            var client = new TokenClient(Startup.AppSettings.Identity.TokenEndpointUrl, clientId, clientSecret);
+
+            // send custom grant to token endpoint, return response
+            return await client.RequestCustomGrantAsync("delegation", resourceName, payload);
+        }
+
     }
 }

src/GOC.ApiGateway/Repositories/RepositoryBase.cs

@@ -0,0 +1,11 @@
+using GOC.ApiGateway;
+
+public class RespositoryBase
+{
+    protected readonly IGocHttpClient Client;
+
+    public RespositoryBase(IGocHttpClient client)
+    {
+        Client = client;
+    }
+}

src/GOC.ApiGateway/Startup.cs

@@ -37,18 +37,19 @@ public Startup(IHostingEnvironment env)
 
             Configuration = builder.Build();
             AppSettings = Configuration.GetSection("ApiGateWay").Get<AppSettings>();
-
+            //TODO do this somehow in json config file
             var downstreamClients = new List<DownstreamClient>
             {
                 new DownstreamClient
                 {
-                    ApiName = "api1.client",
-                    ApiSecret = "api1.client-secret"
+                    ClientId = "api1.client",
+                    ClientSecret = "api1.client-secret",
+                    ResourceName = "api2"
                 }
             };
             AppSettings.Identity.DownstreamClients = downstreamClients;
         }
-        public  static AppSettings   AppSettings { get; set; }
+        public  static AppSettings   AppSettings { get; private set; }
         public IConfiguration Configuration { get; }
         private Container Container { get; } = new Container();
         private ILoggerFactory LoggerFactory { get; set; }
@@ -143,7 +144,7 @@ protected void InitializeContainer(IApplicationBuilder app)
 
             // message bus registration
             Container.Register<IBus>(() => RabbitHutch.CreateBus($"host={AppSettings.Rabbit.Host}"), Lifestyle.Singleton);
-
+            Container.Register<IHttpContextAccessor, HttpContextAccessor>(Lifestyle.Scoped);
             Container.CrossWire<ILoggerFactory>(app);
             Container.Verify();
 
@@ -166,41 +167,24 @@ private void RegisterCustomHttpClient(IApplicationBuilder app)
             }, Lifestyle.Scoped);
 
             var consulUriResolverRegistration = Lifestyle.Singleton.CreateRegistration<Func<string, string, Uri>>(
-                () => (serviceName, relativeUri) => Cluster.Client.ResolveUri(serviceName, relativeUri), Container);
-
-            var httpMessageDecoratorRegistration =
-                Lifestyle.Singleton.CreateRegistration<Action<HttpRequestMessage>>(
-                    () => m =>
-                    {
-                        var authorizationContext = Container.GetInstance<IHttpTokenAuthorizationContext>();
-                        void SetBearerToken(string t) => m.Headers.Add("Authorization", $"Bearer {t}");
-
-                        if (authorizationContext.BearerTokens.Any())
-                        {
-                            SetBearerToken(authorizationContext.BearerTokens.First());
-                        }
-                        else if (!String.IsNullOrEmpty(authorizationContext.AccessToken))
-                        {
-                            SetBearerToken(authorizationContext.AccessToken);
-                        }
-                    }, Container);
-
+                () => (serviceName, relativeUri) => Cluster.Client.ResolveUri(serviceName, relativeUri), Container);
+
+           
             var gocHttpClientRegistration = Lifestyle.Singleton.CreateRegistration(() => new HttpClient(), Container);
 
 
             Container.RegisterConditional(serviceType: typeof(HttpClient), 
                                           registration: gocHttpClientRegistration,
-                                          predicate: c => c.Consumer.ImplementationType.GetInterface(nameof(IGocHttpBasicClient)) != null);
+                                          predicate: c => c.Consumer.ImplementationType.GetInterface(nameof(IGocHttpClient)) != null);
 
             void RegisterHttpClient(Type type, Registration registration) => Container.RegisterConditional(serviceType: type, 
                                                                                                            registration: registration, 
                                                                                                            predicate: context => 
                                                                                                            context.Consumer.ImplementationType == typeof(HttpClientWrapper));
 
             RegisterHttpClient(typeof(Func<string, string, Uri>), consulUriResolverRegistration);
-            RegisterHttpClient(typeof(Action<HttpRequestMessage>), httpMessageDecoratorRegistration);
 
-            Container.Register<IGocHttpBasicClient, HttpClientWrapper>(Lifestyle.Scoped);
+            Container.Register<IGocHttpClient, HttpClientWrapper>(Lifestyle.Scoped);
         }
 
         private async Task<IEnumerable<string>> BearerTokenAccessor(HttpContext context)

src/GOC.ApiGateway/appsettings.json

@@ -18,7 +18,8 @@
     "Identity" :  {
       "Authority": "http://vagrant:5000",
       "ApiName": "api1",
-      "ApiSecret": "api1-secret"
+      "ApiSecret": "api1-secret",
+      "TokenEndpoint": "connect/token"
     },
     "Rabbit": {
       "Host": "vagrant"