System Design: Building a Parking Lot System in Go

In this article, we’ll go through a low-level design (LLD) implementation of a parking lot system in Go. We'll explore different aspects of the system and see how each component interacts with the rest. This implementation focuses on clarity and real-world usefulness, so you can extend it easily if you want to add features like more vehicle types, multiple payment options, or spot reservations.

The system handles tasks like managing parking floors and spots, parking and unparking vehicles, and processing payments. We’ll also ensure it’s thread-safe for concurrent access, so if we need to expand it into a larger system, it won’t break down under pressure.

---

Core Components

Our design includes six main components:

1. Parking Lot - The main entry point managing floors and parking operations.
2. Parking Floor - Each floor contains multiple parking spots for different types of vehicles.
3. Parking Spot - Represents a parking spot that can hold a specific type of vehicle.
4. Parking Ticket - Tracks entry/exit times, parking charges, and the associated vehicle.
5. Payment System - Handles parking fee calculations and payment processing.
6. Vehicle Types - Supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge.

Singleton Parking Lot

Our ParkingLot uses the Singleton pattern. This means there’s only one instance of the parking lot, which is created once and reused across the application. Here’s the code to get that working:

var (
    parkingLotInstance *ParkingLot
    once               sync.Once
)

type ParkingLot struct {
    Name   string
    floors []*ParkingFloor
}

func GetParkingLotInstance() *ParkingLot {
    once.Do(func() {
        parkingLotInstance = &ParkingLot{}
    })
    return parkingLotInstance
}

Using sync.Once, we ensure that only one instance is created, even when accessed by multiple goroutines.

Managing Floors in the Parking Lot

The parking lot has multiple floors, each with designated parking spots for different vehicle types (e.g., cars, vans, trucks, and motorcycles). To add a floor to the parking lot, we use the AddFloor method:

func (p *ParkingLot) AddFloor(floorID int) {
    p.floors = append(p.floors, NewParkingFloor(floorID))
}

Each floor is created using the NewParkingFloor function, which organizes spots by vehicle type.

Parking Spots

Each ParkingSpot is associated with a specific vehicle type (like a car or motorcycle). This allows the system to manage and restrict which vehicles can park in each spot. Here’s the ParkingSpot structure and the ParkVehicle method:

type ParkingSpot struct {
    SpotID         int
    VehicleType    vehicles.VehicleType
    CurrentVehicle *vehicles.VehicleInterface
    lock           sync.Mutex
}

func (p *ParkingSpot) ParkVehicle(vehicle vehicles.VehicleInterface) error {
    p.lock.Lock()
    defer p.lock.Unlock()

    if vehicle.GetVehicleType() != p.VehicleType {
        return fmt.Errorf("vehicle type mismatch: expected %s, got %s", p.VehicleType, vehicle.GetVehicleType())
    }
    if p.CurrentVehicle != nil {
        return fmt.Errorf("parking spot already occupied")
    }

    p.CurrentVehicle = &vehicle
    return nil
}

We use a Mutex lock to make sure only one vehicle can park in a spot at a time.

Parking Ticket

Every vehicle gets a ticket with the entry time, exit time, parking spot, and total charge. This ticket will be updated when the vehicle exits, and charges will be calculated based on the time spent parked.

type ParkingTicket struct {
    EntryTime   time.Time
    ExitTime    time.Time
    Vehicle     vehicles.VehicleInterface
    Spot        *ParkingSpot
    TotalCharge float64
}

func NewParkingTicket(vehicle vehicles.VehicleInterface, spot *ParkingSpot) *ParkingTicket {
    return &ParkingTicket{EntryTime: time.Now(), ExitTime: time.Time{}, Vehicle: vehicle, Spot: spot, TotalCharge: 0.00}
}

The CalculateTotalCharge method calculates parking fees based on the vehicle type and duration.

Payment System

The PaymentSystem class processes the payment, updating the payment status based on whether the required amount is paid:

type PaymentSystem struct {
    Status        Status
    Amount        float64
    ParkingTicket *ParkingTicket
}

func (p *PaymentSystem) ProcessPayment() error {
    if p.ParkingTicket == nil {
        return fmt.Errorf("payment failed: no parking ticket found")
    }
    if p.ParkingTicket.TotalCharge < p.Amount {
        p.Status = PaymentStatusFailed
        return fmt.Errorf("payment failed: insufficient funds")
    }

    p.Status = PaymentStatusCompleted
    return nil
}

The ProcessPayment function checks the amount and updates the payment status to Completed or Failed.

Adding Vehicle Types

Our system supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge. This is achieved by setting up a VehicleType and VehicleInterface in a separate vehicles package:

package vehicles

type VehicleType string

const (
    CarType        VehicleType = "Car"
    VanType        VehicleType = "Van"
    TruckType      VehicleType = "Truck"
    MotorcycleType VehicleType = "Motorcycle"
)

type VehicleInterface interface {
    GetLicenceNumber() string
    GetVehicleType() VehicleType
    GetVehicleCost() float64
}

We can create new vehicles by calling NewCar, NewVan, NewTruck, etc., each of which implements VehicleInterface.

---

Bringing It All Together

Let’s see how the pieces fit together in a flow:

• Create a Parking Lot: Call GetParkingLotInstance() and add floors with AddFloor.
• Find Parking Spot and Park Vehicle: ParkVehicle method finds an available spot, validates it against the vehicle type, and generates a ticket.
• Unpark Vehicle and Process Payment: UnparkVehicle generates the total charge, initiates the payment system, and completes the transaction.

---

This parking lot system is a simplified starting point for building more complex systems. We covered the basics of floor and spot management, vehicle parking and unparking, and a basic payment process.

For full code implementation, check the following repository:

thesaltree / low-level-design-golang

Low level system design solutions in Golang

Low-Level System Design in Go

Welcome to the Low-Level System Design in Go repository! This repository contains various low-level system design problems and their solutions implemented in Go. The primary aim is to demonstrate the design and architecture of systems through practical examples.

Table of Contents

• Overview
• Parking Lot System
• Elevator System
• Library Management System
• Vending Machine System
• Social Media Platform

Overview

Low-level system design involves understanding the core concepts of system architecture and designing scalable, maintainable, and efficient systems. This repository will try to cover solutions of various problems and scenarios using Go.

Parking Lot System

The first project in this repository is a Parking Lot System. This system simulates a parking lot where vehicles can be parked and unparked. It demonstrates:

• Singleton design pattern for managing the parking lot instance.
• Handling different types of vehicles (e.g., cars, trucks).
• Parking space management across multiple floors.
• Payment processing for…

View on GitHub