Fixed issue with generating multiple OTP - now prints a nice list for Copy/Paste. Began splitting client / server functionality. Demoted selector and setup to util from service. Fixed some typos.
This commit is contained in:
+30
-1
@@ -141,7 +141,13 @@ class AirlockAPIWrapper:
|
||||
payload = {"status": "0"}
|
||||
result = self._post("/v1/otp/usage", payload)
|
||||
return pd.DataFrame(result["response"]["otpusage"])
|
||||
|
||||
|
||||
def otp_find_by_agent(self, agentid) -> pd.DataFrame:
|
||||
"""Find OTP by agent."""
|
||||
payload = {"agentid": agentid}
|
||||
result = self._post("/v1/otp/usage", payload)
|
||||
return pd.DataFrame(result["response"]["otpusage"])
|
||||
|
||||
def otp_generate(self, agentid: str, duration: int, purpose: str) -> str:
|
||||
"""Generate a new OTP for an agent."""
|
||||
payload = {
|
||||
@@ -157,6 +163,29 @@ class AirlockAPIWrapper:
|
||||
payload = {"otpid": otpid}
|
||||
result = self._post("/v1/otp/activities", payload)
|
||||
return pd.DataFrame(result["response"]["otpactivities"])
|
||||
|
||||
def otp_revoke(self, otpid: str) -> dict:
|
||||
"""
|
||||
Revoke an active OTP.
|
||||
Parameters:
|
||||
- otpid (str): The ID of the OTP to revoke.
|
||||
Returns:
|
||||
- dict: JSON response from the API.
|
||||
"""
|
||||
payload = {"otpid": otpid}
|
||||
return self._post("/v1/otp/revoke", payload)
|
||||
|
||||
def otp_validate(self, otpcode: str) -> dict:
|
||||
"""
|
||||
Validate an OTP code.
|
||||
Parameters:
|
||||
- otpcode (str): The OTP code to validate.
|
||||
Returns:
|
||||
- dict: JSON response indicating validity.
|
||||
"""
|
||||
payload = {"otpcode": otpcode}
|
||||
return self._post("/v1/otp/validate", payload)
|
||||
|
||||
|
||||
# Policy Management
|
||||
def policy_add_path_exclusions(self, groupid: str, paths: List[str]) -> dict:
|
||||
|
||||
+39
-33
@@ -27,7 +27,7 @@ import pandas as pd
|
||||
from models.agent import Agent
|
||||
from models.policy import Policy
|
||||
from services.API import AirlockAPIWrapper
|
||||
from services.selector import Selector
|
||||
from utils.selector import Selector
|
||||
from utils.utils import colorText, load_env, load_env_json
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
@@ -94,43 +94,44 @@ def findAllAgents(api):
|
||||
|
||||
return agents
|
||||
|
||||
|
||||
|
||||
def findAgents(api, return_dataframe):
|
||||
agents = selectAgents(api)
|
||||
working_dir = load_env("WORKING_DIR")
|
||||
if agents:
|
||||
agent_dicts = [asdict(agent) for agent in agents]
|
||||
agent_df = pd.DataFrame(agent_dicts)
|
||||
|
||||
if return_dataframe:
|
||||
logging.debug("Returning DataFrame to caller.")
|
||||
return agent_df
|
||||
else:
|
||||
print(agent_df)
|
||||
logging.debug("Displayed DataFrame to console.")
|
||||
|
||||
# Ask user if they want to export
|
||||
user_input = input("\nWould you like to export the results to a CSV file? (y/n): ").strip().lower()
|
||||
if user_input == 'y':
|
||||
timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
|
||||
filename = f"agentsearch_{timestamp}.csv"
|
||||
file_path = os.path.join(working_dir, filename)
|
||||
|
||||
agent_df.to_csv(file_path, index=False)
|
||||
logging.info(f"Exported DataFrame to {file_path}")
|
||||
|
||||
print(
|
||||
colorText(
|
||||
f"\n✅ Matched devices exported to: {working_dir}\\{filename}",
|
||||
"green",
|
||||
)
|
||||
)
|
||||
else:
|
||||
logging.debug("User declined to export the DataFrame.")
|
||||
else:
|
||||
logging.warning("No agents found.")
|
||||
if not agents:
|
||||
logging.warning("No agents or policies found.")
|
||||
print("No agents matched the criteria.")
|
||||
return
|
||||
|
||||
# Convert enriched agents to DataFrame
|
||||
agent_dicts = [asdict(agent) for agent in agents]
|
||||
agent_df = pd.DataFrame(agent_dicts)
|
||||
|
||||
if return_dataframe:
|
||||
logging.debug("Returning DataFrame to caller.")
|
||||
return agent_df
|
||||
|
||||
# Otherwise, print and optionally export
|
||||
print(agent_df)
|
||||
logging.debug("Displayed DataFrame to console.")
|
||||
|
||||
user_input = input("\nWould you like to export the results to a CSV file? (y/n): ").strip().lower()
|
||||
if user_input == 'y':
|
||||
timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
|
||||
filename = f"agentsearch_{timestamp}.csv"
|
||||
file_path = os.path.join(working_dir, filename)
|
||||
|
||||
agent_df.to_csv(file_path, index=False)
|
||||
logging.info(f"Exported DataFrame to {file_path}")
|
||||
|
||||
print(
|
||||
colorText(
|
||||
f"\n✅ Matched devices exported to: {working_dir}\\{filename}",
|
||||
"green",
|
||||
)
|
||||
)
|
||||
else:
|
||||
logging.debug("User declined to export the DataFrame.")
|
||||
|
||||
def selectAgents(api: AirlockAPIWrapper) -> List[Agent]:
|
||||
print(colorText("🔍 Device Search", "cyan"))
|
||||
@@ -143,6 +144,7 @@ def selectAgents(api: AirlockAPIWrapper) -> List[Agent]:
|
||||
print(colorText("u-hVenderBroke\n", "cyan"))
|
||||
|
||||
print(colorText("Paste or type your device names below:", "white"))
|
||||
policies = [Policy(**row.to_dict()) for _, row in api.policy_find_all().iterrows()]
|
||||
|
||||
device_input_lines = []
|
||||
empty_line_count = 0
|
||||
@@ -185,6 +187,10 @@ def selectAgents(api: AirlockAPIWrapper) -> List[Agent]:
|
||||
logger.debug(f"✅ Found {len(matched_agents)} matching device(s).")
|
||||
print(colorText(f"✅ Found {len(matched_agents)} matching device(s).", "green"))
|
||||
|
||||
# Enrich each agent using its class method
|
||||
for agent in matched_agents:
|
||||
agent.enrich_with_policies(policies)
|
||||
|
||||
return matched_agents
|
||||
|
||||
def moveAgentToRelatedPolicy(
|
||||
|
||||
@@ -27,7 +27,7 @@ from bson import ObjectId
|
||||
|
||||
from models.policy import Policy
|
||||
from services.API import AirlockAPIWrapper
|
||||
from services.setup import get_base_directory
|
||||
from utils.setup import get_base_directory
|
||||
from utils.utils import colorText, load_env_json
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@@ -1,352 +0,0 @@
|
||||
# Copyright (C) 2025 James Brotosky, Brandon Wickline
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Affero General Public License as published
|
||||
# by the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Affero General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Affero General Public License
|
||||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
from typing import Any, Callable, Dict, List
|
||||
|
||||
import schedule
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# TODO - move this File where all jobs are persisted
|
||||
JOBS_FILE = f"{os.getenv('WORKING_DIR')}\\scheduling\\jobs.json"
|
||||
|
||||
# Ensure directory exists
|
||||
os.makedirs(os.path.dirname(JOBS_FILE), exist_ok=True)
|
||||
|
||||
# Registry of functions that can be scheduled
|
||||
FUNCTION_MAP: Dict[str, Callable] = {}
|
||||
|
||||
# -------------------------------
|
||||
# Function Registration
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def register_function(name: str, func: Callable):
|
||||
"""
|
||||
Register a function so it can be called by name later.
|
||||
Example:
|
||||
register_function("say_hello", say_hello)
|
||||
"""
|
||||
FUNCTION_MAP[name] = func
|
||||
|
||||
|
||||
# -------------------------------
|
||||
# Persistence Helpers
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def load_jobs() -> List[Dict[str, Any]]:
|
||||
"""Load jobs from the JSON file, or return [] if none exist."""
|
||||
if not os.path.exists(JOBS_FILE):
|
||||
return []
|
||||
with open(JOBS_FILE, "r") as f:
|
||||
return json.load(f)
|
||||
|
||||
|
||||
def _atomic_save(path: str, data: Any):
|
||||
"""Write JSON atomically to avoid partial writes."""
|
||||
tmp = f"{path}.tmp"
|
||||
with open(tmp, "w") as f:
|
||||
json.dump(data, f, indent=4)
|
||||
os.replace(tmp, path)
|
||||
|
||||
|
||||
def save_jobs(jobs: List[Dict[str, Any]]):
|
||||
"""Save jobs to the JSON file (overwrite)."""
|
||||
_atomic_save(JOBS_FILE, jobs)
|
||||
|
||||
|
||||
# -------------------------------
|
||||
# Uniqueness Helpers
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def job_in_store(job_id: str) -> bool:
|
||||
"""Check if a job id exists in the persisted JSON file."""
|
||||
return any(j.get("id") == job_id for j in load_jobs())
|
||||
|
||||
|
||||
def job_in_scheduler(job_id: str) -> bool:
|
||||
"""
|
||||
Check if a job with this tag exists in the in-memory scheduler.
|
||||
Uses schedule.get_jobs(tag=...) if available, otherwise scans tags.
|
||||
"""
|
||||
try:
|
||||
jobs = schedule.get_jobs(tag=job_id) # schedule >= 1.2.0
|
||||
return len(jobs) > 0
|
||||
except TypeError:
|
||||
# Fallback for older versions
|
||||
return any(job_id in getattr(j, "tags", set()) for j in schedule.jobs)
|
||||
|
||||
|
||||
def ensure_unique(job_id: str, on_conflict: str = "skip") -> bool:
|
||||
"""
|
||||
Ensure the job_id is unique across persistence and in-memory schedule.
|
||||
on_conflict:
|
||||
- "error": raise ValueError if exists.
|
||||
- "skip" : print and return False.
|
||||
- "replace": remove existing (in-memory + JSON), then continue.
|
||||
"""
|
||||
exists = job_in_store(job_id) or job_in_scheduler(job_id)
|
||||
if not exists:
|
||||
return True
|
||||
if on_conflict == "error":
|
||||
raise ValueError(f"Job id '{job_id}' already exists.")
|
||||
elif on_conflict == "skip":
|
||||
logger.info(f"Job '{job_id}' already exists. Skipping creation.")
|
||||
return False
|
||||
elif on_conflict == "replace":
|
||||
# Clear from scheduler
|
||||
schedule.clear(job_id)
|
||||
# Remove from persistence
|
||||
jobs = [j for j in load_jobs() if j.get("id") != job_id]
|
||||
save_jobs(jobs)
|
||||
return True
|
||||
else:
|
||||
raise ValueError(f"Unsupported on_conflict policy: {on_conflict}")
|
||||
|
||||
|
||||
# -------------------------------
|
||||
# Internal scheduling (no persistence)
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def _schedule_once(job_id: str, func_name: str, run_at_timestamp: float, args=None, kwargs=None):
|
||||
args = args or []
|
||||
kwargs = kwargs or {}
|
||||
|
||||
def job_wrapper():
|
||||
"""Executes the job once, then removes it."""
|
||||
if func_name not in FUNCTION_MAP:
|
||||
logger.error(f"Function '{func_name}' is not registered.")
|
||||
return
|
||||
FUNCTION_MAP[func_name](*args, **kwargs)
|
||||
# Remove from persistence
|
||||
jobs = load_jobs()
|
||||
jobs = [j for j in jobs if j["id"] != job_id]
|
||||
save_jobs(jobs)
|
||||
# Clear from in-memory schedule
|
||||
schedule.clear(job_id)
|
||||
|
||||
delay_seconds = run_at_timestamp - time.time()
|
||||
if delay_seconds <= 0:
|
||||
logger.info(f"Job {job_id} scheduled in the past. Skipping.")
|
||||
return
|
||||
# Schedule via schedule library
|
||||
schedule.every(int(delay_seconds)).seconds.do(job_wrapper).tag(job_id)
|
||||
|
||||
|
||||
def _schedule_recurring(
|
||||
job_id: str, func_name: str, interval: int, unit: str, args=None, kwargs=None
|
||||
):
|
||||
args = args or []
|
||||
kwargs = kwargs or {}
|
||||
|
||||
def job_wrapper():
|
||||
if func_name not in FUNCTION_MAP:
|
||||
logger.error(f"Function '{func_name}' is not registered.")
|
||||
return
|
||||
FUNCTION_MAP[func_name](*args, **kwargs)
|
||||
|
||||
if unit == "seconds":
|
||||
schedule.every(interval).seconds.do(job_wrapper).tag(job_id)
|
||||
elif unit == "minutes":
|
||||
schedule.every(interval).minutes.do(job_wrapper).tag(job_id)
|
||||
elif unit == "hours":
|
||||
schedule.every(interval).hours.do(job_wrapper).tag(job_id)
|
||||
elif unit == "days":
|
||||
schedule.every(interval).days.do(job_wrapper).tag(job_id)
|
||||
else:
|
||||
raise ValueError(f"Unsupported unit: {unit}")
|
||||
|
||||
|
||||
# -------------------------------
|
||||
# Public APIs (with uniqueness + persistence)
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def run_once_job(
|
||||
job_id: str,
|
||||
func_name: str,
|
||||
run_at_timestamp: float,
|
||||
args=None,
|
||||
kwargs=None,
|
||||
*,
|
||||
replace: bool = False,
|
||||
persist: bool = True,
|
||||
):
|
||||
"""
|
||||
Schedule a job to run once at a specific timestamp.
|
||||
replace: if True, replace existing job with same id; otherwise print and skip.
|
||||
persist: if False, do not write to JSON (used by reload_jobs()).
|
||||
"""
|
||||
if persist:
|
||||
policy = "replace" if replace else "skip"
|
||||
if not ensure_unique(job_id, on_conflict=policy):
|
||||
return
|
||||
elif job_in_scheduler(job_id):
|
||||
schedule.clear(job_id)
|
||||
_schedule_once(job_id, func_name, run_at_timestamp, args, kwargs)
|
||||
if persist:
|
||||
jobs = [j for j in load_jobs() if j["id"] != job_id]
|
||||
jobs.append(
|
||||
{
|
||||
"id": job_id,
|
||||
"type": "once",
|
||||
"run_at": run_at_timestamp,
|
||||
"function": func_name,
|
||||
"args": args or [],
|
||||
"kwargs": kwargs or {},
|
||||
}
|
||||
)
|
||||
save_jobs(jobs)
|
||||
|
||||
|
||||
def recurring_job(
|
||||
job_id: str,
|
||||
func_name: str,
|
||||
interval: int,
|
||||
unit: str,
|
||||
args=None,
|
||||
kwargs=None,
|
||||
*,
|
||||
replace: bool = False,
|
||||
persist: bool = True,
|
||||
):
|
||||
"""
|
||||
Schedule a recurring job.
|
||||
replace: if True, replace existing job with same id; otherwise print and skip.
|
||||
persist: if False, do not write to JSON (used by reload_jobs()).
|
||||
"""
|
||||
if persist:
|
||||
policy = "replace" if replace else "skip"
|
||||
if not ensure_unique(job_id, on_conflict=policy):
|
||||
return
|
||||
elif job_in_scheduler(job_id):
|
||||
schedule.clear(job_id)
|
||||
_schedule_recurring(job_id, func_name, interval, unit, args, kwargs)
|
||||
if persist:
|
||||
jobs = [j for j in load_jobs() if j["id"] != job_id]
|
||||
jobs.append(
|
||||
{
|
||||
"id": job_id,
|
||||
"type": "recurring",
|
||||
"interval": interval,
|
||||
"unit": unit,
|
||||
"function": func_name,
|
||||
"args": args or [],
|
||||
"kwargs": kwargs or {},
|
||||
}
|
||||
)
|
||||
save_jobs(jobs)
|
||||
|
||||
|
||||
def find_and_prioritize_jobs_by_pid(pid_substring: str, new_delay_seconds: float = 1.0):
|
||||
"""
|
||||
Find all jobs whose ID contains the given PID substring and reschedule them to run sooner.
|
||||
"""
|
||||
jobs = load_jobs()
|
||||
matched_jobs = [job for job in jobs if pid_substring in job.get("id", "")]
|
||||
|
||||
if not matched_jobs:
|
||||
logger.info(f"No jobs found containing PID substring '{pid_substring}'.")
|
||||
return
|
||||
|
||||
logger.info(f"Found {len(matched_jobs)} job(s) containing '{pid_substring}':")
|
||||
|
||||
for job in matched_jobs:
|
||||
job_id = job["id"]
|
||||
logger.debug(f" - Prioritizing job: {job_id}")
|
||||
|
||||
# Clear existing job from scheduler
|
||||
schedule.clear(job_id)
|
||||
|
||||
# Reschedule based on job type
|
||||
if job["type"] == "once":
|
||||
run_once_job(
|
||||
job_id,
|
||||
job["function"],
|
||||
time.time() + new_delay_seconds,
|
||||
job.get("args"),
|
||||
job.get("kwargs"),
|
||||
replace=True,
|
||||
persist=True,
|
||||
)
|
||||
elif job["type"] == "recurring":
|
||||
recurring_job(
|
||||
job_id,
|
||||
job["function"],
|
||||
job["interval"],
|
||||
job["unit"],
|
||||
job.get("args"),
|
||||
job.get("kwargs"),
|
||||
replace=True,
|
||||
persist=True,
|
||||
)
|
||||
else:
|
||||
logger.warning(f"Unknown job type for job '{job_id}'")
|
||||
|
||||
|
||||
# -------------------------------
|
||||
# Reload Saved Jobs
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def reload_jobs():
|
||||
"""Reload jobs from JSON and reschedule them (no re-persist)."""
|
||||
jobs = load_jobs()
|
||||
for job in jobs:
|
||||
if job["type"] == "once":
|
||||
if job["run_at"] > time.time():
|
||||
run_once_job(
|
||||
job["id"],
|
||||
job["function"],
|
||||
job["run_at"],
|
||||
job.get("args"),
|
||||
job.get("kwargs"),
|
||||
persist=False,
|
||||
)
|
||||
elif job["type"] == "recurring":
|
||||
recurring_job(
|
||||
job["id"],
|
||||
job["function"],
|
||||
job["interval"],
|
||||
job["unit"],
|
||||
job.get("args"),
|
||||
job.get("kwargs"),
|
||||
persist=False,
|
||||
)
|
||||
|
||||
|
||||
# -------------------------------
|
||||
# Scheduler Loop
|
||||
# -------------------------------
|
||||
|
||||
|
||||
def start_scheduler():
|
||||
"""
|
||||
Start the scheduler loop (blocking).
|
||||
Call this once in main to begin.
|
||||
"""
|
||||
try:
|
||||
while True:
|
||||
schedule.run_pending()
|
||||
time.sleep(0.5)
|
||||
except KeyboardInterrupt:
|
||||
logger.critical("Scheduler stopped.")
|
||||
@@ -1,121 +0,0 @@
|
||||
# Copyright (C) 2025 James Brotosky, Brandon Wickline
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Affero General Public License as published
|
||||
# by the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Affero General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Affero General Public License
|
||||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
import logging
|
||||
from typing import Any, List, Optional, Union
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Selector:
|
||||
@staticmethod
|
||||
def select_objects(
|
||||
objects: List[Any],
|
||||
allow_multiple: bool = False,
|
||||
prompt_each: bool = False
|
||||
) -> Union[Optional[Any], List[Any]]:
|
||||
if not objects:
|
||||
logger.warning("No objects available for selection.")
|
||||
return None
|
||||
|
||||
# Sort objects alphabetically by their 'name' attribute
|
||||
sorted_objects = sorted(objects, key=lambda obj: getattr(obj, "name", str(obj)).lower())
|
||||
|
||||
# Display in 4 columns with extra spacing
|
||||
num_columns = 4
|
||||
rows = (len(sorted_objects) + num_columns - 1) // num_columns
|
||||
print("\nAvailable Choices:")
|
||||
for row in range(rows):
|
||||
line = ""
|
||||
for col in range(num_columns):
|
||||
idx = row + col * rows
|
||||
if idx < len(sorted_objects):
|
||||
obj = sorted_objects[idx]
|
||||
name = getattr(obj, "name", str(obj))
|
||||
line += f"{idx + 1}: {name:<30}"
|
||||
print(line)
|
||||
|
||||
selected = []
|
||||
|
||||
if allow_multiple:
|
||||
while True:
|
||||
choice = input("Select an object by number (or Q to finish): ").strip().lower()
|
||||
if choice == "q":
|
||||
break
|
||||
try:
|
||||
index = int(choice)
|
||||
if 1 <= index <= len(sorted_objects):
|
||||
obj = sorted_objects[index - 1]
|
||||
if obj not in selected:
|
||||
selected.append(obj)
|
||||
if prompt_each:
|
||||
logger.info(f"Selected: {getattr(obj, 'name', str(obj))}")
|
||||
else:
|
||||
logger.warning("Object already selected.")
|
||||
else:
|
||||
logger.warning("Selection out of range. Try again.")
|
||||
except ValueError:
|
||||
logger.warning("Invalid input. Enter a number or 'Q' to quit.")
|
||||
return selected if selected else None
|
||||
else:
|
||||
try:
|
||||
choice = int(input("Select one object by number: "))
|
||||
if 1 <= choice <= len(sorted_objects):
|
||||
selected_obj = sorted_objects[choice - 1]
|
||||
logger.info(f"Selected: {getattr(selected_obj, 'name', str(selected_obj))}")
|
||||
return selected_obj
|
||||
else:
|
||||
logger.warning("Selection out of range.")
|
||||
except ValueError:
|
||||
logger.warning("Invalid input.")
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def select_value(
|
||||
prompt: str,
|
||||
value_type: type = int,
|
||||
valid_range: Optional[tuple] = None,
|
||||
allow_quit: bool = False
|
||||
) -> Optional[Any]:
|
||||
while True:
|
||||
user_input = input(prompt).strip().lower()
|
||||
if allow_quit and user_input == "q":
|
||||
logger.info("User opted to quit value selection.")
|
||||
return None
|
||||
try:
|
||||
value = value_type(user_input)
|
||||
if valid_range:
|
||||
min_val, max_val = valid_range
|
||||
if not (min_val <= value <= max_val):
|
||||
logger.warning(f"Value out of range ({min_val}–{max_val}).")
|
||||
continue
|
||||
logger.info(f"User selected value: {value}")
|
||||
return value
|
||||
except ValueError:
|
||||
logger.warning(f"Invalid input. Expected a {value_type.__name__}.")
|
||||
|
||||
@staticmethod
|
||||
def confirm(prompt: str = "Are you sure? (Y/N): ") -> bool:
|
||||
while True:
|
||||
response = input(prompt).strip().lower()
|
||||
if response in ["y", "yes"]:
|
||||
logger.info("User confirmed action.")
|
||||
return True
|
||||
elif response in ["n", "no"]:
|
||||
logger.info("User declined action.")
|
||||
return False
|
||||
else:
|
||||
logger.warning("Invalid confirmation input. Expected 'Y' or 'N'.")
|
||||
@@ -1,183 +0,0 @@
|
||||
# Copyright (C) 2025 James Brotosky, Brandon Wickline
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Affero General Public License as published
|
||||
# by the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Affero General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Affero General Public License
|
||||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
|
||||
import json
|
||||
import logging
|
||||
import logging.handlers
|
||||
import os
|
||||
import platform
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
from dotenv import load_dotenv, set_key
|
||||
|
||||
PROTECTED_KEYS = [
|
||||
"APPNAME",
|
||||
"PATH_EXCLUSION_CONST",
|
||||
"MIN_FILES_FOR_PATH",
|
||||
"VT_THREAT_TOLERANCE",
|
||||
"POLICY_MAP_ENF_AUD"
|
||||
]
|
||||
|
||||
def get_base_directory() -> Path:
|
||||
system = platform.system()
|
||||
home = Path.home()
|
||||
if system == 'Windows':
|
||||
return Path(os.getenv('APPDATA', home / 'AppData' / 'Roaming')) / "AirlockTools"
|
||||
elif system == 'Darwin':
|
||||
return home / 'Library' / 'Application Support' / "AirlockTools"
|
||||
else:
|
||||
return home / '.local' / 'share' / "AirlockTools"
|
||||
|
||||
def configure_logging(log_dir: Path, log_level: str = "DEBUG"):
|
||||
log_file = log_dir / "airlocktools.log"
|
||||
logger = logging.getLogger()
|
||||
logger.setLevel(getattr(logging, log_level.upper(), logging.DEBUG))
|
||||
|
||||
# 🔧 Clear existing handlers
|
||||
for handler in logger.handlers[:]:
|
||||
logger.removeHandler(handler)
|
||||
|
||||
file_handler = logging.handlers.RotatingFileHandler(
|
||||
log_file, maxBytes=5_000_000, backupCount=5, encoding='utf-8'
|
||||
)
|
||||
file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
|
||||
logger.addHandler(file_handler)
|
||||
|
||||
console_handler = logging.StreamHandler()
|
||||
console_handler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
|
||||
logger.addHandler(console_handler)
|
||||
|
||||
if platform.system() == "Windows":
|
||||
try:
|
||||
event_handler = logging.handlers.NTEventLogHandler("AirlockTools")
|
||||
event_handler.setLevel(logging.CRITICAL)
|
||||
event_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
|
||||
logger.addHandler(event_handler)
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not attach Windows Event Log handler: {e}")
|
||||
|
||||
logger.debug("✅ Logging configured.")
|
||||
|
||||
|
||||
def get_system_config_path() -> Path:
|
||||
base_path = Path(getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__))))
|
||||
return base_path.parent / "system_config.json"
|
||||
|
||||
def load_system_config() -> dict:
|
||||
try:
|
||||
config_path = get_system_config_path()
|
||||
with open(config_path, "r") as f:
|
||||
return json.load(f)
|
||||
except FileNotFoundError:
|
||||
logging.warning("⚠️ system_config.json not found. Using built-in defaults.")
|
||||
return {
|
||||
"APPNAME": "AirlockTools",
|
||||
"LOG_LEVEL": "DEBUG",
|
||||
"PATH_EXCLUSION_CONST": 4,
|
||||
"MIN_FILES_FOR_PATH": 4,
|
||||
"VT_THREAT_TOLERANCE": 4,
|
||||
"POLICY_MAP_ENF_AUD": {
|
||||
"enforced_id": "audit_id"
|
||||
}
|
||||
}
|
||||
|
||||
def load_user_config(config_dir: Path) -> dict:
|
||||
user_config_path = config_dir / "user_config.json"
|
||||
if not user_config_path.exists():
|
||||
default_user_config = {
|
||||
"URL": "",
|
||||
"LOG_LEVEL": "INFO"
|
||||
}
|
||||
with open(user_config_path, "w") as f:
|
||||
json.dump(default_user_config, f, indent=4)
|
||||
logging.debug(f"Created user config at {user_config_path}")
|
||||
with open(user_config_path, "r") as f:
|
||||
return json.load(f)
|
||||
|
||||
def write_config_to_env(config: dict, env_path: Path):
|
||||
for key, value in config.items():
|
||||
try:
|
||||
serialized = json.dumps(value) if isinstance(value, (list, dict)) else str(value)
|
||||
set_key(env_path, key, serialized)
|
||||
except Exception as e:
|
||||
logging.warning(f"Failed to write {key} to .env: {e}")
|
||||
|
||||
def setup() -> Path:
|
||||
base_dir = get_base_directory()
|
||||
dirs = {
|
||||
'config': base_dir / 'config',
|
||||
'cache': base_dir / 'cache',
|
||||
'logs': base_dir / 'logs',
|
||||
}
|
||||
|
||||
for name, path in dirs.items():
|
||||
path.mkdir(parents=True, exist_ok=True)
|
||||
logging.debug(f"{name.capitalize()} directory ensured at: {path}")
|
||||
|
||||
system_config = load_system_config()
|
||||
configure_logging(dirs['logs'], system_config.get("LOG_LEVEL", "DEBUG"))
|
||||
|
||||
env_path = base_dir / ".env"
|
||||
if not env_path.exists():
|
||||
env_path.touch()
|
||||
load_dotenv(dotenv_path=env_path, override=True)
|
||||
|
||||
working_dir = Path(os.getenv("WORKING_DIR") or (base_dir / "data"))
|
||||
working_dir.mkdir(parents=True, exist_ok=True)
|
||||
set_key(env_path, "WORKING_DIR", str(working_dir))
|
||||
os.environ["WORKING_DIR"] = str(working_dir)
|
||||
logging.debug(f"Working directory set to: {working_dir}")
|
||||
|
||||
folders_structure = {
|
||||
"Approved": [],
|
||||
"Needs_Review": ["Review_First", "Review_Second", "HTML"],
|
||||
"Preflight": ["HTML"],
|
||||
"Archived": ["HTML"],
|
||||
"Scheduling": []
|
||||
}
|
||||
|
||||
for folder_name, subfolders in folders_structure.items():
|
||||
folder_path = working_dir / folder_name
|
||||
folder_path.mkdir(parents=True, exist_ok=True)
|
||||
logging.debug(f"'{folder_name}' folder ensured at: {folder_path}")
|
||||
for subfolder in subfolders:
|
||||
subfolder_path = folder_path / subfolder
|
||||
subfolder_path.mkdir(parents=True, exist_ok=True)
|
||||
logging.debug(f" └─ '{subfolder}' subfolder created at: {subfolder_path}")
|
||||
|
||||
user_config = load_user_config(dirs['config'])
|
||||
merged_config = {**system_config, **user_config}
|
||||
|
||||
for key in PROTECTED_KEYS:
|
||||
merged_config[key] = system_config.get(key, "")
|
||||
|
||||
# ✅ URL resolution order: system_config → .env → user prompt
|
||||
url = system_config.get("URL")
|
||||
if not url:
|
||||
url = os.getenv("URL")
|
||||
if not url:
|
||||
url = input("🌐 Enter the service URL (e.g., https://example.com/api): ").strip()
|
||||
|
||||
merged_config["URL"] = url
|
||||
set_key(env_path, "URL", url)
|
||||
os.environ["URL"] = url
|
||||
logging.debug(f"Service URL set to: {url}")
|
||||
|
||||
write_config_to_env(merged_config, env_path)
|
||||
|
||||
return working_dir
|
||||
Reference in New Issue
Block a user