Merge pull request #1 from PythonHacker24/development-v1

Vortex Backend Component Version 1 - Final GSoC 2025 Evaluation

Author: PythonHacker24

.github/workflows/format.yaml

@@ -0,0 +1,25 @@
+# .github/workflows/gofmt.yml
+# .github/workflows/lint.yml
+name: Lint Check
+
+on:
+  push:
+    branches:
+      - '**'
+
+jobs:
+  lint:
+    name: Run make lint
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.24.2'
+
+      - name: Run lint
+        run: make lint

.gitignore

@@ -1,5 +1,5 @@
-# Binary files
-/bin/
+# Debug logs
+/logs/
 
 # for macOS dev environments
 .DS_Store

Dockerfile

@@ -0,0 +1,29 @@
+# --- Build stage ---
+FROM golang:latest AS builder
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+
+RUN make
+
+# --- Final image ---
+FROM debian:latest
+
+WORKDIR /app
+
+# Copy only the built binary
+COPY --from=builder /app/bin/laclm ./bin/laclm
+
+# Install bash in case needed
+# RUN apt-get update && apt-get install -y bash && rm -rf /var/lib/apt/lists/*
+
+RUN apt-get update && apt-get install -y bash acl && rm -rf /var/lib/apt/lists/*
+
+EXPOSE 8080
+
+# Default command to run your Go app
+CMD ["./bin/laclm", "--config", "config.yaml"]

Makefile

@@ -1,29 +1,47 @@
-APP_NAME = laclm
-CMD_DIR = ./cmd/$(APP_NAME)
-BIN_DIR = ./bin
-BIN_PATH = $(BIN_DIR)/$(APP_NAME)
+APP_NAME := laclm
+CMD_DIR := ./cmd/$(APP_NAME)
+BIN_DIR := ./bin
+BUILD_DIR := ./build
 
 GOFILES := $(shell find . -name '*.go' -type f)
 
-.PHONY: all build clean run test lint build-linux build-mac build-win
+# Target platforms: OS_ARCH
+TARGETS := \
+	linux_amd64 \
+	linux_arm64
 
+.PHONY: all build build-cross clean run test lint vendor package
+
+## Default target
 all: build
 
-## Build the app
-build: $(GOFILES)
+## Build for local OS/arch using vendored deps
+build: vendor $(GOFILES)
 	@echo "Building $(APP_NAME)..."
 	@mkdir -p $(BIN_DIR)
-	go build -o $(BIN_PATH) $(CMD_DIR)
+	GOOS="" GOARCH="" go build -mod=vendor -o $(BIN_DIR)/$(APP_NAME) $(CMD_DIR)
+
+## Build cross-compiled binaries for all Linux targets
+build-cross: vendor $(GOFILES)
+	@echo "Cross building for targets: $(TARGETS)"
+	@mkdir -p $(BIN_DIR)
+	@for target in $(TARGETS); do \
+		OS=$${target%_*}; \
+		ARCH=$${target#*_}; \
+		OUT=$(BIN_DIR)/$(APP_NAME)-$$OS-$$ARCH; \
+		echo "Building $$OUT..."; \
+		GOOS=$$OS GOARCH=$$ARCH go build -mod=vendor -o $$OUT $(CMD_DIR); \
+	done
 
 ## Run the app
 run: build
 	@echo "Running $(APP_NAME)..."
-	@$(BIN_PATH)
+	@$(BIN_DIR)/$(APP_NAME)
 
-## Clean build artifacts
+## Clean build and package directories
 clean:
 	@echo "Cleaning..."
-	@rm -rf $(BIN_DIR)
+	@rm -rf $(BIN_DIR) $(BUILD_DIR) vendor
 
 ## Run tests
 test:
@@ -32,9 +50,32 @@ test:
 
 ## Lint (requires golangci-lint)
 lint:
+	@if ! command -v golangci-lint >/dev/null 2>&1; then \
+		echo "Installing golangci-lint..."; \
+		go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest; \
+	fi
 	@echo "Linting..."
 	@golangci-lint run
 
-## Cross-build for Linux
-build-linux:
-	GOOS=linux GOARCH=amd64 go build -o $(BIN_DIR)/$(APP_NAME)-linux $(CMD_DIR)
+## Vendor dependencies
+vendor:
+	@echo "Vendoring dependencies..."
+	go mod vendor
+
+## Package full project source (with vendor) for each target
+package: clean vendor
+	@echo "Packaging full source tarballs for: $(TARGETS)"
+	@mkdir -p $(BUILD_DIR)
+	@for target in $(TARGETS); do \
+		OS=$${target%_*}; \
+		ARCH=$${target#*_}; \
+		NAME=$(APP_NAME)-$$OS-$$ARCH; \
+		TARBALL=$$NAME-source.tar.gz; \
+		echo "Creating $$TARBALL..."; \
+		mkdir -p tmp/$$NAME; \
+		cp -r * tmp/$$NAME; \
+		rm -rf tmp/$$NAME/$(BUILD_DIR) tmp/$$NAME/$(BIN_DIR); \
+		gtar -czf $(BUILD_DIR)/$$TARBALL -C tmp $$NAME; \
+		rm -rf tmp/$$NAME; \
+	done
+	@rm -rf tmp

README.md

@@ -1,34 +1,152 @@
-# Backend Component - Linux ACL Management Interface  
+<div align="center">
 
-Securing Linux Storage with ACLs: An Open-Source Web Management Interface for Enhanced Data Protection.
+# Linux ACL Management Interface - Backend Component
 
-Progress Docs: https://pythonhacker24.github.io/linux-acl-management/
+<img width="600" hegith="600" src="https://github.com/user-attachments/assets/a1625f58-0cd8-4df9-babc-31547b18d55a">
 
-## Documentation
+A robust web-based management interface for Linux Access Control Lists (ACLs), designed to enhance data protection and simplify ACL administration. This project provides a modern, user-friendly solution for managing file system permissions in Linux environments.
 
-To be written ...
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
+[View Documentation](https://pythonhacker24.github.io/linux-acl-management/)
 
-## Progress Report
+</div>
 
-To be written ...
+## Project Summary 
+
+Institutional departments, such as the Biomedical Informatics (BMI) Department of Emory University School of Medicine, manage vast amounts of data, often reaching petabyte scales across multiple Linux-based storage servers. Researchers storing data in these systems need a streamlined way to modify ACLs to grant or revoke access for collaborators. Currently, the IT team at BMI is responsible for manually handling these ACL modifications, which is time-consuming, error-prone, and inefficient, especially as data volume and user demands grow. To address this challenge at BMI and similar institutions worldwide, a Web Management Interface is needed to allow users to modify ACLs securely. This solution would eliminate the burden on IT teams by enabling on-demand permission management while ensuring security and reliability. The proposed system will feature a robust and highly configurable backend, high-speed databases, orchestration daemons for file storage servers, and an intuitive frontend. The proposal includes an in-depth analysis of required components, high-level and low-level design considerations, technology selection, and the demonstration of a functional prototype as proof of concept. The goal is to deliver a production-ready, secure, scalable, and reliable system for managing ACLs across multiple servers hosting filesystems such as NFS, BeeGFS, and others. This solution will streamline access control management and prepare it for deployment at BMI and other institutions worldwide, significantly reducing the manual workload for IT teams.
+
+## Features
+
+- Intuitive web interface for ACL management
+- High-performance backend written in Go
+- Real-time ACL updates
+- Comprehensive ACL reporting and visualization
+- Integration with OpenLDAP for authentication
+
+## Quick Start
+
+### Prerequisites
+
+- Go 1.20 or higher
+- Docker (optional)
+- Redis
+- OpenLDAP server
+
+### Local Installation
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/PythonHacker24/linux-acl-management.git
+   cd linux-acl-management
+   ```
+
+2. Install dependencies:
+   ```bash
+   go mod download
+   ```
+
+3. Build the application:
+   ```bash
+   go build -o acl-manager
+   ```
+
+### Production Build 
+
+For production build, it is recommended to use the Makefile. This allows you to build the complete binary on locally for security purposes. Since the project is in development mode, complete local build is not possible since dependencies are managed via GitHub and external vendors. Tarball based complete local builds will be developed in later stages.
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/yourusername/linux-acl-management.git
+   cd linux-acl-management
+   ```
+
+2. Use make:
+    ```bash
+    make build
+    ```
+
+3. Execute the binary
+    ```bash
+    ./bin/laclm --config config.yaml
+    ```
+
+### Docker Testbench Deployment
+
+A simulated environment has been developed on docker-compose for testing and experimenting purposes. It's not a production level build but a training ground for testing your config.yaml file for specific scenario. 
+
+```bash
+docker-compose up -d
+```
+
+A complete optional Docker based deployment option will be developed in later stages of development 
+
+## Usage
+
+1. Configure your settings in `config.yaml`
+
+2. Start the server:
+   ```bash
+   ./laclm --config <config.yaml>
+   ```
+
+3. Access the api at `http://<ip-address>:<port>`
+
+For detailed usage instructions, please refer to our [documentation](https://pythonhacker24.github.io/linux-acl-management/).
+
+## Project Structure
+
+```
+.
+├── cmd/          # Application entry points
+├── internal/     # Private application code
+├── pkg/          # Public library code
+├── api/          # API definitions and handlers
+├── docs/         # Documentation
+└── deployments/  # Deployment configurations
+```
+
+## Development
+
+### Branches
+
+- `main`: Production-ready code
+- `development-v<version>`: Development branches for specific versions
+
+### Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and development process.
 
 ## About
 
-- **Organization:** Department of Biomedical Informatics, Emory University
-- **Program:** Google Summer of Code 2025
-- **Contributor:** Aditya Patil
-- **Mentors:** Robert Tweedy, Mahmoud Zeydabadinezhad, PhD
+This project is developed as part of Google Summer of Code 2025, in collaboration with the Department of Biomedical Informatics at Emory University.
 
-This project is part of Google Summer of Code 2025, undertaken with the Department of Biomedical Informatics at Emory University.
+### Team
 
-## Technologies Used
+- **Contributor:** Aditya Patil
+- **Mentors:** 
+  - Robert Tweedy
+  - Mahmoud Zeydabadinezhad, PhD
+
+### Technologies
 
-- **Programming Languages:** Golang
-- **Frameworks/Libraries:** net/http
-- **Standards/Protocols:** gRPC, REST
-- **Tools:** Tarball, Redis, Docker, OpenLDAP
+- **Backend:** Golang, net/http
+- **API:** gRPC, REST
+- **Infrastructure:** Docker, Redis, OpenLDAP
+- **Packaging:** Tarball
 
 ## License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Department of Biomedical Informatics, Emory University
+- Google Summer of Code Program
+- Open Source Community