Sprint 5

APIGateway/APIGateway.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="6.0.0" />
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.19.4" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>

APIGateway/Controllers/GatewayController.cs

@@ -1,70 +1,121 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Net.Http;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
-
-using Microsoft.Extensions.Caching.Distributed;
-using System.Text.Json;
+using System.Net.Http.Json;
+using System.Text;
 
 namespace Gateway
 {
+    /// <summary>
+    /// Controller responsible for handling requests and responses at the gateway.
+    /// </summary>
     [ApiController]
     [Route("[controller]")]
     public class GatewayController : ControllerBase
     {
-        private static readonly List<GameInfo> TheInfo = new List<GameInfo>
+        private readonly HttpClient _httpClient; // Making readonly ensures thread safety 
+        private readonly ILogger<GatewayController> _logger; // Making readonly ensures thread safety 
+        private readonly List<GameInfo> TheInfo;
+
+        public GatewayController(HttpClient httpClient, ILogger<GatewayController> logger)
         {
-            new GameInfo { 
-                //Id = 1,
-                Title = "Snake",
-                //Content = "~/js/snake.js",
-                Author = "Fall 2023 Semester",
-                DateAdded = "",
-                Description = "Snake is a classic arcade game that challenges the player to control a snake-like creature that grows longer as it eats apples. The player must avoid hitting the walls or the snake's own body, which can end the game.\r\n",
-                HowTo = "Control with arrow keys.",
-                //Thumbnail = "/images/snake.jpg" //640x360 resolution
-                LeaderBoardStack = new Stack<KeyValuePair<string, int>>(),
+            _httpClient = httpClient;
+            _logger = logger;
+            TheInfo = new List<GameInfo>();
+        }
 
-    },
-            new GameInfo { 
-                //Id = 2,
-                Title = "Tetris",
-                //Content = "~/js/tetris.js",
-                Author = "Fall 2023 Semester",
-                DateAdded = "",
-                Description = "Tetris is a classic arcade puzzle game where the player has to arrange falling blocks, also known as Tetronimos, of different shapes and colors to form complete rows on the bottom of the screen. The game gets faster and harder as the player progresses, and ends when the Tetronimos reach the top of the screen.",
-                HowTo = "Control with arrow keys: Up arrow to spin, down to speed up fall, space to insta-drop.",
-                //Thumbnail = "/images/tetris.jpg"
-                LeaderBoardStack = new Stack<KeyValuePair<string, int>>(),
-
-            },
-            new GameInfo { 
-                //Id = 3,
-                Title = "Pong",
-                //Content = "~/js/pong.js",
-                Author = "Fall 2023 Semester",
-                DateAdded = "",
-                Description = "Pong is a classic arcade game where the player uses a paddle to hit a ball against a computer's paddle. Either party scores when the ball makes it past the opponent's paddle.",
-                HowTo = "Control with arrow keys.",
-                //Thumbnail = "/images/pong.jpg"
-                LeaderBoardStack = new Stack<KeyValuePair<string, int>>(),
-            },
+        /// <summary>
+        /// Handles GET requests to retrieve game information from microservices.
+        /// </summary>
+        /// <returns>A collection of GameInfo objects.</returns>
+        [HttpGet]
+        public async Task<IEnumerable<GameInfo>> Get()
+        {
+            try
+            {
+                var SnakeTask = AddGameInfo("https://localhost:1948", "/Snake" ); //Snake 
+                var Tetristask = AddGameInfo("https://localhost:2626", "/Tetris"); //Tetris
+                var PongTask = AddGameInfo("https://localhost:1941", "Pong"); //Pong
+                await Task.WhenAll(SnakeTask, Tetristask, PongTask);
+                return TheInfo;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"An error occurred while fetching data from microservice: {ex.Message}");
+                // Return a placeholder list of GameInfo objects indicating failure
+                return GenerateFailureResponse();
+            }
+        }
 
-        };
+         /// <summary>
+         /// Attempts to retrieve gameinfo object from a microservice that holds a game info object (snake, tetris, pong)
+         /// and adds the game info into a list of game info objects
+         /// </summary>
+         /// <param name="gameinfolist"></param>
+         /// <param name="baseUrl"></param>
+         /// <param name="endpoint"></param>
+         /// <returns></returns>
+         [ApiExplorerSettings(IgnoreApi = true)]
+        public async Task AddGameInfo(string baseUrl, string endpoint)
+        {
+            try
+            {
+                using var client = new HttpClient();
+                //Set the base address of the microservice 
+                client.BaseAddress = new Uri(baseUrl);
 
-        private readonly ILogger<GatewayController> _logger;
+                //Read the data from the endpoint 
+                HttpResponseMessage response = await client.GetAsync(endpoint);
 
-        public GatewayController(ILogger<GatewayController> logger)
-        {
-            _logger = logger;
+                // Check if the request was successful
+                if (response.IsSuccessStatusCode)
+                {
+                    // Deserialize the response content to a GameInfo object
+                    var gameinfo = await response.Content.ReadAsAsync<List<GameInfo>>();
+                    //Add object to list
+                    lock (TheInfo)
+                    {
+                        TheInfo.AddRange(gameinfo);
+                    }
+                }
+                else
+                {
+                    _logger.LogError($"Failed to retrieve data from microservice at endpoint {endpoint}. Status code: {response.StatusCode}");
+                }
+
+            }
+            catch (Exception ex) //Log error and return false if any exception occurs
+            { 
+                _logger.LogError(ex.Message);
+            }
         }
 
-        [HttpGet]
-        public IEnumerable<GameInfo> Get()
+        /// <summary>
+        /// Generates a placeholder list of GameInfo objects indicating failure to retrieve data.
+        /// Written with ChatGPT
+        /// </summary>
+        /// <returns>A collection of GameInfo objects indicating failure.</returns>
+        private IEnumerable<GameInfo> GenerateFailureResponse()
         {
-            return TheInfo;
+            // Using IEnumerable allows flexibility in returning a placeholder response.
+            // It allows the method to return different types of collections (e.g., List, Array) if needed in the future.
+            // In this case, IEnumerable provides a simple way to return a list of failed responses.
+
+            // Generate a placeholder list of GameInfo objects indicating failure to retrieve data
+            return new List<GameInfo>
+            {
+                new GameInfo
+                {
+                    Title = "Failed to retrieve from Microservice",
+                    Author = "Failed to retrieve from Microservice",
+                    Description = "Failed to retrieve from Microservice",
+                    HowTo = "Failed to retrieve from Microservice",
+                    LeaderBoardStack = new Stack<KeyValuePair<string, int>>() // Initializing an empty stack
+                }
+            };
         }
     }
-}
+}

APIGateway/Dockerfile

@@ -7,16 +7,16 @@ EXPOSE 443
 
 FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
 WORKDIR /src
-COPY ["GameMicroServer/GameMicroServer.csproj", "GameMicroServer/"]
-RUN dotnet restore "GameMicroServer/GameMicroServer.csproj"
+COPY ["APIGateway/APIGateway.csproj", "APIGateway/"]
+RUN dotnet restore "APIGateway/APIGateway.csproj"
 COPY . .
-WORKDIR "/src/GameMicroServer"
-RUN dotnet build "GameMicroServer.csproj" -c Release -o /app/build
+WORKDIR "/src/APIGateway"
+RUN dotnet build "APIGateway.csproj" -c Release -o /app/build
 
 FROM build AS publish
-RUN dotnet publish "GameMicroServer.csproj" -c Release -o /app/publish /p:UseAppHost=false
+RUN dotnet publish "APIGateway.csproj" -c Release -o /app/publish /p:UseAppHost=false
 
 FROM base AS final
 WORKDIR /app
 COPY --from=publish /app/publish .
-ENTRYPOINT ["dotnet", "GameMicroServer.dll"]
+ENTRYPOINT ["dotnet", "APIGateway.dll"]

APIGateway/GameInfo.cs

@@ -2,11 +2,14 @@
 {
     public class GameInfo
     {
+        public int Id { get; set; }
         public string Title { get; set; }
         public string Author { get; set; }
+        public string Content { get; set; }
         public string Description { get; set; }
         public string DateAdded { get; set; }
         public string HowTo { get; set; }
+        public string Thumbnail { get; set; }
         public Stack<KeyValuePair<string, int>> LeaderBoardStack { get; set; }
     }
 }

APIGateway/Program.cs

@@ -7,6 +7,16 @@
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
+// Register HttpClient
+builder.Services.AddHttpClient();
+
+// This creates the timestamp for the logger.
+builder.Logging.AddSimpleConsole(options =>
+{
+    options.IncludeScopes = true;
+    options.TimestampFormat = "yyyy-MM-dd HH:mm:ss ";
+});
+
 var app = builder.Build();
 
 // Configure the HTTP request pipeline.

APIGateway/Properties/launchSettings.json

@@ -8,7 +8,7 @@
         "ASPNETCORE_ENVIRONMENT": "Development"
       },
       "dotnetRunMessages": true,
-      "applicationUrl": "https://localhost:7223;http://localhost:5130"
+      "applicationUrl": "https://localhost:4141"
     },
     "IIS Express": {
       "commandName": "IISExpress",

README.md

@@ -1,21 +1,17 @@
-# GameMicroService
-### A Team Bobby Project
+# APIGateway
+### A Team [Redacted] Project
 ### Members:
-> Isaac Camacho, Richard Cashion, Dylan Cowell, Thomas Foreman,
-> Dionte Jones, Matt Justis, Jacob Klucher, Dylan Lynch, 
-> Caleb Rains, Chris Seals, Kyle Wittman
+> Kurt Brewer, Josh Rucevice, Charlie Shahan, Ethan Webb, Ethan Hensley, Patrick Vergason, Bryson Brandon
 #### CSCI 4350
-#### Fall 2023, East Tennessee State University
+#### Spring 2024, East Tennessee State University
 
 ### Overview:
-This is a microservice that returns game info in JSON format to the [BOBBY Project](https://github.com/chrisseals98/BOBBY).
+This is the API Gateway that requests and queries from the main website, routed through a single entry-point to the [[Redacted] Project Tetris, Snake, and Pong].
 
 ### Project Structure:
-* The application handles HTTP calls in the microController.cs file in the /GameMicroServer/Controllers directory.
-* It only handles an HTTP Get call to the path /Micro. So if the application was running locally, you would call [http://localhost/Micro](http://localhost/Micro).
-* This application is deployed alongside the BucStop project with docker compose, see [BOBBY Project](https://github.com/chrisseals98/BOBBY) for more details.
+* This API Gateway acts as a middle-man to facilitate interaction between the BucStop main site and the Microservice(s).
+* This architecture was set up with scalability in mind, and to allow the site to function at full capacity regardless of the number of microservices it employs.
 
 ### Help
 For more documentation on how to run locally and how to set up deployments, see the google docs below:
-* [Running Locally](https://docs.google.com/document/d/1gfUpjZNfqWyv1ohUW1IaS8fOhXp0hOx6tFQVXBADa8Q/edit?usp=sharing)
-* [How to Deploy](https://docs.google.com/document/d/1i0edcmvZm_j0zQLYiigNliW39FJuJbmhkxOCCb2NbVs/edit?usp=sharing)
+* [UNDER CONSTRUCTION]