Fix/suprctbl no output (#52)

* Updated Makefile

Kind of want to update that deployment to properly use watchtower`

* Fixed No File Output

- Updated Makefile command for shelling intno the web app
- Fixed No Output Issue. The issue happened because users would do
  `slopFile=dpronsbl_ree`, but we forgot to copy over dpronsbl_ree into
the job directory. That would literally ensure that any request with
dpronsbl_ree wouldn't output any files. Anyways that was a simple fix.
- Also added logging

* Added formatting and linting

- Updated Makefile to include formatting and linting scripts.
- Formatted and linted the code.
- `rate_calc.py`: Commented out some variables that were literally
  unaccessed/unused. Maintains functionality whilst helping out the
style a bit.

* Updated glob package to fix security issue

glob library had a big security issue so we had to update it.

* Updated stack.yml poll time

Updated back to 5 minutes.

* Logging in auth.py

Saw that auth.py had its own logger defined, so we just used our app
logger instead.

Author: Knguyen-dev

Makefile

@@ -7,6 +7,10 @@ TAG=latest
 
 .PHONY: up down restart logs frontend deploy build
 
+
+## -----------------------------------------------
+# Running app in dev + Debugging with logs and shell
+## -----------------------------------------------
 # Run the app in development env
 up:
 	@echo "Building the project..."
@@ -27,23 +31,45 @@ logs:
 
 # For running execing into the dev container
 shell:
-	@docker exec -it $(shell docker ps -q -f "name=$(PROJECT_NAME)") /bin/sh
+	@docker compose -f $(COMPOSE_FILE) exec web /bin/bash
 
 # Run the react app only; good for when you just need to develop the frontend.
 frontend:
 	@echo "Building the frontend..."
 	@cd frontend && npm install && npm run dev
 
-format:
-	@echo "Formatting the code"
-	@cd frontend && npm run format
-	@cd backend && uv run ruff format
-
+## -----------------------------------------------
+# Commands for starting up or shutting down prod
+## -----------------------------------------------
 build:
 	@echo "Building the project..."
 	@cd frontend && npm install && npm run build
 	@docker build -t $(IMAGE_NAME):$(TAG) .
 
 # Expect a wait about 5 seconds for the replicas to be created after you run the command
 deploy: build
-	@docker stack deploy -c $(STACK_FILE) $(STACK_NAME)
+	docker stack deploy -c $(STACK_FILE) $(STACK_NAME)
+
+# Remove stack
+remove:
+	docker stack rm $(STACK_NAME)
+
+# Redeploy the stack
+redeploy: remove deploy
+
+# View the logs of a service 
+# e.g. make stack-logs SERVICE=watchtower
+stack-logs:
+	docker service logs -f $(STACK_NAME)_$(SERVICE)
+
+## -----------------------------------------------
+# Linting and Formatting
+## -----------------------------------------------
+format:
+	@cd backend && uv run ruff format .
+	@cd frontend && npm run format
+
+# Checks for and fixes simple linting errors
+lint:
+	@cd backend && uv run ruff check --fix .
+	@cd frontend && npm run lint

backend/app/config.py

@@ -1,6 +1,5 @@
 import os
 from pydantic_settings import BaseSettings
-from typing import Optional
 
 
 class Settings(BaseSettings):

backend/app/db/database.py

@@ -3,7 +3,6 @@
 import pymysql
 from sqlmodel import create_engine, Session, text
 from contextlib import contextmanager
-import time
 import urllib.parse
 
 # Configure logging

backend/app/routes/auth.py

@@ -1,21 +1,17 @@
 from starlette.responses import RedirectResponse
 from fastapi import Request, Response, APIRouter
-import os, requests
-import logging
+import os
+import requests
 from sqlalchemy.exc import SQLAlchemyError
 from sqlmodel import select
 from app.db import User, get_session
-from datetime import datetime
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+from app.services.logger import app_logger
 
 router = APIRouter()
 
 
 @router.get("/auth", tags=["auth"])
-async def auth_me():
+async def auth_redirect():
   """
   Redirect for OIDC authentication.
   """
@@ -74,7 +70,7 @@ async def auth_callback(code: str):
             if db_user and db_user.archived == 1:
               # User is archived, do not log in
               return RedirectResponse(url="/?alert=archived_user")
-        except Exception as e:
+        except Exception:
           # Optionally handle DB errors
           return RedirectResponse(url="/?alert=database_error")
 
@@ -128,7 +124,7 @@ async def auth_me(request: Request, response: Response):
       timeout=2,
     )
   except requests.exceptions.RequestException as e:
-    logger.error(f"Failed to fetch user info: {e}")
+    app_logger.exception(f"Failed to fetch user info. Clearing access token cookie!")
     response.delete_cookie("access_token")
     return {
       "status": "failure",
@@ -138,7 +134,7 @@ async def auth_me(request: Request, response: Response):
 
   if user_info_response.status_code == 200:
     try:
-      logger.info("User info response received successfully")
+      # app_logger.info("User info response received successfully")
       user_info = user_info_response.json()
 
       # Get user authorization details from database using the email
@@ -149,32 +145,28 @@ async def auth_me(request: Request, response: Response):
 
       if "email" in user_info:
         email = user_info["email"]
-        logger.info(f"Looking up user authorization for email: {email}")
-
+        # app_logger.info(f"Looking up user email: {email}")
         try:
           with get_session() as session:
             if session is None:
               db_status = "warning"
               db_message = "Database connection unavailable"
-              logger.warning("Database session is None, skipping user lookup")
+              app_logger.warning("Database session is None, skipping user lookup")
             else:
               try:
-                logger.info("Querying user_details table for existing user")
                 statement = select(User).where(User.email == email)
                 db_user = session.exec(statement).first()
-
                 if db_user:
-                  logger.info(f"Found existing user in database: {db_user.id}")
-
+                  # app_logger.info(f"Found existing user with id '{db_user.id}'")
                   if db_user.archived == 1:
-                    logger.info(
+                    app_logger.info(
                       f"User with email '{db_user.email}' is archived. Cannot authenticate them!"
                     )
                     response.delete_cookie("access_token")
                     return {
                       "status": "failure",
                       "message": "User is archived. Login prevented!",
-                      "details": str(e),
+                      "details": "User is archived. Please contact supcrt@iu.edu for support",
                     }
 
                   # Convert SQLModel to dict and add to response
@@ -192,7 +184,7 @@ async def auth_me(request: Request, response: Response):
                     "onboarded": db_user.onboarded,
                   }
                 else:
-                  logger.info(f"User {email} not found, creating minimal user entry")
+                  # app_logger.info(f"User {email} not found, creating minimal user entry")
 
                   # Get name components from CILogon data if available
                   name = user_info.get("name", "")
@@ -216,7 +208,7 @@ async def auth_me(request: Request, response: Response):
                     session.commit()
                     # Refresh to get the assigned ID
                     session.refresh(new_user)
-                    logger.info(f"Created new user with ID: {new_user.id}")
+                    # app_logger.info(f"Created new user with ID: {new_user.id}")
 
                     # Set flag for new user creation
                     is_new_user = True
@@ -238,17 +230,17 @@ async def auth_me(request: Request, response: Response):
 
                     db_message = "New user created successfully"
                   except SQLAlchemyError as add_error:
-                    logger.error(f"Failed to create new user: {add_error}")
+                    app_logger.exception(f"Failed to create new user: {add_error}")
                     db_status = "error"
                     db_message = f"Failed to create new user: {str(add_error)}"
               except Exception as table_error:
                 db_status = "error"
                 db_message = f"Error querying user_details table: {str(table_error)}"
-                logger.error(db_message)
+                app_logger.exception(db_message)
         except SQLAlchemyError as db_error:
           db_status = "error"
           db_message = f"Database connection error: {str(db_error)}"
-          logger.error(db_message)
+          app_logger.exception(db_message)
 
       return {
         "status": "success",
@@ -261,15 +253,15 @@ async def auth_me(request: Request, response: Response):
         "access_token": access_token,
       }
     except requests.exceptions.JSONDecodeError:
-      logger.error("Failed to decode user info response as JSON")
+      app_logger.exception("Failed to decode user info response as JSON")
       response.delete_cookie("access_token")
       return {
         "status": "failure",
         "message": "Failed to decode user info response as JSON",
         "details": user_info_response.text,
       }
   else:
-    logger.error(f"Failed to fetch user info: {user_info_response.status_code}")
+    app_logger.exception(f"Failed to fetch user info: {user_info_response.status_code}")
     response.delete_cookie("access_token")
     return {
       "status": "failure",

backend/app/routes/co2/co2_calc.py

@@ -94,4 +94,4 @@ def co2_calculator_interceptor(temp: float, bar: float, mNaCl: float):
     raise HTTPException(status_code=500, detail="Internal Server Error")
   except FileNotFoundError as e:
     print(f"File not found: {binary_path} - {e.strerror}")
-    raise HTTPException(status_code=500, detail=f"Internal Server Error")
+    raise HTTPException(status_code=500, detail="Internal Server Error")

backend/app/routes/minerals.py

@@ -1,6 +1,6 @@
-from fastapi import Form, HTTPException, APIRouter, Request
+from fastapi import HTTPException, APIRouter, Request
 import logging
-from sqlmodel import select, text
+from sqlmodel import text
 from app.db.database import get_session
 
 # Configure detailed logging

backend/app/routes/phreeqc/phreeqc_calc.py

@@ -1,16 +1,14 @@
-import subprocess
-from fastapi import APIRouter, HTTPException, File, Form, UploadFile
+from fastapi import APIRouter, HTTPException, Form, UploadFile
 from fastapi.responses import FileResponse
 import os
 from typing import Union, Optional
-from zipfile import ZipFile
 import re
 from datetime import datetime
-
-router = APIRouter()
 from typing import Annotated
 from . import process_manager
 
+router = APIRouter()
+
 databaseOptionList = [
   "geothermal.dat",
   "geothermal-ree.dat",
@@ -60,7 +58,7 @@ async def phreeqc_interceptor(
   inputFileDir = os.path.join(inputDir, inputFile.filename)
   files = []
   contents = (await inputFile.read()).decode("utf-8")
-  lines = re.split(f"\r\n|\r|\n", contents)
+  lines = re.split("\r\n|\r|\n", contents)
   for line in lines:
     line_parts = re.sub(r"\s+", " ", line).split(" ")
     for i in range(len(line_parts) - 1):
@@ -92,7 +90,7 @@ async def phreeqc_interceptor(
       with open(datFileDir, "w") as f:
         contents = (await customDataFile.read()).decode("utf-8")
         f.write(contents)
-    except:
+    except Exception:
       raise HTTPException(
         status_code=500,
         detail="Failed to parse your custom database file. Please double check it and try again later!",

backend/app/routes/phreeqc/process_manager.py

@@ -3,7 +3,7 @@
 import time
 import threading
 import json
-from typing import Dict, Optional
+from typing import Dict
 from datetime import datetime
 
 # Dictionary to keep track of running processes
@@ -189,7 +189,7 @@ def cleanup_old_processes():
         update_lock_file(
           process_info["lock_file"], "timeout", "Process killed after timeout"
         )
-      except:
+      except Exception:
         pass
       expired_processes.append(exp_id)