Okay, congratulations on completing the implementation of the Payment Microservice! It's now equipped to listen for `OrderCreatedEvent`, simulate payment processing, and publish the results (`PaymentProcessedEvent` or `PaymentFailedEvent`), complete with logging, testing, and health checks. With the Order and Payment services functional, we now turn our attention to the next participant in this event-driven choreography: the **Inventory Microservice**. Its role will be to react to successful payment events (`PaymentProcessedEvent`) by checking stock availability and reserving items. Eventually, it will publish its own events indicating whether inventory was successfully updated or if items are out of stock. Just as we did for the Order and Payment services, the first step is to create a clean, isolated foundation for the Inventory Service. This involves setting up its dedicated directory structure and initializing its Go module. ### Why a Dedicated Structure (Again)? Consistency is key in a multi-service project. Establishing a dedicated structure for the Inventory Service reinforces the principles of microservices: * **Isolation:** Keeps inventory-specific logic (stock management, database interaction if needed, event handling) separate from other services. * **Independent Development & Deployment:** Allows the Inventory Service to be worked on, tested, and deployed without impacting the Order or Payment services. * **Clear Boundaries:** Makes the codebase easier to navigate and understand. * **Focused Dependencies:** Its `go.mod` file will only list dependencies relevant to inventory tasks (like the NATS client, shared events, potentially a database driver or in-memory store library). ### Establishing the Inventory Service Structure We'll replicate the standard Go project layout used previously. 1. **Navigate to Project Root:** Open your terminal and make sure you are in the top-level `event-driven-choreography` directory, alongside `order-service/`, `payment-service/`, and `pkg/`. ```bash # Example: cd /path/to/your/event-driven-choreography pwd ls -l ``` 2. **Create the Service Root Directory:** ```bash mkdir inventory-service ``` 3. **Navigate into the Service Directory:** ```bash cd inventory-service ``` 4. **Create `cmd` Directory:** This will hold the main entry point. ```bash mkdir -p cmd/inventoryservice ``` 5. **Create `internal` Directory:** This directory will house all the private code specific to this service (event handlers, inventory logic, etc.). ```bash mkdir internal ``` 6. **Initialize the Go Module:** Create the `go.mod` file for this service. ```bash go mod init event-driven-choreography/inventory-service ``` Your project structure should now include the `inventory-service`: ```text event-driven-choreography/ ├── docker-compose.yml ├── pkg/ │ └── events/ │ ├── events.go │ └── go.mod ├── order-service/ │ ├── cmd/ │ │ └── orderservice/ │ │ └── main.go │ ├── internal/ │ │ └── ... │ └── go.mod ├── payment-service/ │ ├── cmd/ │ │ └── paymentservice/ │ │ └── main.go │ ├── internal/ │ │ └── ... │ └── go.mod ├── inventory-service/ # <<< Root for the Inventory Service │ ├── cmd/ │ │ └── inventoryservice/ # <<< Entry point directory │ ├── internal/ # <<< Internal service code directory │ └── go.mod # <<< Module definition for inventory-service └── ... ``` ### Creating a Placeholder `main.go` To provide an entry point and establish consistency from the start, let's create a basic `main.go` file, including the `slog` setup and graceful shutdown pattern used in the other services. Create the file `inventory-service/cmd/inventoryservice/main.go`: ```go // inventory-service/cmd/inventoryservice/main.go package main import ( // Use slog for consistency "log/slog" "os" "os/signal" "syscall" // Import other necessary packages later (context, time, internal packages, nats, etc.) ) func main() { // --- Configure Structured Logger (slog) --- // Setup default JSON logger (same pattern as other services) logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ Level: slog.LevelInfo, // Adjust level via config later if needed AddSource: true, // Include source file/line number })) slog.SetDefault(logger) slog.Info("Starting Inventory Service...") // --- TODO: Add setup code later --- // - Load Configuration (NATS URL, Inventory settings/DB details if needed) // - Connect to NATS // - Setup Event Subscription (e.g., subscribe to "payments.processed") // - Initialize Inventory Store (in-memory map or database connection) // - Instantiate dependencies (event handler, inventory manager) // - Start the subscriber/listener process // --- Graceful Shutdown Handling --- // Setup graceful shutdown (similar to other services) slog.Info("Setting up graceful shutdown handler...") quit := make(chan os.Signal, 1) // Buffered channel to prevent signal loss signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) // Block until a signal is received receivedSignal := <-quit slog.Info("Received shutdown signal", slog.String("signal", receivedSignal.String())) slog.Info("Starting graceful shutdown...") // TODO: Add graceful shutdown logic here: // - Drain/Unsubscribe NATS subscription // - Close NATS connection // - Close Database connection (if used) // - Shutdown HTTP server (if health check endpoint is added) slog.Info("Inventory Service shut down complete.") } ``` **Explanation:** * **`package main`**: Standard declaration for an executable. * **`slog` Setup**: Initializes the structured JSON logger as the default, ensuring consistent logging format from the beginning. We use `LevelInfo` and include the source location for development. * **`main()`**: The entry point. * **TODO Placeholders**: Clearly mark where future logic for configuration, NATS connection, subscription, inventory management, and dependency injection will be added in subsequent tasks. * **Graceful Shutdown**: Implements the standard signal listening pattern (`SIGINT`, `SIGTERM`) to allow the service to shut down cleanly. TODO comments indicate where specific cleanup actions (like unsubscribing from NATS) will be added. You can test this skeleton structure: ```bash # Navigate to the inventory-service directory # Example: cd /path/to/your/event-driven-choreography/inventory-service # Run the main package go run ./cmd/inventoryservice/main.go ``` You should see the structured JSON log message "Starting Inventory Service...". You have now successfully created the fundamental directory structure and Go module for the Inventory Service, providing a clean and isolated foundation consistent with the other services in your project. ### Next Steps With the basic structure for the `inventory-service` in place, the immediate next task according to the roadmap is to equip it with the necessary tools for communication: **Add the Go client library for the message broker** (`github.com/nats-io/nats.go`) as a dependency to the `inventory-service/go.mod` file. ### Further Reading * **Standard Go Project Layout:** [https://github.com/golang-standards/project-layout](https://github.com/golang-standards/project-layout) (A useful reference, even if you adapt parts of it) * **Go Modules Reference:** [https://go.dev/ref/mod](https://go.dev/ref/mod) (Official documentation for Go modules) * **`log/slog` package:** [https://pkg.go.dev/log/slog](https://pkg.go.dev/log/slog) (Review structured logging concepts)