5 |
6 |
7 | ## Introduction
8 | The Post Viewer and Analyzer is a *very* simple web-based application built with Go. It serves a web interface that allows users to fetch posts from the JSONPlaceholder API, save these posts to a file, and perform a character frequency analysis on the saved data. This application demonstrates the use of Go for server-side web development, including handling HTTP requests, processing JSON, and rendering HTML templates.
9 |
10 | ## Features
11 | - **Fetch Data**: Users can fetch posts from the external JSONPlaceholder API.
12 | - **Save Data**: Automatically saves fetched posts into a local JSON file.
13 | - **Analyze Data**: Performs a character frequency analysis on the contents of the saved JSON file.
14 | - **Web Interface**: Simple and user-friendly web interface to interact with the application.
15 |
16 | ## Live Deployment
17 |
18 | The application is deployed on Render and can be accessed using the following link: [Post Viewer and Analyzer](https://post-analyzer-webserver.onrender.com)
19 |
20 | Please note that the application is hosted on a free tier and may take some time to load initially.
21 |
22 | ## Technology Stack
23 | - **Go**: All server-side logic is implemented in Go, utilizing its standard library for web server functionality, file I/O, and concurrency.
24 | - **HTML/CSS**: Front-end layout and styling.
25 | - **JSONPlaceholder API**: External REST API used for fetching sample post data.
26 |
27 | ### Why Go?
28 | - **Concurrency**: Go's built-in support for concurrency makes it easy to write efficient and scalable web servers.
29 | - **Standard Library**: Go's standard library provides robust support for web development, including an HTTP server, JSON encoding/decoding, and file I/O.
30 | - **Performance**: Go is known for its fast compilation times and efficient runtime performance, making it a great choice for web applications.
31 | - **Community**: Go has a large and active community, with extensive documentation and libraries available for web development.
32 |
33 | ### Example Analysis Result
34 |
35 | 
37 | 
96 | 
97 | 
98 | 
99 | 
100 |
101 | ---
102 |
103 | Created with ❤️ by [Son Nguyen](https://github.com/hoangsonww) in 2024.
104 |
--------------------------------------------------------------------------------
/internal/metrics/metrics.go:
--------------------------------------------------------------------------------
1 | package metrics
2 |
3 | import (
4 | "net/http"
5 | "strconv"
6 | "time"
7 |
8 | "github.com/prometheus/client_golang/prometheus"
9 | "github.com/prometheus/client_golang/prometheus/promauto"
10 | "github.com/prometheus/client_golang/prometheus/promhttp"
11 | )
12 |
13 | var (
14 | // HTTP metrics
15 | httpRequestsTotal = promauto.NewCounterVec(
16 | prometheus.CounterOpts{
17 | Name: "http_requests_total",
18 | Help: "Total number of HTTP requests",
19 | },
20 | []string{"method", "path", "status"},
21 | )
22 |
23 | httpRequestDuration = promauto.NewHistogramVec(
24 | prometheus.HistogramOpts{
25 | Name: "http_request_duration_seconds",
26 | Help: "HTTP request latency in seconds",
27 | Buckets: prometheus.DefBuckets,
28 | },
29 | []string{"method", "path", "status"},
30 | )
31 |
32 | httpRequestSize = promauto.NewHistogramVec(
33 | prometheus.HistogramOpts{
34 | Name: "http_request_size_bytes",
35 | Help: "HTTP request size in bytes",
36 | Buckets: prometheus.ExponentialBuckets(100, 10, 8),
37 | },
38 | []string{"method", "path"},
39 | )
40 |
41 | httpResponseSize = promauto.NewHistogramVec(
42 | prometheus.HistogramOpts{
43 | Name: "http_response_size_bytes",
44 | Help: "HTTP response size in bytes",
45 | Buckets: prometheus.ExponentialBuckets(100, 10, 8),
46 | },
47 | []string{"method", "path"},
48 | )
49 |
50 | // Application metrics
51 | postsTotal = promauto.NewGauge(
52 | prometheus.GaugeOpts{
53 | Name: "posts_total",
54 | Help: "Total number of posts in the system",
55 | },
56 | )
57 |
58 | postsFetched = promauto.NewCounter(
59 | prometheus.CounterOpts{
60 | Name: "posts_fetched_total",
61 | Help: "Total number of posts fetched from external API",
62 | },
63 | )
64 |
65 | postsAdded = promauto.NewCounter(
66 | prometheus.CounterOpts{
67 | Name: "posts_added_total",
68 | Help: "Total number of posts added by users",
69 | },
70 | )
71 |
72 | analysisOperations = promauto.NewCounter(
73 | prometheus.CounterOpts{
74 | Name: "analysis_operations_total",
75 | Help: "Total number of character analysis operations",
76 | },
77 | )
78 |
79 | analysisDuration = promauto.NewHistogram(
80 | prometheus.HistogramOpts{
81 | Name: "analysis_duration_seconds",
82 | Help: "Character analysis operation duration in seconds",
83 | Buckets: prometheus.DefBuckets,
84 | },
85 | )
86 |
87 | dbOperations = promauto.NewCounterVec(
88 | prometheus.CounterOpts{
89 | Name: "db_operations_total",
90 | Help: "Total number of database operations",
91 | },
92 | []string{"operation", "status"},
93 | )
94 |
95 | dbOperationDuration = promauto.NewHistogramVec(
96 | prometheus.HistogramOpts{
97 | Name: "db_operation_duration_seconds",
98 | Help: "Database operation duration in seconds",
99 | Buckets: prometheus.DefBuckets,
100 | },
101 | []string{"operation"},
102 | )
103 | )
104 |
105 | // Middleware creates a middleware for recording HTTP metrics
106 | func Middleware(next http.Handler) http.Handler {
107 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
108 | start := time.Now()
109 |
110 | // Create a response wrapper to capture status and size
111 | rw := &metricsResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}
112 |
113 | // Record request size
114 | if r.ContentLength > 0 {
115 | httpRequestSize.WithLabelValues(r.Method, r.URL.Path).Observe(float64(r.ContentLength))
116 | }
117 |
118 | next.ServeHTTP(rw, r)
119 |
120 | // Record metrics
121 | duration := time.Since(start).Seconds()
122 | status := strconv.Itoa(rw.statusCode)
123 |
124 | httpRequestsTotal.WithLabelValues(r.Method, r.URL.Path, status).Inc()
125 | httpRequestDuration.WithLabelValues(r.Method, r.URL.Path, status).Observe(duration)
126 | httpResponseSize.WithLabelValues(r.Method, r.URL.Path).Observe(float64(rw.bytesWritten))
127 | })
128 | }
129 |
130 | type metricsResponseWriter struct {
131 | http.ResponseWriter
132 | statusCode int
133 | bytesWritten int
134 | }
135 |
136 | func (mrw *metricsResponseWriter) WriteHeader(code int) {
137 | mrw.statusCode = code
138 | mrw.ResponseWriter.WriteHeader(code)
139 | }
140 |
141 | func (mrw *metricsResponseWriter) Write(b []byte) (int, error) {
142 | n, err := mrw.ResponseWriter.Write(b)
143 | mrw.bytesWritten += n
144 | return n, err
145 | }
146 |
147 | // Handler returns the Prometheus metrics HTTP handler
148 | func Handler() http.Handler {
149 | return promhttp.Handler()
150 | }
151 |
152 | // RecordPostsTotal records the total number of posts
153 | func RecordPostsTotal(count int) {
154 | postsTotal.Set(float64(count))
155 | }
156 |
157 | // RecordPostsFetched increments the posts fetched counter
158 | func RecordPostsFetched(count int) {
159 | postsFetched.Add(float64(count))
160 | }
161 |
162 | // RecordPostAdded increments the posts added counter
163 | func RecordPostAdded() {
164 | postsAdded.Inc()
165 | }
166 |
167 | // RecordAnalysisOperation records a character analysis operation
168 | func RecordAnalysisOperation(duration time.Duration) {
169 | analysisOperations.Inc()
170 | analysisDuration.Observe(duration.Seconds())
171 | }
172 |
173 | // RecordDBOperation records a database operation
174 | func RecordDBOperation(operation, status string, duration time.Duration) {
175 | dbOperations.WithLabelValues(operation, status).Inc()
176 | dbOperationDuration.WithLabelValues(operation).Observe(duration.Seconds())
177 | }
178 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | .PHONY: help build run test clean docker-build docker-up docker-down lint format install-tools dev migrate
2 |
3 | # Variables
4 | APP_NAME := post-analyzer
5 | MAIN_FILE := main_new.go
6 | BINARY := $(APP_NAME)
7 | DOCKER_IMAGE := $(APP_NAME):latest
8 | GO := go
9 | GOFLAGS := -v
10 | LDFLAGS := -w -s
11 |
12 | # Colors for output
13 | BLUE := \033[0;34m
14 | GREEN := \033[0;32m
15 | YELLOW := \033[0;33m
16 | NC := \033[0m # No Color
17 |
18 | ## help: Display this help message
19 | help:
20 | @echo "$(BLUE)Post Analyzer Webserver - Makefile Commands$(NC)"
21 | @echo ""
22 | @grep -E '^## ' Makefile | sed 's/## / /' | column -t -s ':'
23 |
24 | ## install: Install dependencies
25 | install:
26 | @echo "$(GREEN)Installing dependencies...$(NC)"
27 | $(GO) mod download
28 | $(GO) mod verify
29 |
30 | ## install-tools: Install development tools
31 | install-tools:
32 | @echo "$(GREEN)Installing development tools...$(NC)"
33 | $(GO) install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
34 | $(GO) install github.com/swaggo/swag/cmd/swag@latest
35 |
36 | ## build: Build the application
37 | build:
38 | @echo "$(GREEN)Building $(APP_NAME)...$(NC)"
39 | $(GO) build $(GOFLAGS) -ldflags="$(LDFLAGS)" -o $(BINARY) $(MAIN_FILE)
40 | @echo "$(GREEN)Build complete: $(BINARY)$(NC)"
41 |
42 | ## run: Run the application
43 | run: build
44 | @echo "$(GREEN)Running $(APP_NAME)...$(NC)"
45 | ./$(BINARY)
46 |
47 | ## dev: Run the application in development mode with file watching
48 | dev:
49 | @echo "$(GREEN)Running in development mode...$(NC)"
50 | @if command -v air > /dev/null; then \
51 | air; \
52 | else \
53 | echo "$(YELLOW)Air not installed. Running normally...$(NC)"; \
54 | $(GO) run $(MAIN_FILE); \
55 | fi
56 |
57 | ## test: Run all tests
58 | test:
59 | @echo "$(GREEN)Running tests...$(NC)"
60 | $(GO) test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
61 |
62 | ## test-coverage: Run tests with coverage report
63 | test-coverage: test
64 | @echo "$(GREEN)Generating coverage report...$(NC)"
65 | $(GO) tool cover -html=coverage.txt -o coverage.html
66 | @echo "$(GREEN)Coverage report generated: coverage.html$(NC)"
67 |
68 | ## lint: Run linter
69 | lint:
70 | @echo "$(GREEN)Running linter...$(NC)"
71 | golangci-lint run --timeout=5m
72 |
73 | ## format: Format Go code
74 | format:
75 | @echo "$(GREEN)Formatting code...$(NC)"
76 | $(GO) fmt ./...
77 | gofmt -s -w .
78 |
79 | ## clean: Clean build artifacts
80 | clean:
81 | @echo "$(YELLOW)Cleaning build artifacts...$(NC)"
82 | rm -f $(BINARY)
83 | rm -f coverage.txt coverage.html
84 | rm -rf dist/
85 | $(GO) clean
86 |
87 | ## docker-build: Build Docker image
88 | docker-build:
89 | @echo "$(GREEN)Building Docker image...$(NC)"
90 | docker build -t $(DOCKER_IMAGE) .
91 |
92 | ## docker-up: Start all services with Docker Compose
93 | docker-up:
94 | @echo "$(GREEN)Starting services...$(NC)"
95 | docker-compose up -d
96 | @echo "$(GREEN)Services started. Application available at http://localhost:8080$(NC)"
97 | @echo "$(GREEN)Prometheus available at http://localhost:9090$(NC)"
98 | @echo "$(GREEN)Grafana available at http://localhost:3000 (admin/admin)$(NC)"
99 |
100 | ## docker-down: Stop all services
101 | docker-down:
102 | @echo "$(YELLOW)Stopping services...$(NC)"
103 | docker-compose down
104 |
105 | ## docker-logs: View logs from all services
106 | docker-logs:
107 | docker-compose logs -f
108 |
109 | ## docker-restart: Restart all services
110 | docker-restart: docker-down docker-up
111 |
112 | ## migrate: Run database migrations
113 | migrate:
114 | @echo "$(GREEN)Running database migrations...$(NC)"
115 | @echo "$(YELLOW)Migrations are automatically handled by the application$(NC)"
116 |
117 | ## db-shell: Connect to PostgreSQL database
118 | db-shell:
119 | @echo "$(GREEN)Connecting to database...$(NC)"
120 | docker-compose exec postgres psql -U postgres -d postanalyzer
121 |
122 | ## benchmark: Run benchmarks
123 | benchmark:
124 | @echo "$(GREEN)Running benchmarks...$(NC)"
125 | $(GO) test -bench=. -benchmem ./...
126 |
127 | ## security: Run security checks
128 | security:
129 | @echo "$(GREEN)Running security checks...$(NC)"
130 | @if command -v gosec > /dev/null; then \
131 | gosec ./...; \
132 | else \
133 | echo "$(YELLOW)gosec not installed. Install with: go install github.com/securego/gosec/v2/cmd/gosec@latest$(NC)"; \
134 | fi
135 |
136 | ## deps-update: Update dependencies
137 | deps-update:
138 | @echo "$(GREEN)Updating dependencies...$(NC)"
139 | $(GO) get -u ./...
140 | $(GO) mod tidy
141 |
142 | ## check: Run all checks (lint, test, security)
143 | check: lint test security
144 | @echo "$(GREEN)All checks passed!$(NC)"
145 |
146 | ## prod-build: Build for production
147 | prod-build:
148 | @echo "$(GREEN)Building for production...$(NC)"
149 | CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GO) build -ldflags="$(LDFLAGS)" -o $(BINARY) $(MAIN_FILE)
150 | @echo "$(GREEN)Production build complete$(NC)"
151 |
152 | ## init: Initialize development environment
153 | init: install install-tools
154 | @echo "$(GREEN)Creating .env file from example...$(NC)"
155 | @if [ ! -f .env ]; then cp .env.example .env 2>/dev/null || echo "$(YELLOW)No .env.example found$(NC)"; fi
156 | @echo "$(GREEN)Development environment ready!$(NC)"
157 |
158 | ## version: Display version information
159 | version:
160 | @echo "$(BLUE)Post Analyzer Webserver$(NC)"
161 | @echo "Go version: $$($(GO) version)"
162 | @echo "Git commit: $$(git rev-parse --short HEAD 2>/dev/null || echo 'N/A')"
163 |
164 | .DEFAULT_GOAL := help
165 |
--------------------------------------------------------------------------------
/internal/models/models.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "time"
5 | )
6 |
7 | // Post represents a post in the system
8 | type Post struct {
9 | ID int `json:"id" db:"id"`
10 | UserID int `json:"userId" db:"user_id"`
11 | Title string `json:"title" db:"title"`
12 | Body string `json:"body" db:"body"`
13 | CreatedAt time.Time `json:"createdAt" db:"created_at"`
14 | UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
15 | }
16 |
17 | // CreatePostRequest represents a request to create a post
18 | type CreatePostRequest struct {
19 | UserID int `json:"userId"`
20 | Title string `json:"title" validate:"required,min=1,max=500"`
21 | Body string `json:"body" validate:"required,min=1,max=10000"`
22 | }
23 |
24 | // UpdatePostRequest represents a request to update a post
25 | type UpdatePostRequest struct {
26 | UserID int `json:"userId,omitempty"`
27 | Title string `json:"title,omitempty" validate:"omitempty,min=1,max=500"`
28 | Body string `json:"body,omitempty" validate:"omitempty,min=1,max=10000"`
29 | }
30 |
31 | // PostFilter represents filtering options for posts
32 | type PostFilter struct {
33 | UserID *int `json:"userId,omitempty"`
34 | Search string `json:"search,omitempty"`
35 | SortBy string `json:"sortBy,omitempty"` // id, title, createdAt, updatedAt
36 | SortOrder string `json:"sortOrder,omitempty"` // asc, desc
37 | }
38 |
39 | // PaginationParams represents pagination parameters
40 | type PaginationParams struct {
41 | Page int `json:"page"`
42 | PageSize int `json:"pageSize"`
43 | Offset int `json:"-"`
44 | }
45 |
46 | // PaginatedResponse represents a paginated API response
47 | type PaginatedResponse struct {
48 | Data interface{} `json:"data"`
49 | Pagination PaginationMeta `json:"pagination"`
50 | Meta *ResponseMeta `json:"meta,omitempty"`
51 | }
52 |
53 | // PaginationMeta contains pagination metadata
54 | type PaginationMeta struct {
55 | Page int `json:"page"`
56 | PageSize int `json:"pageSize"`
57 | TotalItems int `json:"totalItems"`
58 | TotalPages int `json:"totalPages"`
59 | HasNext bool `json:"hasNext"`
60 | HasPrev bool `json:"hasPrev"`
61 | }
62 |
63 | // ResponseMeta contains additional response metadata
64 | type ResponseMeta struct {
65 | RequestID string `json:"requestId,omitempty"`
66 | Timestamp time.Time `json:"timestamp"`
67 | Duration time.Duration `json:"duration,omitempty"`
68 | }
69 |
70 | // AnalyticsResult represents character frequency analysis results
71 | type AnalyticsResult struct {
72 | TotalPosts int `json:"totalPosts"`
73 | TotalCharacters int `json:"totalCharacters"`
74 | UniqueChars int `json:"uniqueChars"`
75 | CharFrequency map[rune]int `json:"charFrequency"`
76 | TopCharacters []CharacterStat `json:"topCharacters"`
77 | Statistics *AnalyticsStats `json:"statistics,omitempty"`
78 | }
79 |
80 | // CharacterStat represents statistics for a single character
81 | type CharacterStat struct {
82 | Character rune `json:"character"`
83 | Count int `json:"count"`
84 | Frequency float64 `json:"frequency"`
85 | }
86 |
87 | // AnalyticsStats represents overall analytics statistics
88 | type AnalyticsStats struct {
89 | AveragePostLength float64 `json:"averagePostLength"`
90 | MedianPostLength int `json:"medianPostLength"`
91 | PostsPerUser map[int]int `json:"postsPerUser"`
92 | TimeDistribution map[string]int `json:"timeDistribution"`
93 | }
94 |
95 | // BulkCreateRequest represents a bulk create request
96 | type BulkCreateRequest struct {
97 | Posts []CreatePostRequest `json:"posts" validate:"required,min=1,max=1000"`
98 | }
99 |
100 | // BulkCreateResponse represents a bulk create response
101 | type BulkCreateResponse struct {
102 | Created int `json:"created"`
103 | Failed int `json:"failed"`
104 | Errors []string `json:"errors,omitempty"`
105 | PostIDs []int `json:"postIds,omitempty"`
106 | }
107 |
108 | // ExportFormat represents export file format
109 | type ExportFormat string
110 |
111 | const (
112 | ExportFormatJSON ExportFormat = "json"
113 | ExportFormatCSV ExportFormat = "csv"
114 | )
115 |
116 | // HealthResponse represents health check response
117 | type HealthResponse struct {
118 | Status string `json:"status"`
119 | Timestamp time.Time `json:"timestamp"`
120 | Version string `json:"version,omitempty"`
121 | Uptime time.Duration `json:"uptime,omitempty"`
122 | Checks map[string]bool `json:"checks,omitempty"`
123 | }
124 |
125 | // User represents a user in the system (for future auth)
126 | type User struct {
127 | ID int `json:"id" db:"id"`
128 | Email string `json:"email" db:"email"`
129 | Username string `json:"username" db:"username"`
130 | Role string `json:"role" db:"role"`
131 | CreatedAt time.Time `json:"createdAt" db:"created_at"`
132 | UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
133 | }
134 |
135 | // AuditLog represents an audit log entry
136 | type AuditLog struct {
137 | ID int `json:"id" db:"id"`
138 | UserID int `json:"userId" db:"user_id"`
139 | Action string `json:"action" db:"action"`
140 | Resource string `json:"resource" db:"resource"`
141 | ResourceID int `json:"resourceId" db:"resource_id"`
142 | Changes string `json:"changes,omitempty" db:"changes"`
143 | IPAddress string `json:"ipAddress" db:"ip_address"`
144 | UserAgent string `json:"userAgent" db:"user_agent"`
145 | CreatedAt time.Time `json:"createdAt" db:"created_at"`
146 | }
147 |
--------------------------------------------------------------------------------
/assets/post-analyzer.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "html/template"
7 | "io/ioutil"
8 | "net/http"
9 | "os"
10 | "sync"
11 | )
12 |
13 | // Post struct to map the JSON data
14 | type Post struct {
15 | UserId int `json:"userId"`
16 | Id int `json:"id"`
17 | Title string `json:"title"`
18 | Body string `json:"body"`
19 | }
20 |
21 | // Template variables
22 | type HomePageVars struct {
23 | Title string
24 | Posts []Post
25 | CharFreq map[rune]int
26 | Error string
27 | HasPosts bool
28 | HasAnalysis bool
29 | }
30 |
31 | // Custom template functions
32 | var funcMap = template.FuncMap{
33 | "toJSON": func(v interface{}) string {
34 | data, _ := json.Marshal(v)
35 | return string(data)
36 | },
37 | }
38 |
39 | var templates = template.Must(template.New("").Funcs(funcMap).ParseFiles("home.html"))
40 |
41 | func main() {
42 | http.HandleFunc("/", HomeHandler)
43 | http.HandleFunc("/fetch", FetchPostsHandler)
44 | http.HandleFunc("/analyze", AnalyzePostsHandler)
45 | http.HandleFunc("/add", AddPostHandler)
46 |
47 | fmt.Println("Server starting at http://localhost:8080/")
48 | _ = http.ListenAndServe(":8080", nil)
49 | }
50 |
51 | // HomeHandler serves the home page
52 | func HomeHandler(w http.ResponseWriter, r *http.Request) {
53 | posts, err := readPostsFromFile()
54 | if err != nil {
55 | renderTemplate(w, HomePageVars{Title: "Home", Error: "Failed to read posts: " + err.Error()})
56 | return
57 | }
58 | renderTemplate(w, HomePageVars{Title: "Home", Posts: posts, HasPosts: len(posts) > 0})
59 | }
60 |
61 | // FetchPostsHandler fetches posts and writes them to a file
62 | func FetchPostsHandler(w http.ResponseWriter, r *http.Request) {
63 | posts, err := fetchPosts()
64 | if err != nil {
65 | renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to fetch posts: " + err.Error()})
66 | return
67 | }
68 |
69 | if err := writePostsToFile(posts); err != nil {
70 | renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to write posts to file: " + err.Error()})
71 | return
72 | }
73 |
74 | renderTemplate(w, HomePageVars{Title: "Posts Fetched", Posts: posts, HasPosts: true})
75 | }
76 |
77 | // AnalyzePostsHandler reads the posts file and analyzes character frequency
78 | func AnalyzePostsHandler(w http.ResponseWriter, r *http.Request) {
79 | count, err := countCharacters("posts.json")
80 | if err != nil {
81 | renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to analyze posts: " + err.Error()})
82 | return
83 | }
84 |
85 | renderTemplate(w, HomePageVars{Title: "Character Analysis", CharFreq: count, HasAnalysis: true})
86 | }
87 |
88 | // AddPostHandler allows the user to add a new post
89 | func AddPostHandler(w http.ResponseWriter, r *http.Request) {
90 | if r.Method == http.MethodPost {
91 | var post Post
92 | post.UserId = 1 // You can set this as needed
93 | post.Id = generatePostID()
94 | post.Title = r.FormValue("title")
95 | post.Body = r.FormValue("body")
96 |
97 | posts, err := readPostsFromFile()
98 | if err != nil {
99 | renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to read posts: " + err.Error()})
100 | return
101 | }
102 |
103 | posts = append(posts, post)
104 |
105 | if err := writePostsToFile(posts); err != nil {
106 | renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to write post to file: " + err.Error()})
107 | return
108 | }
109 |
110 | renderTemplate(w, HomePageVars{Title: "Post Added", Posts: posts, HasPosts: true})
111 | } else {
112 | renderTemplate(w, HomePageVars{Title: "Add New Post"})
113 | }
114 | }
115 |
116 | func fetchPosts() ([]Post, error) {
117 | resp, err := http.Get("https://jsonplaceholder.typicode.com/posts")
118 | if err != nil {
119 | return nil, err
120 | }
121 | defer resp.Body.Close()
122 |
123 | var posts []Post
124 | if err := json.NewDecoder(resp.Body).Decode(&posts); err != nil {
125 | return nil, err
126 | }
127 | return posts, nil
128 | }
129 |
130 | func writePostsToFile(posts []Post) error {
131 | file, err := os.Create("posts.json")
132 | if err != nil {
133 | return err
134 | }
135 | defer file.Close()
136 |
137 | encoder := json.NewEncoder(file)
138 | if err := encoder.Encode(posts); err != nil {
139 | return err
140 | }
141 | return nil
142 | }
143 |
144 | func readPostsFromFile() ([]Post, error) {
145 | data, err := ioutil.ReadFile("posts.json")
146 | if err != nil {
147 | return nil, err
148 | }
149 |
150 | var posts []Post
151 | if err := json.Unmarshal(data, &posts); err != nil {
152 | return nil, err
153 | }
154 | return posts, nil
155 | }
156 |
157 | func countCharacters(filePath string) (map[rune]int, error) {
158 | data, err := ioutil.ReadFile(filePath)
159 | if err != nil {
160 | return nil, err
161 | }
162 |
163 | charCount := make(map[rune]int)
164 | mu := sync.Mutex{}
165 | wg := sync.WaitGroup{}
166 |
167 | for _, byteValue := range string(data) {
168 | wg.Add(1)
169 | go func(c rune) {
170 | defer wg.Done()
171 | mu.Lock()
172 | charCount[c]++
173 | mu.Unlock()
174 | }(rune(byteValue))
175 | }
176 |
177 | wg.Wait()
178 | return charCount, nil
179 | }
180 |
181 | func renderTemplate(w http.ResponseWriter, vars HomePageVars) {
182 | if err := templates.ExecuteTemplate(w, "home.html", vars); err != nil {
183 | http.Error(w, "Failed to render template", http.StatusInternalServerError)
184 | }
185 | }
186 |
187 | func generatePostID() int {
188 | posts, _ := readPostsFromFile()
189 | maxID := 0
190 | for _, post := range posts {
191 | if post.Id > maxID {
192 | maxID = post.Id
193 | }
194 | }
195 | return maxID + 1
196 | }
197 |
--------------------------------------------------------------------------------
/.github/workflows/ci-cd.yml:
--------------------------------------------------------------------------------
1 | name: CI/CD Pipeline
2 |
3 | on:
4 | push:
5 | branches: [ main, master, claude/* ]
6 | pull_request:
7 | branches: [ main, master ]
8 |
9 | env:
10 | GO_VERSION: '1.21'
11 | DOCKER_IMAGE: post-analyzer
12 |
13 | jobs:
14 | # Linting and code quality
15 | lint:
16 | name: Lint Code
17 | runs-on: ubuntu-latest
18 | steps:
19 | - name: Checkout code
20 | uses: actions/checkout@v4
21 |
22 | - name: Set up Go
23 | uses: actions/setup-go@v5
24 | with:
25 | go-version: ${{ env.GO_VERSION }}
26 |
27 | - name: Run golangci-lint
28 | uses: golangci/golangci-lint-action@v4
29 | with:
30 | version: latest
31 | args: --timeout=5m
32 |
33 | # Unit and integration tests
34 | test:
35 | name: Run Tests
36 | runs-on: ubuntu-latest
37 | services:
38 | postgres:
39 | image: postgres:16-alpine
40 | env:
41 | POSTGRES_DB: testdb
42 | POSTGRES_USER: postgres
43 | POSTGRES_PASSWORD: postgres
44 | ports:
45 | - 5432:5432
46 | options: >-
47 | --health-cmd pg_isready
48 | --health-interval 10s
49 | --health-timeout 5s
50 | --health-retries 5
51 |
52 | steps:
53 | - name: Checkout code
54 | uses: actions/checkout@v4
55 |
56 | - name: Set up Go
57 | uses: actions/setup-go@v5
58 | with:
59 | go-version: ${{ env.GO_VERSION }}
60 |
61 | - name: Cache Go modules
62 | uses: actions/cache@v4
63 | with:
64 | path: |
65 | ~/.cache/go-build
66 | ~/go/pkg/mod
67 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
68 | restore-keys: |
69 | ${{ runner.os }}-go-
70 |
71 | - name: Download dependencies
72 | run: go mod download
73 |
74 | - name: Run tests
75 | run: go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
76 | env:
77 | DB_HOST: localhost
78 | DB_PORT: 5432
79 | DB_USER: postgres
80 | DB_PASSWORD: postgres
81 | DB_NAME: testdb
82 |
83 | - name: Upload coverage to Codecov
84 | uses: codecov/codecov-action@v4
85 | with:
86 | file: ./coverage.txt
87 | fail_ci_if_error: false
88 |
89 | # Build and verify
90 | build:
91 | name: Build Application
92 | runs-on: ubuntu-latest
93 | needs: [lint, test]
94 | steps:
95 | - name: Checkout code
96 | uses: actions/checkout@v4
97 |
98 | - name: Set up Go
99 | uses: actions/setup-go@v5
100 | with:
101 | go-version: ${{ env.GO_VERSION }}
102 |
103 | - name: Build application
104 | run: |
105 | go build -v -ldflags="-w -s" -o post-analyzer main_new.go
106 |
107 | - name: Upload build artifact
108 | uses: actions/upload-artifact@v4
109 | with:
110 | name: post-analyzer
111 | path: post-analyzer
112 | retention-days: 1
113 |
114 | # Docker build and push
115 | docker:
116 | name: Build and Push Docker Image
117 | runs-on: ubuntu-latest
118 | needs: [build]
119 | if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
120 | steps:
121 | - name: Checkout code
122 | uses: actions/checkout@v4
123 |
124 | - name: Set up Docker Buildx
125 | uses: docker/setup-buildx-action@v3
126 |
127 | - name: Log in to Docker Hub
128 | uses: docker/login-action@v3
129 | with:
130 | username: ${{ secrets.DOCKER_USERNAME }}
131 | password: ${{ secrets.DOCKER_PASSWORD }}
132 | if: github.event_name == 'push'
133 |
134 | - name: Extract metadata
135 | id: meta
136 | uses: docker/metadata-action@v5
137 | with:
138 | images: ${{ secrets.DOCKER_USERNAME }}/${{ env.DOCKER_IMAGE }}
139 | tags: |
140 | type=ref,event=branch
141 | type=ref,event=pr
142 | type=semver,pattern={{version}}
143 | type=semver,pattern={{major}}.{{minor}}
144 | type=sha,prefix={{branch}}-
145 | type=raw,value=latest,enable={{is_default_branch}}
146 |
147 | - name: Build and push Docker image
148 | uses: docker/build-push-action@v5
149 | with:
150 | context: .
151 | push: ${{ github.event_name == 'push' }}
152 | tags: ${{ steps.meta.outputs.tags }}
153 | labels: ${{ steps.meta.outputs.labels }}
154 | cache-from: type=gha
155 | cache-to: type=gha,mode=max
156 |
157 | # Security scanning
158 | security:
159 | name: Security Scan
160 | runs-on: ubuntu-latest
161 | steps:
162 | - name: Checkout code
163 | uses: actions/checkout@v4
164 |
165 | - name: Run Trivy vulnerability scanner
166 | uses: aquasecurity/trivy-action@master
167 | with:
168 | scan-type: 'fs'
169 | scan-ref: '.'
170 | format: 'sarif'
171 | output: 'trivy-results.sarif'
172 |
173 | - name: Upload Trivy results to GitHub Security
174 | uses: github/codeql-action/upload-sarif@v3
175 | with:
176 | sarif_file: 'trivy-results.sarif'
177 |
178 | # Deployment (optional - customize for your deployment target)
179 | deploy:
180 | name: Deploy Application
181 | runs-on: ubuntu-latest
182 | needs: [docker]
183 | if: github.event_name == 'push' && github.ref == 'refs/heads/main'
184 | steps:
185 | - name: Checkout code
186 | uses: actions/checkout@v4
187 |
188 | - name: Deploy to production
189 | run: |
190 | echo "Add your deployment steps here"
191 | echo "Examples: kubectl apply, helm upgrade, SSH to server, etc."
192 | # Uncomment and customize based on your deployment method:
193 | # - name: Deploy to Kubernetes
194 | # run: |
195 | # kubectl set image deployment/post-analyzer post-analyzer=${{ secrets.DOCKER_USERNAME }}/${{ env.DOCKER_IMAGE }}:latest
196 | #
197 | # - name: Deploy to Render
198 | # run: |
199 | # curl -X POST ${{ secrets.RENDER_DEPLOY_HOOK }}
200 |
--------------------------------------------------------------------------------
/internal/migrations/migrations.go:
--------------------------------------------------------------------------------
1 | package migrations
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "time"
8 |
9 | "Post_Analyzer_Webserver/internal/logger"
10 | )
11 |
12 | // Migration represents a database migration
13 | type Migration struct {
14 | Version int
15 | Description string
16 | Up func(*sql.DB) error
17 | Down func(*sql.DB) error
18 | }
19 |
20 | // Migrator handles database migrations
21 | type Migrator struct {
22 | db *sql.DB
23 | migrations []Migration
24 | }
25 |
26 | // NewMigrator creates a new migrator
27 | func NewMigrator(db *sql.DB) *Migrator {
28 | return &Migrator{
29 | db: db,
30 | migrations: getMigrations(),
31 | }
32 | }
33 |
34 | // Migrate runs all pending migrations
35 | func (m *Migrator) Migrate(ctx context.Context) error {
36 | // Create migrations table if it doesn't exist
37 | if err := m.createMigrationsTable(); err != nil {
38 | return fmt.Errorf("failed to create migrations table: %w", err)
39 | }
40 |
41 | // Get current version
42 | currentVersion, err := m.getCurrentVersion()
43 | if err != nil {
44 | return fmt.Errorf("failed to get current version: %w", err)
45 | }
46 |
47 | logger.Info("starting migrations", "current_version", currentVersion)
48 |
49 | // Run pending migrations
50 | for _, migration := range m.migrations {
51 | if migration.Version <= currentVersion {
52 | continue
53 | }
54 |
55 | logger.Info("running migration", "version", migration.Version, "description", migration.Description)
56 |
57 | // Begin transaction
58 | tx, err := m.db.Begin()
59 | if err != nil {
60 | return fmt.Errorf("failed to begin transaction: %w", err)
61 | }
62 |
63 | // Run migration
64 | if err := migration.Up(m.db); err != nil {
65 | _ = tx.Rollback()
66 | return fmt.Errorf("migration %d failed: %w", migration.Version, err)
67 | }
68 |
69 | // Update version
70 | if err := m.updateVersion(tx, migration.Version, migration.Description); err != nil {
71 | _ = tx.Rollback()
72 | return fmt.Errorf("failed to update version: %w", err)
73 | }
74 |
75 | // Commit transaction
76 | if err := tx.Commit(); err != nil {
77 | return fmt.Errorf("failed to commit migration: %w", err)
78 | }
79 |
80 | logger.Info("migration completed", "version", migration.Version)
81 | }
82 |
83 | logger.Info("all migrations completed")
84 | return nil
85 | }
86 |
87 | // createMigrationsTable creates the migrations tracking table
88 | func (m *Migrator) createMigrationsTable() error {
89 | query := `
90 | CREATE TABLE IF NOT EXISTS schema_migrations (
91 | id SERIAL PRIMARY KEY,
92 | version INTEGER NOT NULL UNIQUE,
93 | description TEXT NOT NULL,
94 | applied_at TIMESTAMP NOT NULL DEFAULT NOW()
95 | )`
96 |
97 | _, err := m.db.Exec(query)
98 | return err
99 | }
100 |
101 | // getCurrentVersion gets the current migration version
102 | func (m *Migrator) getCurrentVersion() (int, error) {
103 | var version int
104 | err := m.db.QueryRow("SELECT COALESCE(MAX(version), 0) FROM schema_migrations").Scan(&version)
105 | if err != nil {
106 | return 0, err
107 | }
108 | return version, nil
109 | }
110 |
111 | // updateVersion records a completed migration
112 | func (m *Migrator) updateVersion(tx *sql.Tx, version int, description string) error {
113 | query := "INSERT INTO schema_migrations (version, description, applied_at) VALUES ($1, $2, $3)"
114 | _, err := tx.Exec(query, version, description, time.Now())
115 | return err
116 | }
117 |
118 | // getMigrations returns all migrations in order
119 | func getMigrations() []Migration {
120 | return []Migration{
121 | {
122 | Version: 1,
123 | Description: "Create posts table",
124 | Up: func(db *sql.DB) error {
125 | query := `
126 | CREATE TABLE IF NOT EXISTS posts (
127 | id SERIAL PRIMARY KEY,
128 | user_id INTEGER NOT NULL,
129 | title VARCHAR(500) NOT NULL,
130 | body TEXT NOT NULL,
131 | created_at TIMESTAMP NOT NULL DEFAULT NOW(),
132 | updated_at TIMESTAMP NOT NULL DEFAULT NOW()
133 | );
134 |
135 | CREATE INDEX IF NOT EXISTS idx_posts_user_id ON posts(user_id);
136 | CREATE INDEX IF NOT EXISTS idx_posts_created_at ON posts(created_at DESC);
137 | `
138 | _, err := db.Exec(query)
139 | return err
140 | },
141 | Down: func(db *sql.DB) error {
142 | _, err := db.Exec("DROP TABLE IF EXISTS posts")
143 | return err
144 | },
145 | },
146 | {
147 | Version: 2,
148 | Description: "Create audit_logs table",
149 | Up: func(db *sql.DB) error {
150 | query := `
151 | CREATE TABLE IF NOT EXISTS audit_logs (
152 | id SERIAL PRIMARY KEY,
153 | user_id INTEGER NOT NULL,
154 | action VARCHAR(50) NOT NULL,
155 | resource VARCHAR(50) NOT NULL,
156 | resource_id INTEGER NOT NULL,
157 | changes TEXT,
158 | ip_address VARCHAR(45),
159 | user_agent TEXT,
160 | created_at TIMESTAMP NOT NULL DEFAULT NOW()
161 | );
162 |
163 | CREATE INDEX IF NOT EXISTS idx_audit_logs_user_id ON audit_logs(user_id);
164 | CREATE INDEX IF NOT EXISTS idx_audit_logs_resource ON audit_logs(resource, resource_id);
165 | CREATE INDEX IF NOT EXISTS idx_audit_logs_created_at ON audit_logs(created_at DESC);
166 | `
167 | _, err := db.Exec(query)
168 | return err
169 | },
170 | Down: func(db *sql.DB) error {
171 | _, err := db.Exec("DROP TABLE IF EXISTS audit_logs")
172 | return err
173 | },
174 | },
175 | {
176 | Version: 3,
177 | Description: "Add full-text search indexes",
178 | Up: func(db *sql.DB) error {
179 | query := `
180 | CREATE INDEX IF NOT EXISTS idx_posts_title_trgm ON posts USING gin(title gin_trgm_ops);
181 | CREATE INDEX IF NOT EXISTS idx_posts_body_trgm ON posts USING gin(body gin_trgm_ops);
182 | `
183 | _, err := db.Exec(query)
184 | if err != nil {
185 | // If pg_trgm extension doesn't exist, skip this migration
186 | logger.Warn("failed to create full-text search indexes, pg_trgm extension may not be enabled")
187 | return nil
188 | }
189 | return err
190 | },
191 | Down: func(db *sql.DB) error {
192 | query := `
193 | DROP INDEX IF EXISTS idx_posts_title_trgm;
194 | DROP INDEX IF EXISTS idx_posts_body_trgm;
195 | `
196 | _, err := db.Exec(query)
197 | return err
198 | },
199 | },
200 | }
201 | }
202 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "net/http"
8 | "os"
9 | "os/signal"
10 | "syscall"
11 | "time"
12 |
13 | "Post_Analyzer_Webserver/config"
14 | "Post_Analyzer_Webserver/internal/api"
15 | "Post_Analyzer_Webserver/internal/cache"
16 | "Post_Analyzer_Webserver/internal/handlers"
17 | "Post_Analyzer_Webserver/internal/logger"
18 | "Post_Analyzer_Webserver/internal/metrics"
19 | "Post_Analyzer_Webserver/internal/middleware"
20 | "Post_Analyzer_Webserver/internal/migrations"
21 | "Post_Analyzer_Webserver/internal/service"
22 | "Post_Analyzer_Webserver/internal/storage"
23 |
24 | _ "github.com/lib/pq"
25 | )
26 |
27 | var (
28 | version = "2.0.0"
29 | buildTime = time.Now().Format(time.RFC3339)
30 | startTime = time.Now()
31 | )
32 |
33 | func main() {
34 | // Load configuration
35 | cfg, err := config.Load()
36 | if err != nil {
37 | fmt.Fprintf(os.Stderr, "Failed to load configuration: %v\n", err)
38 | os.Exit(1)
39 | }
40 |
41 | // Initialize logger
42 | if err := logger.Init(&cfg.Logging); err != nil {
43 | fmt.Fprintf(os.Stderr, "Failed to initialize logger: %v\n", err)
44 | os.Exit(1)
45 | }
46 |
47 | logger.Info("starting Post Analyzer Webserver",
48 | "version", version,
49 | "environment", cfg.Server.Environment,
50 | "port", cfg.Server.Port,
51 | "database_type", cfg.Database.Type,
52 | )
53 |
54 | // Initialize storage
55 | var store storage.Storage
56 | var db *sql.DB
57 |
58 | if cfg.Database.Type == "postgres" {
59 | pgStore, err := storage.NewPostgresStorage(&cfg.Database)
60 | if err != nil {
61 | logger.Error("failed to initialize PostgreSQL storage", "error", err)
62 | os.Exit(1)
63 | }
64 | store = pgStore
65 |
66 | // Get underlying DB for migrations
67 | dsn := fmt.Sprintf(
68 | "host=%s port=%s user=%s password=%s dbname=%s sslmode=%s",
69 | cfg.Database.Host, cfg.Database.Port, cfg.Database.User,
70 | cfg.Database.Password, cfg.Database.DBName, cfg.Database.SSLMode,
71 | )
72 | db, err = sql.Open("postgres", dsn)
73 | if err != nil {
74 | logger.Error("failed to open database for migrations", "error", err)
75 | os.Exit(1)
76 | }
77 | defer db.Close()
78 |
79 | // Run migrations
80 | logger.Info("running database migrations...")
81 | migrator := migrations.NewMigrator(db)
82 | if err := migrator.Migrate(context.Background()); err != nil {
83 | logger.Error("migration failed", "error", err)
84 | os.Exit(1)
85 | }
86 |
87 | logger.Info("using PostgreSQL storage")
88 | } else {
89 | fileStore, err := storage.NewFileStorage(cfg.Database.FilePath)
90 | if err != nil {
91 | logger.Error("failed to initialize file storage", "error", err)
92 | os.Exit(1)
93 | }
94 | store = fileStore
95 | logger.Info("using file storage", "path", cfg.Database.FilePath)
96 | }
97 | defer store.Close()
98 |
99 | // Initialize cache
100 | _ = cache.NewCache(cfg) // Cache initialized for future use
101 | logger.Info("cache initialized", "type", "memory")
102 |
103 | // Initialize service layer
104 | postService := service.NewPostService(store)
105 | logger.Info("service layer initialized")
106 |
107 | // Initialize API handlers
108 | apiHandler := api.NewAPI(postService)
109 | apiRouter := api.NewRouter(apiHandler)
110 | logger.Info("API handlers initialized")
111 |
112 | // Initialize web handlers
113 | webHandlers, err := handlers.New(store, cfg)
114 | if err != nil {
115 | logger.Error("failed to initialize web handlers", "error", err)
116 | os.Exit(1)
117 | }
118 | defer webHandlers.Close()
119 |
120 | // Setup HTTP router
121 | mux := http.NewServeMux()
122 |
123 | // Health and monitoring endpoints
124 | mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
125 | uptime := time.Since(startTime)
126 | w.Header().Set("Content-Type", "application/json")
127 | w.WriteHeader(http.StatusOK)
128 | fmt.Fprintf(w, `{"status":"healthy","version":"%s","uptime":"%s","timestamp":"%s"}`,
129 | version, uptime, time.Now().Format(time.RFC3339))
130 | })
131 | mux.HandleFunc("/readiness", webHandlers.Readiness)
132 | mux.Handle("/metrics", metrics.Handler())
133 |
134 | // API endpoints (v1)
135 | mux.Handle("/api/", apiRouter)
136 | mux.Handle("/api/v1/", apiRouter)
137 |
138 | // Web interface endpoints
139 | mux.HandleFunc("/", webHandlers.Home)
140 | mux.HandleFunc("/fetch", webHandlers.FetchPosts)
141 | mux.HandleFunc("/analyze", webHandlers.AnalyzePosts)
142 | mux.HandleFunc("/add", webHandlers.AddPost)
143 |
144 | // Serve static assets
145 | mux.Handle("/assets/", http.StripPrefix("/assets/", http.FileServer(http.Dir("assets"))))
146 |
147 | // Create rate limiter
148 | rateLimiter := middleware.NewRateLimiter(
149 | cfg.Security.RateLimitRequests,
150 | cfg.Security.RateLimitWindow,
151 | )
152 |
153 | // Apply middleware chain
154 | handler := middleware.Chain(
155 | middleware.RequestID,
156 | middleware.Logging,
157 | middleware.Recovery,
158 | middleware.SecurityHeaders,
159 | middleware.CORS(cfg.Security.AllowedOrigins),
160 | rateLimiter.Middleware,
161 | middleware.MaxBodySize(cfg.Security.MaxBodySize),
162 | middleware.Compression,
163 | metrics.Middleware,
164 | )(mux)
165 |
166 | // Create HTTP server with production settings
167 | server := &http.Server{
168 | Addr: fmt.Sprintf("%s:%s", cfg.Server.Host, cfg.Server.Port),
169 | Handler: handler,
170 | ReadTimeout: cfg.Server.ReadTimeout,
171 | WriteTimeout: cfg.Server.WriteTimeout,
172 | IdleTimeout: cfg.Server.IdleTimeout,
173 | }
174 |
175 | // Start server in a goroutine
176 | go func() {
177 | logger.Info("server listening",
178 | "address", server.Addr,
179 | "read_timeout", cfg.Server.ReadTimeout,
180 | "write_timeout", cfg.Server.WriteTimeout,
181 | )
182 | logger.Info("endpoints available",
183 | "web", fmt.Sprintf("http://%s:%s/", cfg.Server.Host, cfg.Server.Port),
184 | "api", fmt.Sprintf("http://%s:%s/api/v1/posts", cfg.Server.Host, cfg.Server.Port),
185 | "health", fmt.Sprintf("http://%s:%s/health", cfg.Server.Host, cfg.Server.Port),
186 | "metrics", fmt.Sprintf("http://%s:%s/metrics", cfg.Server.Host, cfg.Server.Port),
187 | )
188 |
189 | if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
190 | logger.Error("server failed to start", "error", err)
191 | os.Exit(1)
192 | }
193 | }()
194 |
195 | // Wait for interrupt signal for graceful shutdown
196 | quit := make(chan os.Signal, 1)
197 | signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
198 | <-quit
199 |
200 | logger.Info("shutting down server gracefully...")
201 |
202 | // Create shutdown context with timeout
203 | ctx, cancel := context.WithTimeout(context.Background(), cfg.Server.ShutdownTimeout)
204 | defer cancel()
205 |
206 | // Attempt graceful shutdown
207 | if err := server.Shutdown(ctx); err != nil {
208 | logger.Error("server forced to shutdown", "error", err)
209 | os.Exit(1)
210 | }
211 |
212 | logger.Info("server stopped gracefully")
213 | }
214 |
--------------------------------------------------------------------------------
/config/config.go:
--------------------------------------------------------------------------------
1 | package config
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "strconv"
7 | "time"
8 | )
9 |
10 | // Config holds all configuration for the application
11 | type Config struct {
12 | Server ServerConfig
13 | Database DatabaseConfig
14 | Security SecurityConfig
15 | Logging LoggingConfig
16 | External ExternalConfig
17 | }
18 |
19 | // ServerConfig contains server-related configuration
20 | type ServerConfig struct {
21 | Port string
22 | Host string
23 | ReadTimeout time.Duration
24 | WriteTimeout time.Duration
25 | IdleTimeout time.Duration
26 | ShutdownTimeout time.Duration
27 | Environment string
28 | }
29 |
30 | // DatabaseConfig contains database-related configuration
31 | type DatabaseConfig struct {
32 | Type string // "file" or "postgres"
33 | FilePath string
34 | Host string
35 | Port string
36 | User string
37 | Password string
38 | DBName string
39 | SSLMode string
40 | MaxConns int
41 | MinConns int
42 | }
43 |
44 | // SecurityConfig contains security-related configuration
45 | type SecurityConfig struct {
46 | RateLimitRequests int
47 | RateLimitWindow time.Duration
48 | MaxBodySize int64
49 | AllowedOrigins []string
50 | TrustedProxies []string
51 | }
52 |
53 | // LoggingConfig contains logging-related configuration
54 | type LoggingConfig struct {
55 | Level string
56 | Format string // "json" or "text"
57 | Output string // "stdout" or file path
58 | TimeFormat string
59 | }
60 |
61 | // ExternalConfig contains external service configuration
62 | type ExternalConfig struct {
63 | JSONPlaceholderURL string
64 | HTTPTimeout time.Duration
65 | }
66 |
67 | // Load reads configuration from environment variables with sensible defaults
68 | func Load() (*Config, error) {
69 | cfg := &Config{
70 | Server: ServerConfig{
71 | Port: getEnv("PORT", "8080"),
72 | Host: getEnv("HOST", "0.0.0.0"),
73 | ReadTimeout: getDurationEnv("READ_TIMEOUT", 15*time.Second),
74 | WriteTimeout: getDurationEnv("WRITE_TIMEOUT", 15*time.Second),
75 | IdleTimeout: getDurationEnv("IDLE_TIMEOUT", 60*time.Second),
76 | ShutdownTimeout: getDurationEnv("SHUTDOWN_TIMEOUT", 30*time.Second),
77 | Environment: getEnv("ENVIRONMENT", "development"),
78 | },
79 | Database: DatabaseConfig{
80 | Type: getEnv("DB_TYPE", "file"),
81 | FilePath: getEnv("DB_FILE_PATH", "posts.json"),
82 | Host: getEnv("DB_HOST", "localhost"),
83 | Port: getEnv("DB_PORT", "5432"),
84 | User: getEnv("DB_USER", "postgres"),
85 | Password: getEnv("DB_PASSWORD", ""),
86 | DBName: getEnv("DB_NAME", "postanalyzer"),
87 | SSLMode: getEnv("DB_SSL_MODE", "disable"),
88 | MaxConns: getIntEnv("DB_MAX_CONNS", 25),
89 | MinConns: getIntEnv("DB_MIN_CONNS", 5),
90 | },
91 | Security: SecurityConfig{
92 | RateLimitRequests: getIntEnv("RATE_LIMIT_REQUESTS", 100),
93 | RateLimitWindow: getDurationEnv("RATE_LIMIT_WINDOW", 1*time.Minute),
94 | MaxBodySize: getInt64Env("MAX_BODY_SIZE", 1*1024*1024), // 1MB
95 | AllowedOrigins: getSliceEnv("ALLOWED_ORIGINS", []string{"*"}),
96 | TrustedProxies: getSliceEnv("TRUSTED_PROXIES", []string{}),
97 | },
98 | Logging: LoggingConfig{
99 | Level: getEnv("LOG_LEVEL", "info"),
100 | Format: getEnv("LOG_FORMAT", "json"),
101 | Output: getEnv("LOG_OUTPUT", "stdout"),
102 | TimeFormat: getEnv("LOG_TIME_FORMAT", time.RFC3339),
103 | },
104 | External: ExternalConfig{
105 | JSONPlaceholderURL: getEnv("JSONPLACEHOLDER_URL", "https://jsonplaceholder.typicode.com/posts"),
106 | HTTPTimeout: getDurationEnv("HTTP_TIMEOUT", 30*time.Second),
107 | },
108 | }
109 |
110 | if err := cfg.Validate(); err != nil {
111 | return nil, fmt.Errorf("invalid configuration: %w", err)
112 | }
113 |
114 | return cfg, nil
115 | }
116 |
117 | // Validate checks if the configuration is valid
118 | func (c *Config) Validate() error {
119 | // Validate server config
120 | if c.Server.Port == "" {
121 | return fmt.Errorf("server port cannot be empty")
122 | }
123 | if c.Server.Environment != "development" && c.Server.Environment != "staging" && c.Server.Environment != "production" {
124 | return fmt.Errorf("environment must be one of: development, staging, production")
125 | }
126 |
127 | // Validate database config
128 | if c.Database.Type != "file" && c.Database.Type != "postgres" {
129 | return fmt.Errorf("database type must be 'file' or 'postgres'")
130 | }
131 | if c.Database.Type == "file" && c.Database.FilePath == "" {
132 | return fmt.Errorf("database file path cannot be empty when using file storage")
133 | }
134 | if c.Database.Type == "postgres" {
135 | if c.Database.Host == "" || c.Database.DBName == "" {
136 | return fmt.Errorf("database host and name are required for postgres")
137 | }
138 | }
139 |
140 | // Validate security config
141 | if c.Security.RateLimitRequests <= 0 {
142 | return fmt.Errorf("rate limit requests must be positive")
143 | }
144 | if c.Security.MaxBodySize <= 0 {
145 | return fmt.Errorf("max body size must be positive")
146 | }
147 |
148 | // Validate logging config
149 | validLogLevels := map[string]bool{"debug": true, "info": true, "warn": true, "error": true}
150 | if !validLogLevels[c.Logging.Level] {
151 | return fmt.Errorf("log level must be one of: debug, info, warn, error")
152 | }
153 | if c.Logging.Format != "json" && c.Logging.Format != "text" {
154 | return fmt.Errorf("log format must be 'json' or 'text'")
155 | }
156 |
157 | return nil
158 | }
159 |
160 | // IsDevelopment returns true if running in development mode
161 | func (c *Config) IsDevelopment() bool {
162 | return c.Server.Environment == "development"
163 | }
164 |
165 | // IsProduction returns true if running in production mode
166 | func (c *Config) IsProduction() bool {
167 | return c.Server.Environment == "production"
168 | }
169 |
170 | // Helper functions for reading environment variables
171 |
172 | func getEnv(key, defaultValue string) string {
173 | if value := os.Getenv(key); value != "" {
174 | return value
175 | }
176 | return defaultValue
177 | }
178 |
179 | func getIntEnv(key string, defaultValue int) int {
180 | if value := os.Getenv(key); value != "" {
181 | if intVal, err := strconv.Atoi(value); err == nil {
182 | return intVal
183 | }
184 | }
185 | return defaultValue
186 | }
187 |
188 | func getInt64Env(key string, defaultValue int64) int64 {
189 | if value := os.Getenv(key); value != "" {
190 | if intVal, err := strconv.ParseInt(value, 10, 64); err == nil {
191 | return intVal
192 | }
193 | }
194 | return defaultValue
195 | }
196 |
197 | func getDurationEnv(key string, defaultValue time.Duration) time.Duration {
198 | if value := os.Getenv(key); value != "" {
199 | if duration, err := time.ParseDuration(value); err == nil {
200 | return duration
201 | }
202 | }
203 | return defaultValue
204 | }
205 |
206 | func getSliceEnv(key string, defaultValue []string) []string {
207 | if value := os.Getenv(key); value != "" {
208 | // Simple comma-separated parsing
209 | result := []string{}
210 | current := ""
211 | for _, char := range value {
212 | if char == ',' {
213 | if current != "" {
214 | result = append(result, current)
215 | current = ""
216 | }
217 | } else {
218 | current += string(char)
219 | }
220 | }
221 | if current != "" {
222 | result = append(result, current)
223 | }
224 | return result
225 | }
226 | return defaultValue
227 | }
228 |
--------------------------------------------------------------------------------
/internal/storage/file.go:
--------------------------------------------------------------------------------
1 | package storage
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "errors"
7 | "os"
8 | "sync"
9 | "time"
10 |
11 | "Post_Analyzer_Webserver/internal/logger"
12 | "Post_Analyzer_Webserver/internal/metrics"
13 | )
14 |
15 | // FileStorage implements Storage interface using JSON file
16 | type FileStorage struct {
17 | filePath string
18 | mu sync.RWMutex
19 | }
20 |
21 | // NewFileStorage creates a new file-based storage
22 | func NewFileStorage(filePath string) (*FileStorage, error) {
23 | fs := &FileStorage{
24 | filePath: filePath,
25 | }
26 |
27 | // Initialize file if it doesn't exist
28 | if _, err := os.Stat(filePath); os.IsNotExist(err) {
29 | if err := fs.writeToFile([]Post{}); err != nil {
30 | return nil, err
31 | }
32 | }
33 |
34 | return fs, nil
35 | }
36 |
37 | // GetAll retrieves all posts
38 | func (fs *FileStorage) GetAll(ctx context.Context) ([]Post, error) {
39 | start := time.Now()
40 | defer func() {
41 | metrics.RecordDBOperation("get_all", "success", time.Since(start))
42 | }()
43 |
44 | fs.mu.RLock()
45 | defer fs.mu.RUnlock()
46 |
47 | posts, err := fs.readFromFile()
48 | if err != nil {
49 | metrics.RecordDBOperation("get_all", "error", time.Since(start))
50 | logger.ErrorContext(ctx, "failed to read posts from file", "error", err)
51 | return nil, err
52 | }
53 |
54 | metrics.RecordPostsTotal(len(posts))
55 | return posts, nil
56 | }
57 |
58 | // GetByID retrieves a post by ID
59 | func (fs *FileStorage) GetByID(ctx context.Context, id int) (*Post, error) {
60 | start := time.Now()
61 | defer func() {
62 | metrics.RecordDBOperation("get_by_id", "success", time.Since(start))
63 | }()
64 |
65 | fs.mu.RLock()
66 | defer fs.mu.RUnlock()
67 |
68 | posts, err := fs.readFromFile()
69 | if err != nil {
70 | metrics.RecordDBOperation("get_by_id", "error", time.Since(start))
71 | return nil, err
72 | }
73 |
74 | for _, post := range posts {
75 | if post.Id == id {
76 | return &post, nil
77 | }
78 | }
79 |
80 | return nil, ErrNotFound
81 | }
82 |
83 | // Create creates a new post
84 | func (fs *FileStorage) Create(ctx context.Context, post *Post) error {
85 | start := time.Now()
86 | defer func() {
87 | metrics.RecordDBOperation("create", "success", time.Since(start))
88 | }()
89 |
90 | if err := post.Validate(); err != nil {
91 | return err
92 | }
93 |
94 | fs.mu.Lock()
95 | defer fs.mu.Unlock()
96 |
97 | posts, err := fs.readFromFile()
98 | if err != nil {
99 | metrics.RecordDBOperation("create", "error", time.Since(start))
100 | return err
101 | }
102 |
103 | // Generate new ID
104 | maxID := 0
105 | for _, p := range posts {
106 | if p.Id > maxID {
107 | maxID = p.Id
108 | }
109 | }
110 | post.Id = maxID + 1
111 | post.CreatedAt = time.Now()
112 | post.UpdatedAt = time.Now()
113 |
114 | posts = append(posts, *post)
115 |
116 | if err := fs.writeToFile(posts); err != nil {
117 | metrics.RecordDBOperation("create", "error", time.Since(start))
118 | return err
119 | }
120 |
121 | metrics.RecordPostAdded()
122 | logger.InfoContext(ctx, "post created", "id", post.Id)
123 | return nil
124 | }
125 |
126 | // Update updates an existing post
127 | func (fs *FileStorage) Update(ctx context.Context, post *Post) error {
128 | start := time.Now()
129 | defer func() {
130 | metrics.RecordDBOperation("update", "success", time.Since(start))
131 | }()
132 |
133 | if err := post.Validate(); err != nil {
134 | return err
135 | }
136 |
137 | fs.mu.Lock()
138 | defer fs.mu.Unlock()
139 |
140 | posts, err := fs.readFromFile()
141 | if err != nil {
142 | metrics.RecordDBOperation("update", "error", time.Since(start))
143 | return err
144 | }
145 |
146 | found := false
147 | for i, p := range posts {
148 | if p.Id == post.Id {
149 | post.UpdatedAt = time.Now()
150 | posts[i] = *post
151 | found = true
152 | break
153 | }
154 | }
155 |
156 | if !found {
157 | return ErrNotFound
158 | }
159 |
160 | if err := fs.writeToFile(posts); err != nil {
161 | metrics.RecordDBOperation("update", "error", time.Since(start))
162 | return err
163 | }
164 |
165 | logger.InfoContext(ctx, "post updated", "id", post.Id)
166 | return nil
167 | }
168 |
169 | // Delete deletes a post by ID
170 | func (fs *FileStorage) Delete(ctx context.Context, id int) error {
171 | start := time.Now()
172 | defer func() {
173 | metrics.RecordDBOperation("delete", "success", time.Since(start))
174 | }()
175 |
176 | fs.mu.Lock()
177 | defer fs.mu.Unlock()
178 |
179 | posts, err := fs.readFromFile()
180 | if err != nil {
181 | metrics.RecordDBOperation("delete", "error", time.Since(start))
182 | return err
183 | }
184 |
185 | found := false
186 | newPosts := make([]Post, 0, len(posts))
187 | for _, p := range posts {
188 | if p.Id != id {
189 | newPosts = append(newPosts, p)
190 | } else {
191 | found = true
192 | }
193 | }
194 |
195 | if !found {
196 | return ErrNotFound
197 | }
198 |
199 | if err := fs.writeToFile(newPosts); err != nil {
200 | metrics.RecordDBOperation("delete", "error", time.Since(start))
201 | return err
202 | }
203 |
204 | logger.InfoContext(ctx, "post deleted", "id", id)
205 | return nil
206 | }
207 |
208 | // BatchCreate creates multiple posts in a batch
209 | func (fs *FileStorage) BatchCreate(ctx context.Context, newPosts []Post) error {
210 | start := time.Now()
211 | defer func() {
212 | metrics.RecordDBOperation("batch_create", "success", time.Since(start))
213 | }()
214 |
215 | fs.mu.Lock()
216 | defer fs.mu.Unlock()
217 |
218 | existingPosts, err := fs.readFromFile()
219 | if err != nil && !errors.Is(err, os.ErrNotExist) {
220 | metrics.RecordDBOperation("batch_create", "error", time.Since(start))
221 | return err
222 | }
223 |
224 | // Use existing posts if available, otherwise start fresh
225 | now := time.Now()
226 | for i := range newPosts {
227 | if newPosts[i].CreatedAt.IsZero() {
228 | newPosts[i].CreatedAt = now
229 | }
230 | if newPosts[i].UpdatedAt.IsZero() {
231 | newPosts[i].UpdatedAt = now
232 | }
233 | }
234 |
235 | if err := fs.writeToFile(newPosts); err != nil {
236 | metrics.RecordDBOperation("batch_create", "error", time.Since(start))
237 | return err
238 | }
239 |
240 | metrics.RecordPostsFetched(len(newPosts))
241 | logger.InfoContext(ctx, "batch posts created", "count", len(newPosts), "previous_count", len(existingPosts))
242 | return nil
243 | }
244 |
245 | // Count returns the total number of posts
246 | func (fs *FileStorage) Count(ctx context.Context) (int, error) {
247 | fs.mu.RLock()
248 | defer fs.mu.RUnlock()
249 |
250 | posts, err := fs.readFromFile()
251 | if err != nil {
252 | return 0, err
253 | }
254 |
255 | return len(posts), nil
256 | }
257 |
258 | // Close closes the storage (no-op for file storage)
259 | func (fs *FileStorage) Close() error {
260 | return nil
261 | }
262 |
263 | // readFromFile reads posts from the JSON file
264 | func (fs *FileStorage) readFromFile() ([]Post, error) {
265 | data, err := os.ReadFile(fs.filePath)
266 | if err != nil {
267 | if os.IsNotExist(err) {
268 | return []Post{}, nil
269 | }
270 | return nil, err
271 | }
272 |
273 | if len(data) == 0 {
274 | return []Post{}, nil
275 | }
276 |
277 | var posts []Post
278 | if err := json.Unmarshal(data, &posts); err != nil {
279 | return nil, err
280 | }
281 |
282 | return posts, nil
283 | }
284 |
285 | // writeToFile writes posts to the JSON file
286 | func (fs *FileStorage) writeToFile(posts []Post) error {
287 | data, err := json.MarshalIndent(posts, "", " ")
288 | if err != nil {
289 | return err
290 | }
291 |
292 | return os.WriteFile(fs.filePath, data, 0644)
293 | }
294 |
--------------------------------------------------------------------------------
/internal/middleware/middleware_test.go:
--------------------------------------------------------------------------------
1 | package middleware
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 | "time"
8 |
9 | "Post_Analyzer_Webserver/internal/logger"
10 | )
11 |
12 | func TestRequestID(t *testing.T) {
13 | handler := RequestID(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
14 | requestID := r.Context().Value(logger.RequestIDKey)
15 | if requestID == nil {
16 | t.Error("Expected request ID in context")
17 | }
18 | w.WriteHeader(http.StatusOK)
19 | }))
20 |
21 | req := httptest.NewRequest("GET", "/test", nil)
22 | rr := httptest.NewRecorder()
23 |
24 | handler.ServeHTTP(rr, req)
25 |
26 | if rr.Header().Get("X-Request-ID") == "" {
27 | t.Error("Expected X-Request-ID header")
28 | }
29 | }
30 |
31 | func TestRequestIDFromHeader(t *testing.T) {
32 | customID := "custom-request-id"
33 |
34 | handler := RequestID(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
35 | requestID := r.Context().Value(logger.RequestIDKey)
36 | if requestID != customID {
37 | t.Errorf("Expected request ID %s, got %v", customID, requestID)
38 | }
39 | }))
40 |
41 | req := httptest.NewRequest("GET", "/test", nil)
42 | req.Header.Set("X-Request-ID", customID)
43 | rr := httptest.NewRecorder()
44 |
45 | handler.ServeHTTP(rr, req)
46 |
47 | if rr.Header().Get("X-Request-ID") != customID {
48 | t.Errorf("Expected X-Request-ID header %s, got %s", customID, rr.Header().Get("X-Request-ID"))
49 | }
50 | }
51 |
52 | func TestRecovery(t *testing.T) {
53 | handler := Recovery(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
54 | panic("test panic")
55 | }))
56 |
57 | req := httptest.NewRequest("GET", "/test", nil)
58 | rr := httptest.NewRecorder()
59 |
60 | // Should not panic
61 | handler.ServeHTTP(rr, req)
62 |
63 | if rr.Code != http.StatusInternalServerError {
64 | t.Errorf("Expected status 500, got %d", rr.Code)
65 | }
66 | }
67 |
68 | func TestSecurityHeaders(t *testing.T) {
69 | handler := SecurityHeaders(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
70 | w.WriteHeader(http.StatusOK)
71 | }))
72 |
73 | req := httptest.NewRequest("GET", "/test", nil)
74 | rr := httptest.NewRecorder()
75 |
76 | handler.ServeHTTP(rr, req)
77 |
78 | headers := map[string]string{
79 | "X-Content-Type-Options": "nosniff",
80 | "X-Frame-Options": "DENY",
81 | "X-XSS-Protection": "1; mode=block",
82 | }
83 |
84 | for header, expectedValue := range headers {
85 | actualValue := rr.Header().Get(header)
86 | if actualValue != expectedValue {
87 | t.Errorf("Expected %s header to be %s, got %s", header, expectedValue, actualValue)
88 | }
89 | }
90 | }
91 |
92 | func TestCORS(t *testing.T) {
93 | allowedOrigins := []string{"http://example.com"}
94 | handler := CORS(allowedOrigins)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
95 | w.WriteHeader(http.StatusOK)
96 | }))
97 |
98 | // Test with allowed origin
99 | req := httptest.NewRequest("GET", "/test", nil)
100 | req.Header.Set("Origin", "http://example.com")
101 | rr := httptest.NewRecorder()
102 |
103 | handler.ServeHTTP(rr, req)
104 |
105 | if rr.Header().Get("Access-Control-Allow-Origin") != "http://example.com" {
106 | t.Error("Expected CORS headers for allowed origin")
107 | }
108 |
109 | // Test with disallowed origin
110 | req = httptest.NewRequest("GET", "/test", nil)
111 | req.Header.Set("Origin", "http://evil.com")
112 | rr = httptest.NewRecorder()
113 |
114 | handler.ServeHTTP(rr, req)
115 |
116 | if rr.Header().Get("Access-Control-Allow-Origin") != "" {
117 | t.Error("Should not set CORS headers for disallowed origin")
118 | }
119 | }
120 |
121 | func TestCORSPreflight(t *testing.T) {
122 | allowedOrigins := []string{"*"}
123 | handler := CORS(allowedOrigins)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
124 | t.Error("Should not call next handler for OPTIONS request")
125 | }))
126 |
127 | req := httptest.NewRequest("OPTIONS", "/test", nil)
128 | req.Header.Set("Origin", "http://example.com")
129 | rr := httptest.NewRecorder()
130 |
131 | handler.ServeHTTP(rr, req)
132 |
133 | if rr.Code != http.StatusNoContent {
134 | t.Errorf("Expected status 204 for OPTIONS, got %d", rr.Code)
135 | }
136 | }
137 |
138 | func TestRateLimiter(t *testing.T) {
139 | limit := 5
140 | window := 1 * time.Second
141 | rl := NewRateLimiter(limit, window)
142 |
143 | handler := rl.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
144 | w.WriteHeader(http.StatusOK)
145 | }))
146 |
147 | // Make requests up to the limit
148 | for i := 0; i < limit; i++ {
149 | req := httptest.NewRequest("GET", "/test", nil)
150 | rr := httptest.NewRecorder()
151 | handler.ServeHTTP(rr, req)
152 |
153 | if rr.Code != http.StatusOK {
154 | t.Errorf("Request %d should succeed, got status %d", i+1, rr.Code)
155 | }
156 | }
157 |
158 | // Next request should be rate limited
159 | req := httptest.NewRequest("GET", "/test", nil)
160 | rr := httptest.NewRecorder()
161 | handler.ServeHTTP(rr, req)
162 |
163 | if rr.Code != http.StatusTooManyRequests {
164 | t.Errorf("Expected rate limit (429), got %d", rr.Code)
165 | }
166 |
167 | // Wait for window to reset
168 | time.Sleep(window + 100*time.Millisecond)
169 |
170 | // Should work again
171 | req = httptest.NewRequest("GET", "/test", nil)
172 | rr = httptest.NewRecorder()
173 | handler.ServeHTTP(rr, req)
174 |
175 | if rr.Code != http.StatusOK {
176 | t.Errorf("Expected success after window reset, got %d", rr.Code)
177 | }
178 | }
179 |
180 | func TestMaxBodySize(t *testing.T) {
181 | maxSize := int64(100)
182 | handler := MaxBodySize(maxSize)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
183 | // Try to read body
184 | buf := make([]byte, maxSize+1)
185 | _, err := r.Body.Read(buf)
186 | if err == nil {
187 | t.Error("Expected error when reading body larger than max size")
188 | }
189 | w.WriteHeader(http.StatusOK)
190 | }))
191 |
192 | // Create request with body larger than max size
193 | body := make([]byte, maxSize+1)
194 | req := httptest.NewRequest("POST", "/test", nil)
195 | rr := httptest.NewRecorder()
196 |
197 | handler.ServeHTTP(rr, req)
198 | _ = body // Use body variable
199 | }
200 |
201 | func TestChain(t *testing.T) {
202 | called := []string{}
203 |
204 | middleware1 := func(next http.Handler) http.Handler {
205 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
206 | called = append(called, "middleware1")
207 | next.ServeHTTP(w, r)
208 | })
209 | }
210 |
211 | middleware2 := func(next http.Handler) http.Handler {
212 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
213 | called = append(called, "middleware2")
214 | next.ServeHTTP(w, r)
215 | })
216 | }
217 |
218 | finalHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
219 | called = append(called, "handler")
220 | w.WriteHeader(http.StatusOK)
221 | })
222 |
223 | chained := Chain(middleware1, middleware2)(finalHandler)
224 |
225 | req := httptest.NewRequest("GET", "/test", nil)
226 | rr := httptest.NewRecorder()
227 |
228 | chained.ServeHTTP(rr, req)
229 |
230 | // Check order of execution
231 | if len(called) != 3 {
232 | t.Errorf("Expected 3 calls, got %d", len(called))
233 | }
234 | if called[0] != "middleware1" || called[1] != "middleware2" || called[2] != "handler" {
235 | t.Errorf("Unexpected execution order: %v", called)
236 | }
237 | }
238 |
239 | func TestGetClientIP(t *testing.T) {
240 | tests := []struct {
241 | name string
242 | remoteAddr string
243 | xForwardedFor string
244 | xRealIP string
245 | expectedIP string
246 | }{
247 | {
248 | name: "from RemoteAddr",
249 | remoteAddr: "192.168.1.1:1234",
250 | expectedIP: "192.168.1.1",
251 | },
252 | {
253 | name: "from X-Forwarded-For",
254 | remoteAddr: "192.168.1.1:1234",
255 | xForwardedFor: "10.0.0.1, 10.0.0.2",
256 | expectedIP: "10.0.0.1",
257 | },
258 | {
259 | name: "from X-Real-IP",
260 | remoteAddr: "192.168.1.1:1234",
261 | xRealIP: "10.0.0.1",
262 | expectedIP: "10.0.0.1",
263 | },
264 | }
265 |
266 | for _, tt := range tests {
267 | t.Run(tt.name, func(t *testing.T) {
268 | req := httptest.NewRequest("GET", "/test", nil)
269 | req.RemoteAddr = tt.remoteAddr
270 | if tt.xForwardedFor != "" {
271 | req.Header.Set("X-Forwarded-For", tt.xForwardedFor)
272 | }
273 | if tt.xRealIP != "" {
274 | req.Header.Set("X-Real-IP", tt.xRealIP)
275 | }
276 |
277 | ip := getClientIP(req)
278 | if ip != tt.expectedIP {
279 | t.Errorf("Expected IP %s, got %s", tt.expectedIP, ip)
280 | }
281 | })
282 | }
283 | }
284 |
--------------------------------------------------------------------------------
/internal/storage/file_test.go:
--------------------------------------------------------------------------------
1 | package storage
2 |
3 | import (
4 | "context"
5 | "os"
6 | "path/filepath"
7 | "testing"
8 | )
9 |
10 | func TestFileStorage_CreateAndGet(t *testing.T) {
11 | // Create temporary directory for test
12 | tmpDir := t.TempDir()
13 | filePath := filepath.Join(tmpDir, "test_posts.json")
14 |
15 | store, err := NewFileStorage(filePath)
16 | if err != nil {
17 | t.Fatalf("Failed to create file storage: %v", err)
18 | }
19 | defer store.Close()
20 |
21 | ctx := context.Background()
22 |
23 | // Create a post
24 | post := &Post{
25 | UserId: 1,
26 | Title: "Test Post",
27 | Body: "This is a test post body",
28 | }
29 |
30 | err = store.Create(ctx, post)
31 | if err != nil {
32 | t.Fatalf("Failed to create post: %v", err)
33 | }
34 |
35 | if post.Id == 0 {
36 | t.Error("Post ID should be assigned")
37 | }
38 |
39 | // Retrieve the post
40 | retrieved, err := store.GetByID(ctx, post.Id)
41 | if err != nil {
42 | t.Fatalf("Failed to get post: %v", err)
43 | }
44 |
45 | if retrieved.Title != post.Title {
46 | t.Errorf("Expected title %s, got %s", post.Title, retrieved.Title)
47 | }
48 | if retrieved.Body != post.Body {
49 | t.Errorf("Expected body %s, got %s", post.Body, retrieved.Body)
50 | }
51 | }
52 |
53 | func TestFileStorage_GetAll(t *testing.T) {
54 | tmpDir := t.TempDir()
55 | filePath := filepath.Join(tmpDir, "test_posts.json")
56 |
57 | store, err := NewFileStorage(filePath)
58 | if err != nil {
59 | t.Fatalf("Failed to create file storage: %v", err)
60 | }
61 | defer store.Close()
62 |
63 | ctx := context.Background()
64 |
65 | // Create multiple posts
66 | for i := 1; i <= 3; i++ {
67 | post := &Post{
68 | UserId: i,
69 | Title: "Test Post " + string(rune(i)),
70 | Body: "Test body",
71 | }
72 | if err := store.Create(ctx, post); err != nil {
73 | t.Fatalf("Failed to create post: %v", err)
74 | }
75 | }
76 |
77 | // Get all posts
78 | posts, err := store.GetAll(ctx)
79 | if err != nil {
80 | t.Fatalf("Failed to get all posts: %v", err)
81 | }
82 |
83 | if len(posts) != 3 {
84 | t.Errorf("Expected 3 posts, got %d", len(posts))
85 | }
86 | }
87 |
88 | func TestFileStorage_Update(t *testing.T) {
89 | tmpDir := t.TempDir()
90 | filePath := filepath.Join(tmpDir, "test_posts.json")
91 |
92 | store, err := NewFileStorage(filePath)
93 | if err != nil {
94 | t.Fatalf("Failed to create file storage: %v", err)
95 | }
96 | defer store.Close()
97 |
98 | ctx := context.Background()
99 |
100 | // Create a post
101 | post := &Post{
102 | UserId: 1,
103 | Title: "Original Title",
104 | Body: "Original Body",
105 | }
106 | if err := store.Create(ctx, post); err != nil {
107 | t.Fatalf("Failed to create post: %v", err)
108 | }
109 |
110 | // Update the post
111 | post.Title = "Updated Title"
112 | post.Body = "Updated Body"
113 | if err := store.Update(ctx, post); err != nil {
114 | t.Fatalf("Failed to update post: %v", err)
115 | }
116 |
117 | // Retrieve and verify
118 | retrieved, err := store.GetByID(ctx, post.Id)
119 | if err != nil {
120 | t.Fatalf("Failed to get post: %v", err)
121 | }
122 |
123 | if retrieved.Title != "Updated Title" {
124 | t.Errorf("Expected updated title, got %s", retrieved.Title)
125 | }
126 | if retrieved.Body != "Updated Body" {
127 | t.Errorf("Expected updated body, got %s", retrieved.Body)
128 | }
129 | }
130 |
131 | func TestFileStorage_Delete(t *testing.T) {
132 | tmpDir := t.TempDir()
133 | filePath := filepath.Join(tmpDir, "test_posts.json")
134 |
135 | store, err := NewFileStorage(filePath)
136 | if err != nil {
137 | t.Fatalf("Failed to create file storage: %v", err)
138 | }
139 | defer store.Close()
140 |
141 | ctx := context.Background()
142 |
143 | // Create a post
144 | post := &Post{
145 | UserId: 1,
146 | Title: "To Be Deleted",
147 | Body: "This post will be deleted",
148 | }
149 | if err := store.Create(ctx, post); err != nil {
150 | t.Fatalf("Failed to create post: %v", err)
151 | }
152 |
153 | // Delete the post
154 | if err := store.Delete(ctx, post.Id); err != nil {
155 | t.Fatalf("Failed to delete post: %v", err)
156 | }
157 |
158 | // Try to retrieve - should get error
159 | _, err = store.GetByID(ctx, post.Id)
160 | if err != ErrNotFound {
161 | t.Errorf("Expected ErrNotFound, got %v", err)
162 | }
163 | }
164 |
165 | func TestFileStorage_Validation(t *testing.T) {
166 | tmpDir := t.TempDir()
167 | filePath := filepath.Join(tmpDir, "test_posts.json")
168 |
169 | store, err := NewFileStorage(filePath)
170 | if err != nil {
171 | t.Fatalf("Failed to create file storage: %v", err)
172 | }
173 | defer store.Close()
174 |
175 | ctx := context.Background()
176 |
177 | // Test empty title
178 | post := &Post{
179 | UserId: 1,
180 | Title: "",
181 | Body: "Body",
182 | }
183 | err = store.Create(ctx, post)
184 | if err == nil {
185 | t.Error("Expected error for empty title")
186 | }
187 |
188 | // Test empty body
189 | post = &Post{
190 | UserId: 1,
191 | Title: "Title",
192 | Body: "",
193 | }
194 | err = store.Create(ctx, post)
195 | if err == nil {
196 | t.Error("Expected error for empty body")
197 | }
198 | }
199 |
200 | func TestFileStorage_Count(t *testing.T) {
201 | tmpDir := t.TempDir()
202 | filePath := filepath.Join(tmpDir, "test_posts.json")
203 |
204 | store, err := NewFileStorage(filePath)
205 | if err != nil {
206 | t.Fatalf("Failed to create file storage: %v", err)
207 | }
208 | defer store.Close()
209 |
210 | ctx := context.Background()
211 |
212 | // Initial count should be 0
213 | count, err := store.Count(ctx)
214 | if err != nil {
215 | t.Fatalf("Failed to count posts: %v", err)
216 | }
217 | if count != 0 {
218 | t.Errorf("Expected count 0, got %d", count)
219 | }
220 |
221 | // Create posts
222 | for i := 0; i < 5; i++ {
223 | post := &Post{
224 | UserId: 1,
225 | Title: "Test",
226 | Body: "Body",
227 | }
228 | _ = store.Create(ctx, post)
229 | }
230 |
231 | // Count should be 5
232 | count, err = store.Count(ctx)
233 | if err != nil {
234 | t.Fatalf("Failed to count posts: %v", err)
235 | }
236 | if count != 5 {
237 | t.Errorf("Expected count 5, got %d", count)
238 | }
239 | }
240 |
241 | func TestFileStorage_BatchCreate(t *testing.T) {
242 | tmpDir := t.TempDir()
243 | filePath := filepath.Join(tmpDir, "test_posts.json")
244 |
245 | store, err := NewFileStorage(filePath)
246 | if err != nil {
247 | t.Fatalf("Failed to create file storage: %v", err)
248 | }
249 | defer store.Close()
250 |
251 | ctx := context.Background()
252 |
253 | // Create batch of posts
254 | posts := []Post{
255 | {Id: 1, UserId: 1, Title: "Post 1", Body: "Body 1"},
256 | {Id: 2, UserId: 1, Title: "Post 2", Body: "Body 2"},
257 | {Id: 3, UserId: 1, Title: "Post 3", Body: "Body 3"},
258 | }
259 |
260 | err = store.BatchCreate(ctx, posts)
261 | if err != nil {
262 | t.Fatalf("Failed to batch create posts: %v", err)
263 | }
264 |
265 | // Verify count
266 | count, _ := store.Count(ctx)
267 | if count != 3 {
268 | t.Errorf("Expected 3 posts, got %d", count)
269 | }
270 |
271 | // Verify individual posts exist
272 | for _, post := range posts {
273 | retrieved, err := store.GetByID(ctx, post.Id)
274 | if err != nil {
275 | t.Errorf("Failed to get post %d: %v", post.Id, err)
276 | }
277 | if retrieved.Title != post.Title {
278 | t.Errorf("Expected title %s, got %s", post.Title, retrieved.Title)
279 | }
280 | }
281 | }
282 |
283 | func TestFileStorage_ConcurrentAccess(t *testing.T) {
284 | tmpDir := t.TempDir()
285 | filePath := filepath.Join(tmpDir, "test_posts.json")
286 |
287 | store, err := NewFileStorage(filePath)
288 | if err != nil {
289 | t.Fatalf("Failed to create file storage: %v", err)
290 | }
291 | defer store.Close()
292 |
293 | ctx := context.Background()
294 |
295 | // Create posts concurrently
296 | done := make(chan bool)
297 | for i := 0; i < 10; i++ {
298 | go func(id int) {
299 | post := &Post{
300 | UserId: id,
301 | Title: "Concurrent Post",
302 | Body: "Body",
303 | }
304 | _ = store.Create(ctx, post)
305 | done <- true
306 | }(i)
307 | }
308 |
309 | // Wait for all goroutines
310 | for i := 0; i < 10; i++ {
311 | <-done
312 | }
313 |
314 | // Verify all posts were created
315 | count, _ := store.Count(ctx)
316 | if count != 10 {
317 | t.Errorf("Expected 10 posts, got %d", count)
318 | }
319 | }
320 |
321 | func TestFileStorage_FileNotExists(t *testing.T) {
322 | tmpDir := t.TempDir()
323 | filePath := filepath.Join(tmpDir, "nonexistent.json")
324 |
325 | // Should create the file if it doesn't exist
326 | store, err := NewFileStorage(filePath)
327 | if err != nil {
328 | t.Fatalf("Failed to create file storage: %v", err)
329 | }
330 | defer store.Close()
331 |
332 | // Verify file was created
333 | if _, err := os.Stat(filePath); os.IsNotExist(err) {
334 | t.Error("Expected file to be created")
335 | }
336 | }
337 |
--------------------------------------------------------------------------------
/internal/storage/postgres.go:
--------------------------------------------------------------------------------
1 | package storage
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "time"
8 |
9 | "Post_Analyzer_Webserver/config"
10 | "Post_Analyzer_Webserver/internal/logger"
11 | "Post_Analyzer_Webserver/internal/metrics"
12 |
13 | _ "github.com/lib/pq"
14 | )
15 |
16 | // PostgresStorage implements Storage interface using PostgreSQL
17 | type PostgresStorage struct {
18 | db *sql.DB
19 | }
20 |
21 | // NewPostgresStorage creates a new PostgreSQL storage
22 | func NewPostgresStorage(cfg *config.DatabaseConfig) (*PostgresStorage, error) {
23 | dsn := fmt.Sprintf(
24 | "host=%s port=%s user=%s password=%s dbname=%s sslmode=%s",
25 | cfg.Host, cfg.Port, cfg.User, cfg.Password, cfg.DBName, cfg.SSLMode,
26 | )
27 |
28 | db, err := sql.Open("postgres", dsn)
29 | if err != nil {
30 | return nil, fmt.Errorf("failed to open database: %w", err)
31 | }
32 |
33 | db.SetMaxOpenConns(cfg.MaxConns)
34 | db.SetMaxIdleConns(cfg.MinConns)
35 | db.SetConnMaxLifetime(time.Hour)
36 |
37 | if err := db.Ping(); err != nil {
38 | return nil, fmt.Errorf("failed to ping database: %w", err)
39 | }
40 |
41 | ps := &PostgresStorage{db: db}
42 |
43 | // Initialize schema
44 | if err := ps.initSchema(); err != nil {
45 | return nil, fmt.Errorf("failed to initialize schema: %w", err)
46 | }
47 |
48 | return ps, nil
49 | }
50 |
51 | // initSchema creates the necessary database tables
52 | func (ps *PostgresStorage) initSchema() error {
53 | schema := `
54 | CREATE TABLE IF NOT EXISTS posts (
55 | id SERIAL PRIMARY KEY,
56 | user_id INTEGER NOT NULL,
57 | title VARCHAR(500) NOT NULL,
58 | body TEXT NOT NULL,
59 | created_at TIMESTAMP NOT NULL DEFAULT NOW(),
60 | updated_at TIMESTAMP NOT NULL DEFAULT NOW()
61 | );
62 |
63 | CREATE INDEX IF NOT EXISTS idx_posts_user_id ON posts(user_id);
64 | CREATE INDEX IF NOT EXISTS idx_posts_created_at ON posts(created_at DESC);
65 | `
66 |
67 | _, err := ps.db.Exec(schema)
68 | return err
69 | }
70 |
71 | // GetAll retrieves all posts
72 | func (ps *PostgresStorage) GetAll(ctx context.Context) ([]Post, error) {
73 | start := time.Now()
74 | defer func() {
75 | metrics.RecordDBOperation("get_all", "success", time.Since(start))
76 | }()
77 |
78 | query := `SELECT id, user_id, title, body, created_at, updated_at FROM posts ORDER BY created_at DESC`
79 |
80 | rows, err := ps.db.QueryContext(ctx, query)
81 | if err != nil {
82 | metrics.RecordDBOperation("get_all", "error", time.Since(start))
83 | logger.ErrorContext(ctx, "failed to query posts", "error", err)
84 | return nil, err
85 | }
86 | defer rows.Close()
87 |
88 | var posts []Post
89 | for rows.Next() {
90 | var post Post
91 | if err := rows.Scan(&post.Id, &post.UserId, &post.Title, &post.Body, &post.CreatedAt, &post.UpdatedAt); err != nil {
92 | metrics.RecordDBOperation("get_all", "error", time.Since(start))
93 | return nil, err
94 | }
95 | posts = append(posts, post)
96 | }
97 |
98 | if err := rows.Err(); err != nil {
99 | metrics.RecordDBOperation("get_all", "error", time.Since(start))
100 | return nil, err
101 | }
102 |
103 | metrics.RecordPostsTotal(len(posts))
104 | return posts, nil
105 | }
106 |
107 | // GetByID retrieves a post by ID
108 | func (ps *PostgresStorage) GetByID(ctx context.Context, id int) (*Post, error) {
109 | start := time.Now()
110 | defer func() {
111 | metrics.RecordDBOperation("get_by_id", "success", time.Since(start))
112 | }()
113 |
114 | query := `SELECT id, user_id, title, body, created_at, updated_at FROM posts WHERE id = $1`
115 |
116 | var post Post
117 | err := ps.db.QueryRowContext(ctx, query, id).Scan(
118 | &post.Id, &post.UserId, &post.Title, &post.Body, &post.CreatedAt, &post.UpdatedAt,
119 | )
120 |
121 | if err == sql.ErrNoRows {
122 | return nil, ErrNotFound
123 | }
124 | if err != nil {
125 | metrics.RecordDBOperation("get_by_id", "error", time.Since(start))
126 | logger.ErrorContext(ctx, "failed to query post", "id", id, "error", err)
127 | return nil, err
128 | }
129 |
130 | return &post, nil
131 | }
132 |
133 | // Create creates a new post
134 | func (ps *PostgresStorage) Create(ctx context.Context, post *Post) error {
135 | start := time.Now()
136 | defer func() {
137 | metrics.RecordDBOperation("create", "success", time.Since(start))
138 | }()
139 |
140 | if err := post.Validate(); err != nil {
141 | return err
142 | }
143 |
144 | query := `
145 | INSERT INTO posts (user_id, title, body, created_at, updated_at)
146 | VALUES ($1, $2, $3, $4, $5)
147 | RETURNING id, created_at, updated_at
148 | `
149 |
150 | now := time.Now()
151 | err := ps.db.QueryRowContext(
152 | ctx, query,
153 | post.UserId, post.Title, post.Body, now, now,
154 | ).Scan(&post.Id, &post.CreatedAt, &post.UpdatedAt)
155 |
156 | if err != nil {
157 | metrics.RecordDBOperation("create", "error", time.Since(start))
158 | logger.ErrorContext(ctx, "failed to create post", "error", err)
159 | return err
160 | }
161 |
162 | metrics.RecordPostAdded()
163 | logger.InfoContext(ctx, "post created", "id", post.Id)
164 | return nil
165 | }
166 |
167 | // Update updates an existing post
168 | func (ps *PostgresStorage) Update(ctx context.Context, post *Post) error {
169 | start := time.Now()
170 | defer func() {
171 | metrics.RecordDBOperation("update", "success", time.Since(start))
172 | }()
173 |
174 | if err := post.Validate(); err != nil {
175 | return err
176 | }
177 |
178 | query := `
179 | UPDATE posts
180 | SET user_id = $1, title = $2, body = $3, updated_at = $4
181 | WHERE id = $5
182 | RETURNING updated_at
183 | `
184 |
185 | err := ps.db.QueryRowContext(
186 | ctx, query,
187 | post.UserId, post.Title, post.Body, time.Now(), post.Id,
188 | ).Scan(&post.UpdatedAt)
189 |
190 | if err == sql.ErrNoRows {
191 | return ErrNotFound
192 | }
193 | if err != nil {
194 | metrics.RecordDBOperation("update", "error", time.Since(start))
195 | logger.ErrorContext(ctx, "failed to update post", "id", post.Id, "error", err)
196 | return err
197 | }
198 |
199 | logger.InfoContext(ctx, "post updated", "id", post.Id)
200 | return nil
201 | }
202 |
203 | // Delete deletes a post by ID
204 | func (ps *PostgresStorage) Delete(ctx context.Context, id int) error {
205 | start := time.Now()
206 | defer func() {
207 | metrics.RecordDBOperation("delete", "success", time.Since(start))
208 | }()
209 |
210 | query := `DELETE FROM posts WHERE id = $1`
211 |
212 | result, err := ps.db.ExecContext(ctx, query, id)
213 | if err != nil {
214 | metrics.RecordDBOperation("delete", "error", time.Since(start))
215 | logger.ErrorContext(ctx, "failed to delete post", "id", id, "error", err)
216 | return err
217 | }
218 |
219 | rowsAffected, err := result.RowsAffected()
220 | if err != nil {
221 | return err
222 | }
223 |
224 | if rowsAffected == 0 {
225 | return ErrNotFound
226 | }
227 |
228 | logger.InfoContext(ctx, "post deleted", "id", id)
229 | return nil
230 | }
231 |
232 | // BatchCreate creates multiple posts in a batch
233 | func (ps *PostgresStorage) BatchCreate(ctx context.Context, posts []Post) error {
234 | start := time.Now()
235 | defer func() {
236 | metrics.RecordDBOperation("batch_create", "success", time.Since(start))
237 | }()
238 |
239 | if len(posts) == 0 {
240 | return nil
241 | }
242 |
243 | tx, err := ps.db.BeginTx(ctx, nil)
244 | if err != nil {
245 | metrics.RecordDBOperation("batch_create", "error", time.Since(start))
246 | return err
247 | }
248 | defer func() { _ = tx.Rollback() }()
249 |
250 | stmt, err := tx.PrepareContext(ctx, `
251 | INSERT INTO posts (id, user_id, title, body, created_at, updated_at)
252 | VALUES ($1, $2, $3, $4, $5, $6)
253 | ON CONFLICT (id) DO NOTHING
254 | `)
255 | if err != nil {
256 | metrics.RecordDBOperation("batch_create", "error", time.Since(start))
257 | return err
258 | }
259 | defer stmt.Close()
260 |
261 | now := time.Now()
262 | for _, post := range posts {
263 | createdAt := post.CreatedAt
264 | if createdAt.IsZero() {
265 | createdAt = now
266 | }
267 | updatedAt := post.UpdatedAt
268 | if updatedAt.IsZero() {
269 | updatedAt = now
270 | }
271 |
272 | _, err := stmt.ExecContext(ctx, post.Id, post.UserId, post.Title, post.Body, createdAt, updatedAt)
273 | if err != nil {
274 | metrics.RecordDBOperation("batch_create", "error", time.Since(start))
275 | logger.ErrorContext(ctx, "failed to insert post in batch", "id", post.Id, "error", err)
276 | return err
277 | }
278 | }
279 |
280 | if err := tx.Commit(); err != nil {
281 | metrics.RecordDBOperation("batch_create", "error", time.Since(start))
282 | return err
283 | }
284 |
285 | metrics.RecordPostsFetched(len(posts))
286 | logger.InfoContext(ctx, "batch posts created", "count", len(posts))
287 | return nil
288 | }
289 |
290 | // Count returns the total number of posts
291 | func (ps *PostgresStorage) Count(ctx context.Context) (int, error) {
292 | query := `SELECT COUNT(*) FROM posts`
293 |
294 | var count int
295 | err := ps.db.QueryRowContext(ctx, query).Scan(&count)
296 | if err != nil {
297 | logger.ErrorContext(ctx, "failed to count posts", "error", err)
298 | return 0, err
299 | }
300 |
301 | return count, nil
302 | }
303 |
304 | // Close closes the database connection
305 | func (ps *PostgresStorage) Close() error {
306 | return ps.db.Close()
307 | }
308 |
--------------------------------------------------------------------------------
/internal/middleware/middleware.go:
--------------------------------------------------------------------------------
1 | package middleware
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "net"
7 | "net/http"
8 | "runtime/debug"
9 | "strings"
10 | "sync"
11 | "time"
12 |
13 | "Post_Analyzer_Webserver/internal/logger"
14 |
15 | "github.com/google/uuid"
16 | )
17 |
18 | // RequestID middleware adds a unique request ID to each request
19 | func RequestID(next http.Handler) http.Handler {
20 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
21 | requestID := r.Header.Get("X-Request-ID")
22 | if requestID == "" {
23 | requestID = uuid.New().String()
24 | }
25 |
26 | ctx := context.WithValue(r.Context(), logger.RequestIDKey, requestID)
27 | w.Header().Set("X-Request-ID", requestID)
28 |
29 | next.ServeHTTP(w, r.WithContext(ctx))
30 | })
31 | }
32 |
33 | // Logging middleware logs all HTTP requests
34 | func Logging(next http.Handler) http.Handler {
35 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
36 | start := time.Now()
37 |
38 | // Create a response wrapper to capture status code
39 | rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
40 |
41 | logger.InfoContext(r.Context(), "incoming request",
42 | "method", r.Method,
43 | "path", r.URL.Path,
44 | "remote_addr", r.RemoteAddr,
45 | "user_agent", r.UserAgent(),
46 | )
47 |
48 | next.ServeHTTP(rw, r)
49 |
50 | duration := time.Since(start)
51 |
52 | logger.InfoContext(r.Context(), "request completed",
53 | "method", r.Method,
54 | "path", r.URL.Path,
55 | "status", rw.statusCode,
56 | "duration_ms", duration.Milliseconds(),
57 | "bytes", rw.bytesWritten,
58 | )
59 | })
60 | }
61 |
62 | // responseWriter wraps http.ResponseWriter to capture status code and bytes written
63 | type responseWriter struct {
64 | http.ResponseWriter
65 | statusCode int
66 | bytesWritten int
67 | }
68 |
69 | func (rw *responseWriter) WriteHeader(code int) {
70 | rw.statusCode = code
71 | rw.ResponseWriter.WriteHeader(code)
72 | }
73 |
74 | func (rw *responseWriter) Write(b []byte) (int, error) {
75 | n, err := rw.ResponseWriter.Write(b)
76 | rw.bytesWritten += n
77 | return n, err
78 | }
79 |
80 | // Recovery middleware recovers from panics and logs them
81 | func Recovery(next http.Handler) http.Handler {
82 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
83 | defer func() {
84 | if err := recover(); err != nil {
85 | logger.ErrorContext(r.Context(), "panic recovered",
86 | "error", err,
87 | "stack", string(debug.Stack()),
88 | )
89 |
90 | w.Header().Set("Content-Type", "application/json")
91 | w.WriteHeader(http.StatusInternalServerError)
92 | fmt.Fprintf(w, `{"error":"Internal server error"}`)
93 | }
94 | }()
95 |
96 | next.ServeHTTP(w, r)
97 | })
98 | }
99 |
100 | // SecurityHeaders middleware adds security headers to responses
101 | func SecurityHeaders(next http.Handler) http.Handler {
102 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
103 | w.Header().Set("X-Content-Type-Options", "nosniff")
104 | w.Header().Set("X-Frame-Options", "DENY")
105 | w.Header().Set("X-XSS-Protection", "1; mode=block")
106 | w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
107 | w.Header().Set("Content-Security-Policy", "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'")
108 | w.Header().Set("Permissions-Policy", "geolocation=(), microphone=(), camera=()")
109 |
110 | next.ServeHTTP(w, r)
111 | })
112 | }
113 |
114 | // CORS middleware handles Cross-Origin Resource Sharing
115 | func CORS(allowedOrigins []string) func(http.Handler) http.Handler {
116 | return func(next http.Handler) http.Handler {
117 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
118 | origin := r.Header.Get("Origin")
119 |
120 | // Check if origin is allowed
121 | allowed := false
122 | for _, allowedOrigin := range allowedOrigins {
123 | if allowedOrigin == "*" || allowedOrigin == origin {
124 | allowed = true
125 | break
126 | }
127 | }
128 |
129 | if allowed {
130 | if origin != "" {
131 | w.Header().Set("Access-Control-Allow-Origin", origin)
132 | } else if len(allowedOrigins) > 0 && allowedOrigins[0] == "*" {
133 | w.Header().Set("Access-Control-Allow-Origin", "*")
134 | }
135 | w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
136 | w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Request-ID")
137 | w.Header().Set("Access-Control-Max-Age", "3600")
138 | }
139 |
140 | // Handle preflight requests
141 | if r.Method == "OPTIONS" {
142 | w.WriteHeader(http.StatusNoContent)
143 | return
144 | }
145 |
146 | next.ServeHTTP(w, r)
147 | })
148 | }
149 | }
150 |
151 | // RateLimiter implements a simple in-memory rate limiter
152 | type RateLimiter struct {
153 | requests map[string]*clientInfo
154 | mu sync.RWMutex
155 | limit int
156 | window time.Duration
157 | }
158 |
159 | type clientInfo struct {
160 | count int
161 | windowStart time.Time
162 | }
163 |
164 | // NewRateLimiter creates a new rate limiter
165 | func NewRateLimiter(limit int, window time.Duration) *RateLimiter {
166 | rl := &RateLimiter{
167 | requests: make(map[string]*clientInfo),
168 | limit: limit,
169 | window: window,
170 | }
171 |
172 | // Cleanup old entries every minute
173 | go func() {
174 | ticker := time.NewTicker(1 * time.Minute)
175 | defer ticker.Stop()
176 | for range ticker.C {
177 | rl.cleanup()
178 | }
179 | }()
180 |
181 | return rl
182 | }
183 |
184 | // Middleware returns the rate limiting middleware
185 | func (rl *RateLimiter) Middleware(next http.Handler) http.Handler {
186 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
187 | // Get client IP
188 | clientIP := getClientIP(r)
189 |
190 | if !rl.allow(clientIP) {
191 | logger.WarnContext(r.Context(), "rate limit exceeded",
192 | "client_ip", clientIP,
193 | )
194 |
195 | w.Header().Set("Content-Type", "application/json")
196 | w.WriteHeader(http.StatusTooManyRequests)
197 | fmt.Fprintf(w, `{"error":"Rate limit exceeded. Please try again later."}`)
198 | return
199 | }
200 |
201 | next.ServeHTTP(w, r)
202 | })
203 | }
204 |
205 | func (rl *RateLimiter) allow(clientIP string) bool {
206 | rl.mu.Lock()
207 | defer rl.mu.Unlock()
208 |
209 | now := time.Now()
210 | info, exists := rl.requests[clientIP]
211 |
212 | if !exists || now.Sub(info.windowStart) > rl.window {
213 | // New window
214 | rl.requests[clientIP] = &clientInfo{
215 | count: 1,
216 | windowStart: now,
217 | }
218 | return true
219 | }
220 |
221 | if info.count >= rl.limit {
222 | return false
223 | }
224 |
225 | info.count++
226 | return true
227 | }
228 |
229 | func (rl *RateLimiter) cleanup() {
230 | rl.mu.Lock()
231 | defer rl.mu.Unlock()
232 |
233 | now := time.Now()
234 | for ip, info := range rl.requests {
235 | if now.Sub(info.windowStart) > rl.window*2 {
236 | delete(rl.requests, ip)
237 | }
238 | }
239 | }
240 |
241 | // getClientIP extracts the client IP from the request
242 | func getClientIP(r *http.Request) string {
243 | // Check X-Forwarded-For header
244 | xff := r.Header.Get("X-Forwarded-For")
245 | if xff != "" {
246 | ips := strings.Split(xff, ",")
247 | if len(ips) > 0 {
248 | return strings.TrimSpace(ips[0])
249 | }
250 | }
251 |
252 | // Check X-Real-IP header
253 | xri := r.Header.Get("X-Real-IP")
254 | if xri != "" {
255 | return xri
256 | }
257 |
258 | // Fall back to RemoteAddr
259 | ip, _, err := net.SplitHostPort(r.RemoteAddr)
260 | if err != nil {
261 | return r.RemoteAddr
262 | }
263 | return ip
264 | }
265 |
266 | // MaxBodySize limits the size of request bodies
267 | func MaxBodySize(maxSize int64) func(http.Handler) http.Handler {
268 | return func(next http.Handler) http.Handler {
269 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
270 | r.Body = http.MaxBytesReader(w, r.Body, maxSize)
271 | next.ServeHTTP(w, r)
272 | })
273 | }
274 | }
275 |
276 | // Timeout adds a timeout to requests
277 | func Timeout(timeout time.Duration) func(http.Handler) http.Handler {
278 | return func(next http.Handler) http.Handler {
279 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
280 | ctx, cancel := context.WithTimeout(r.Context(), timeout)
281 | defer cancel()
282 |
283 | done := make(chan struct{})
284 | go func() {
285 | next.ServeHTTP(w, r.WithContext(ctx))
286 | close(done)
287 | }()
288 |
289 | select {
290 | case <-done:
291 | return
292 | case <-ctx.Done():
293 | logger.WarnContext(r.Context(), "request timeout",
294 | "timeout", timeout,
295 | )
296 | w.WriteHeader(http.StatusGatewayTimeout)
297 | fmt.Fprintf(w, `{"error":"Request timeout"}`)
298 | }
299 | })
300 | }
301 | }
302 |
303 | // Chain chains multiple middleware functions
304 | func Chain(middlewares ...func(http.Handler) http.Handler) func(http.Handler) http.Handler {
305 | return func(final http.Handler) http.Handler {
306 | for i := len(middlewares) - 1; i >= 0; i-- {
307 | final = middlewares[i](final)
308 | }
309 | return final
310 | }
311 | }
312 |
--------------------------------------------------------------------------------
/MIGRATION_GUIDE.md:
--------------------------------------------------------------------------------
1 | # Migration Guide: v1.0 to v2.0 (Production Ready)
2 |
3 | This guide will help you migrate from the simple version (v1.0) to the production-ready version (v2.0) of the Post Analyzer Webserver.
4 |
5 | ## What's Changed?
6 |
7 | ### Major Changes
8 |
9 | 1. **Application Architecture**
10 | - Restructured into modular packages
11 | - Introduced storage abstraction layer
12 | - Added comprehensive middleware stack
13 |
14 | 2. **Storage Layer**
15 | - File storage now has thread-safe operations
16 | - Added PostgreSQL support
17 | - Automatic schema management
18 |
19 | 3. **Configuration**
20 | - Environment-based configuration
21 | - Validation on startup
22 | - Support for multiple environments
23 |
24 | 4. **Observability**
25 | - Structured JSON logging
26 | - Prometheus metrics
27 | - Request tracing with IDs
28 |
29 | 5. **Security**
30 | - Input validation and sanitization
31 | - Rate limiting
32 | - Security headers
33 | - CORS configuration
34 |
35 | ## Migration Steps
36 |
37 | ### Step 1: Backup Your Data
38 |
39 | If you're using file storage:
40 |
41 | ```bash
42 | # Backup your existing posts.json
43 | cp posts.json posts.json.backup
44 | ```
45 |
46 | ### Step 2: Update Dependencies
47 |
48 | ```bash
49 | # Download new dependencies
50 | go mod download
51 | go mod tidy
52 | ```
53 |
54 | ### Step 3: Configuration
55 |
56 | Create a `.env` file from the example:
57 |
58 | ```bash
59 | cp .env.example .env
60 | ```
61 |
62 | Edit `.env` to match your setup. For file storage (similar to v1.0):
63 |
64 | ```env
65 | # Keep using file storage
66 | DB_TYPE=file
67 | DB_FILE_PATH=posts.json
68 |
69 | # Other settings
70 | PORT=8080
71 | ENVIRONMENT=production
72 | LOG_LEVEL=info
73 | ```
74 |
75 | For PostgreSQL (recommended for production):
76 |
77 | ```env
78 | # Use PostgreSQL
79 | DB_TYPE=postgres
80 | DB_HOST=localhost
81 | DB_PORT=5432
82 | DB_USER=postgres
83 | DB_PASSWORD=yourpassword
84 | DB_NAME=postanalyzer
85 |
86 | # Other settings
87 | PORT=8080
88 | ENVIRONMENT=production
89 | LOG_LEVEL=info
90 | ```
91 |
92 | ### Step 4: Run the Application
93 |
94 | #### Option A: Direct Run (File Storage)
95 |
96 | ```bash
97 | # Run with default file storage
98 | go run main.go
99 | ```
100 |
101 | #### Option B: With PostgreSQL
102 |
103 | ```bash
104 | # Start PostgreSQL with Docker
105 | docker run -d \
106 | --name postgres \
107 | -e POSTGRES_DB=postanalyzer \
108 | -e POSTGRES_PASSWORD=postgres \
109 | -p 5432:5432 \
110 | postgres:16-alpine
111 |
112 | # Run the application
113 | export DB_TYPE=postgres
114 | export DB_PASSWORD=postgres
115 | go run main.go
116 | ```
117 |
118 | #### Option C: Full Docker Stack
119 |
120 | ```bash
121 | # Start everything with Docker Compose
122 | docker-compose up -d
123 | ```
124 |
125 | This includes:
126 | - Application
127 | - PostgreSQL
128 | - Prometheus
129 | - Grafana
130 |
131 | ### Step 5: Migrate Existing Data
132 |
133 | If you have existing data in `posts.json` and want to move to PostgreSQL:
134 |
135 | ```bash
136 | # The application will automatically handle this
137 | # Just ensure posts.json exists in the same directory
138 | # On first run with DB_TYPE=postgres, the data will be available
139 | ```
140 |
141 | Or manually import:
142 |
143 | ```bash
144 | # Start application with file storage first
145 | DB_TYPE=file go run main.go
146 |
147 | # In another terminal, fetch to ensure data is in posts.json
148 | curl http://localhost:8080/fetch
149 |
150 | # Stop the application (Ctrl+C)
151 |
152 | # Start with PostgreSQL
153 | DB_TYPE=postgres DB_PASSWORD=postgres go run main.go
154 |
155 | # Fetch again to populate PostgreSQL
156 | curl http://localhost:8080/fetch
157 | ```
158 |
159 | ## Compatibility
160 |
161 | ### API Endpoints
162 |
163 | All original endpoints remain functional:
164 |
165 | | v1.0 Endpoint | v2.0 Status | Notes |
166 | |---------------|-------------|-------|
167 | | `/` | ✅ Compatible | Enhanced with better error handling |
168 | | `/fetch` | ✅ Compatible | Now supports batch operations |
169 | | `/analyze` | ✅ Compatible | Improved performance |
170 | | `/add` | ✅ Compatible | Added input validation |
171 |
172 | ### New Endpoints
173 |
174 | | Endpoint | Purpose |
175 | |----------|---------|
176 | | `/health` | Health check for monitoring |
177 | | `/readiness` | Kubernetes-style readiness probe |
178 | | `/metrics` | Prometheus metrics |
179 |
180 | ### File Format
181 |
182 | The `posts.json` file format remains compatible:
183 |
184 | ```json
185 | [
186 | {
187 | "userId": 1,
188 | "id": 1,
189 | "title": "Post Title",
190 | "body": "Post body content"
191 | }
192 | ]
193 | ```
194 |
195 | v2.0 adds optional fields:
196 | - `createdAt`: Timestamp when post was created
197 | - `updatedAt`: Timestamp when post was last updated
198 |
199 | These are automatically managed and backward compatible.
200 |
201 | ## Feature Comparison
202 |
203 | | Feature | v1.0 | v2.0 |
204 | |---------|------|------|
205 | | Post Management | ✅ | ✅ |
206 | | Character Analysis | ✅ | ✅ (faster) |
207 | | External API Fetch | ✅ | ✅ |
208 | | File Storage | ✅ | ✅ (improved) |
209 | | Database Support | ❌ | ✅ |
210 | | Health Checks | ❌ | ✅ |
211 | | Metrics | ❌ | ✅ |
212 | | Structured Logging | ❌ | ✅ |
213 | | Input Validation | ❌ | ✅ |
214 | | Rate Limiting | ❌ | ✅ |
215 | | Security Headers | ❌ | ✅ |
216 | | CORS | ❌ | ✅ |
217 | | Graceful Shutdown | ❌ | ✅ |
218 | | Docker Support | ❌ | ✅ |
219 | | CI/CD Pipeline | ❌ | ✅ |
220 | | Test Suite | ❌ | ✅ |
221 | | API Documentation | ❌ | ✅ |
222 |
223 | ## Troubleshooting
224 |
225 | ### Issue: Application Won't Start
226 |
227 | **Error**: `invalid configuration: environment must be one of: development, staging, production`
228 |
229 | **Solution**: Set the ENVIRONMENT variable:
230 | ```bash
231 | export ENVIRONMENT=development
232 | ```
233 |
234 | ### Issue: Database Connection Failed
235 |
236 | **Error**: `failed to ping database`
237 |
238 | **Solution**: Ensure PostgreSQL is running:
239 | ```bash
240 | # Check if PostgreSQL is running
241 | docker ps | grep postgres
242 |
243 | # Or check locally
244 | pg_isready -h localhost
245 | ```
246 |
247 | ### Issue: Posts Not Showing
248 |
249 | **Symptom**: Empty home page
250 |
251 | **Solution**: Fetch posts first:
252 | ```bash
253 | curl http://localhost:8080/fetch
254 | ```
255 |
256 | ### Issue: Rate Limited
257 |
258 | **Error**: 429 Too Many Requests
259 |
260 | **Solution**: Increase rate limit:
261 | ```bash
262 | export RATE_LIMIT_REQUESTS=1000
263 | ```
264 |
265 | Or wait for the rate limit window to reset (default: 1 minute).
266 |
267 | ## Performance Considerations
268 |
269 | ### File Storage vs PostgreSQL
270 |
271 | **File Storage**:
272 | - ✅ Simple setup
273 | - ✅ No external dependencies
274 | - ❌ Not suitable for high concurrency
275 | - ❌ No advanced querying
276 |
277 | **PostgreSQL**:
278 | - ✅ High concurrency support
279 | - ✅ ACID transactions
280 | - ✅ Advanced querying
281 | - ❌ Requires external service
282 |
283 | **Recommendation**: Use file storage for development, PostgreSQL for production.
284 |
285 | ## Security Updates
286 |
287 | v2.0 includes important security improvements:
288 |
289 | 1. **Input Sanitization**: All user input is sanitized
290 | 2. **Rate Limiting**: Prevents abuse
291 | 3. **Security Headers**: CSP, X-Frame-Options, etc.
292 | 4. **Request Timeouts**: Prevents resource exhaustion
293 |
294 | **Action Required**: Review your CORS configuration in `.env`:
295 | ```env
296 | # Development - allow all
297 | ALLOWED_ORIGINS=*
298 |
299 | # Production - specify allowed origins
300 | ALLOWED_ORIGINS=https://yourdomain.com,https://www.yourdomain.com
301 | ```
302 |
303 | ## Monitoring Setup
304 |
305 | ### Basic Monitoring (Logs)
306 |
307 | ```bash
308 | # View logs in production
309 | tail -f /path/to/app/logs
310 |
311 | # Or with Docker
312 | docker logs -f post-analyzer-app
313 | ```
314 |
315 | ### Advanced Monitoring (Prometheus + Grafana)
316 |
317 | ```bash
318 | # Start monitoring stack
319 | docker-compose up -d prometheus grafana
320 |
321 | # Access Grafana
322 | open http://localhost:3000
323 | # Login: admin/admin
324 | ```
325 |
326 | Add Prometheus data source:
327 | 1. Go to Configuration → Data Sources
328 | 2. Add Prometheus
329 | 3. URL: `http://prometheus:9090`
330 | 4. Save & Test
331 |
332 | Import dashboard from `grafana-dashboard.json` (if provided).
333 |
334 | ## Rollback Plan
335 |
336 | If you need to rollback to v1.0:
337 |
338 | ```bash
339 | # Stop v2.0
340 | pkill post-analyzer
341 |
342 | # Restore old version
343 | mv main.go main_v2.go
344 | mv main_old.go main.go
345 |
346 | # Run v1.0
347 | go run main.go
348 | ```
349 |
350 | Your data in `posts.json` remains compatible.
351 |
352 | ## Getting Help
353 |
354 | - 📖 [Full Documentation](README_PRODUCTION.md)
355 | - 🐛 [Report Issues](https://github.com/hoangsonww/Post-Analyzer-Webserver/issues)
356 | - 💬 [Discussions](https://github.com/hoangsonww/Post-Analyzer-Webserver/discussions)
357 |
358 | ## Next Steps
359 |
360 | After successful migration:
361 |
362 | 1. ✅ Review configuration in `.env`
363 | 2. ✅ Set up monitoring (Prometheus/Grafana)
364 | 3. ✅ Configure backups (for PostgreSQL)
365 | 4. ✅ Set up CI/CD pipeline
366 | 5. ✅ Review security settings
367 | 6. ✅ Load test your application
368 | 7. ✅ Set up log aggregation
369 |
370 | ---
371 |
372 | **Need assistance?** Open an issue on GitHub!
373 |
--------------------------------------------------------------------------------
/internal/handlers/handlers.go:
--------------------------------------------------------------------------------
1 | package handlers
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "html"
8 | "html/template"
9 | "net/http"
10 | "regexp"
11 | "strings"
12 | "sync"
13 | "time"
14 |
15 | "Post_Analyzer_Webserver/config"
16 | "Post_Analyzer_Webserver/internal/logger"
17 | "Post_Analyzer_Webserver/internal/metrics"
18 | "Post_Analyzer_Webserver/internal/storage"
19 | )
20 |
21 | // Handler holds dependencies for HTTP handlers
22 | type Handler struct {
23 | storage storage.Storage
24 | config *config.Config
25 | template *template.Template
26 | }
27 |
28 | // New creates a new Handler
29 | func New(store storage.Storage, cfg *config.Config) (*Handler, error) {
30 | // Custom template functions
31 | funcMap := template.FuncMap{
32 | "toJSON": func(v interface{}) string {
33 | data, _ := json.Marshal(v)
34 | return string(data)
35 | },
36 | }
37 |
38 | tmpl, err := template.New("").Funcs(funcMap).ParseFiles("home.html")
39 | if err != nil {
40 | return nil, fmt.Errorf("failed to parse template: %w", err)
41 | }
42 |
43 | return &Handler{
44 | storage: store,
45 | config: cfg,
46 | template: tmpl,
47 | }, nil
48 | }
49 |
50 | // Template variables
51 | type HomePageVars struct {
52 | Title string
53 | Posts []storage.Post
54 | CharFreq map[rune]int
55 | Error string
56 | HasPosts bool
57 | HasAnalysis bool
58 | }
59 |
60 | // Health check endpoint
61 | func (h *Handler) Health(w http.ResponseWriter, r *http.Request) {
62 | w.Header().Set("Content-Type", "application/json")
63 | w.WriteHeader(http.StatusOK)
64 | fmt.Fprintf(w, `{"status":"healthy","timestamp":"%s"}`, time.Now().Format(time.RFC3339))
65 | }
66 |
67 | // Readiness check endpoint
68 | func (h *Handler) Readiness(w http.ResponseWriter, r *http.Request) {
69 | ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
70 | defer cancel()
71 |
72 | // Check if storage is accessible
73 | _, err := h.storage.Count(ctx)
74 | if err != nil {
75 | logger.ErrorContext(r.Context(), "readiness check failed", "error", err)
76 | w.Header().Set("Content-Type", "application/json")
77 | w.WriteHeader(http.StatusServiceUnavailable)
78 | fmt.Fprintf(w, `{"status":"not ready","error":"%s"}`, err.Error())
79 | return
80 | }
81 |
82 | w.Header().Set("Content-Type", "application/json")
83 | w.WriteHeader(http.StatusOK)
84 | fmt.Fprintf(w, `{"status":"ready","timestamp":"%s"}`, time.Now().Format(time.RFC3339))
85 | }
86 |
87 | // Home serves the home page
88 | func (h *Handler) Home(w http.ResponseWriter, r *http.Request) {
89 | posts, err := h.storage.GetAll(r.Context())
90 | if err != nil {
91 | logger.ErrorContext(r.Context(), "failed to get posts", "error", err)
92 | h.renderTemplate(w, HomePageVars{Title: "Home", Error: "Failed to read posts"})
93 | return
94 | }
95 |
96 | h.renderTemplate(w, HomePageVars{Title: "Home", Posts: posts, HasPosts: len(posts) > 0})
97 | }
98 |
99 | // FetchPosts fetches posts from external API and stores them
100 | func (h *Handler) FetchPosts(w http.ResponseWriter, r *http.Request) {
101 | posts, err := h.fetchPostsFromAPI(r.Context())
102 | if err != nil {
103 | logger.ErrorContext(r.Context(), "failed to fetch posts from API", "error", err)
104 | h.renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to fetch posts from external API"})
105 | return
106 | }
107 |
108 | if err := h.storage.BatchCreate(r.Context(), posts); err != nil {
109 | logger.ErrorContext(r.Context(), "failed to store posts", "error", err)
110 | h.renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to store posts"})
111 | return
112 | }
113 |
114 | logger.InfoContext(r.Context(), "posts fetched successfully", "count", len(posts))
115 | h.renderTemplate(w, HomePageVars{Title: "Posts Fetched", Posts: posts, HasPosts: true})
116 | }
117 |
118 | // AnalyzePosts performs character frequency analysis
119 | func (h *Handler) AnalyzePosts(w http.ResponseWriter, r *http.Request) {
120 | start := time.Now()
121 |
122 | posts, err := h.storage.GetAll(r.Context())
123 | if err != nil {
124 | logger.ErrorContext(r.Context(), "failed to get posts for analysis", "error", err)
125 | h.renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to read posts for analysis"})
126 | return
127 | }
128 |
129 | // Combine all post text
130 | var allText strings.Builder
131 | for _, post := range posts {
132 | allText.WriteString(post.Title)
133 | allText.WriteString(" ")
134 | allText.WriteString(post.Body)
135 | allText.WriteString(" ")
136 | }
137 |
138 | charFreq := h.countCharacters(allText.String())
139 |
140 | metrics.RecordAnalysisOperation(time.Since(start))
141 | logger.InfoContext(r.Context(), "character analysis completed", "duration_ms", time.Since(start).Milliseconds())
142 |
143 | h.renderTemplate(w, HomePageVars{Title: "Character Analysis", CharFreq: charFreq, HasAnalysis: true})
144 | }
145 |
146 | // AddPost adds a new post
147 | func (h *Handler) AddPost(w http.ResponseWriter, r *http.Request) {
148 | if r.Method == http.MethodPost {
149 | // Parse form data
150 | if err := r.ParseForm(); err != nil {
151 | logger.ErrorContext(r.Context(), "failed to parse form", "error", err)
152 | h.renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to parse form data"})
153 | return
154 | }
155 |
156 | // Sanitize and validate input
157 | title := h.sanitizeInput(r.FormValue("title"))
158 | body := h.sanitizeInput(r.FormValue("body"))
159 |
160 | if title == "" || body == "" {
161 | h.renderTemplate(w, HomePageVars{Title: "Error", Error: "Title and body are required"})
162 | return
163 | }
164 |
165 | post := &storage.Post{
166 | UserId: 1,
167 | Title: title,
168 | Body: body,
169 | }
170 |
171 | if err := h.storage.Create(r.Context(), post); err != nil {
172 | logger.ErrorContext(r.Context(), "failed to create post", "error", err)
173 | h.renderTemplate(w, HomePageVars{Title: "Error", Error: "Failed to create post"})
174 | return
175 | }
176 |
177 | // Get all posts to display
178 | posts, _ := h.storage.GetAll(r.Context())
179 | logger.InfoContext(r.Context(), "post added successfully", "id", post.Id)
180 | h.renderTemplate(w, HomePageVars{Title: "Post Added", Posts: posts, HasPosts: true})
181 | } else {
182 | h.renderTemplate(w, HomePageVars{Title: "Add New Post"})
183 | }
184 | }
185 |
186 | // fetchPostsFromAPI fetches posts from external API
187 | func (h *Handler) fetchPostsFromAPI(ctx context.Context) ([]storage.Post, error) {
188 | client := &http.Client{
189 | Timeout: h.config.External.HTTPTimeout,
190 | }
191 |
192 | req, err := http.NewRequestWithContext(ctx, "GET", h.config.External.JSONPlaceholderURL, nil)
193 | if err != nil {
194 | return nil, err
195 | }
196 |
197 | resp, err := client.Do(req)
198 | if err != nil {
199 | return nil, err
200 | }
201 | defer resp.Body.Close()
202 |
203 | if resp.StatusCode != http.StatusOK {
204 | return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
205 | }
206 |
207 | var posts []storage.Post
208 | if err := json.NewDecoder(resp.Body).Decode(&posts); err != nil {
209 | return nil, err
210 | }
211 |
212 | return posts, nil
213 | }
214 |
215 | // countCharacters counts character frequency efficiently
216 | func (h *Handler) countCharacters(text string) map[rune]int {
217 | charCount := make(map[rune]int)
218 |
219 | // Process in chunks for better performance with large texts
220 | const chunkSize = 1000
221 | if len(text) <= chunkSize {
222 | // Small text, process directly
223 | for _, char := range text {
224 | charCount[char]++
225 | }
226 | return charCount
227 | }
228 |
229 | // Large text, use concurrent processing
230 | mu := sync.Mutex{}
231 | wg := sync.WaitGroup{}
232 |
233 | numWorkers := 4
234 | chunkLen := (len(text) + numWorkers - 1) / numWorkers
235 |
236 | for i := 0; i < numWorkers; i++ {
237 | start := i * chunkLen
238 | end := start + chunkLen
239 | if end > len(text) {
240 | end = len(text)
241 | }
242 | if start >= len(text) {
243 | break
244 | }
245 |
246 | wg.Add(1)
247 | go func(chunk string) {
248 | defer wg.Done()
249 | localCount := make(map[rune]int)
250 | for _, char := range chunk {
251 | localCount[char]++
252 | }
253 |
254 | mu.Lock()
255 | for char, count := range localCount {
256 | charCount[char] += count
257 | }
258 | mu.Unlock()
259 | }(text[start:end])
260 | }
261 |
262 | wg.Wait()
263 | return charCount
264 | }
265 |
266 | // sanitizeInput sanitizes user input to prevent XSS
267 | func (h *Handler) sanitizeInput(input string) string {
268 | // Remove any HTML tags
269 | input = html.EscapeString(input)
270 |
271 | // Remove any potential script tags or event handlers
272 | input = regexp.MustCompile(`(?i)
10 | 
11 | 
12 | 
13 | Error: {{.Error}}
151 | {{end}} 152 | {{if eq .Title "Home"}} 153 |Welcome to the Post Viewer and Analyzer!
154 |This application allows you to:
155 |-
156 |
- Fetch posts from an external API and view them. 157 |
- Analyze character frequency in the posts (calculated in your browser). 158 |
- Add new posts to the existing list. 159 |
Recent Posts:
162 |
163 | {{range .Posts}}
164 |
170 | {{end}}
171 | {{else if eq .Title "Add New Post"}}
172 |
185 | {{else if .HasPosts}}
186 |
165 | {{.Title}}
166 |
168 | {{end}}
169 | {{.Body}}
167 |
187 |
195 | {{end}}
196 |
197 |
198 | Fetched Posts:
188 | {{range .Posts}} 189 |
190 | {{.Title}}
191 |
193 | {{end}}
194 | {{.Body}}
192 |
199 |
229 | Character Frequency Analysis (Client-Side)
200 | 201 |
202 |
219 |
220 |
203 |
206 | Total Posts
204 | 0
205 |
207 |
210 | Total Characters
208 | 0
209 |
211 |
214 | Unique Characters
212 | 0
213 |
215 |
218 | Average Post Length
216 | 0
217 |
221 |
222 |
223 |
224 |
225 |
228 |