# SteamCache2

SteamCache2 is a blazing fast download cache for Steam, designed to reduce bandwidth usage and speed up game downloads.

## Features

- High-speed caching for Steam downloads
- Tiered storage for getting the most out of your storage media
- Garbage Collected storage for limiting the size of RAM or Disk cache and will not go above what you choose or stop caching unlike others
- Reduces bandwidth usage
- Easy to set up and configure aside from dns stuff to trick Steam into using it
- Supports multiple clients
- **NEW:** YAML configuration system with automatic config generation
- **NEW:** Simple Makefile for development workflow
- Cross-platform builds (Linux, macOS, Windows)

## Quick Start

### First Time Setup

1. **Clone and build:**
   ```bash
   git clone <repository-url>
   cd steamcache2
   make  # This will run tests and build the application
   ```

2. **Run the application** (it will create a default config):
   ```bash
   ./steamcache2
   # or on Windows:
   steamcache2.exe
   ```

   The application will automatically create a `config.yaml` file with default settings and exit, allowing you to customize it.

3. **Edit the configuration** (`config.yaml`):
   ```yaml
   listen_address: :80
   cache:
       memory:
           size: 1GB
           gc_algorithm: lru
       disk:
           size: 10GB
           path: ./disk
           gc_algorithm: hybrid
   upstream: "https://steam.cdn.com"  # Set your upstream server
   ```

4. **Run the application again:**
   ```bash
   make run  # or ./steamcache2
   ```

### Development Workflow

```bash
# Run all tests and start the application (default target)
make

# Run only tests
make test

# Run with debug logging
make run-debug

# Download dependencies
make deps

# Show available commands
make help
```

### Command Line Flags

While most configuration is done via the YAML file, some runtime options are still available as command-line flags:

```bash
# Use a custom config file
./steamcache2 --config /path/to/my-config.yaml

# Set logging level
./steamcache2 --log-level debug --log-format json

# Set number of worker threads
./steamcache2 --threads 8

# Show help
./steamcache2 --help
```

### Configuration

SteamCache2 uses a YAML configuration file (`config.yaml`) for all settings. Here's a complete configuration example:

```yaml
# Server configuration
listen_address: :80

# Cache configuration
cache:
  # Memory cache settings
  memory:
    # Size of memory cache (e.g., "512MB", "1GB", "0" to disable)
    size: 1GB
    # Garbage collection algorithm
    gc_algorithm: lru

  # Disk cache settings
  disk:
    # Size of disk cache (e.g., "10GB", "50GB", "0" to disable)
    size: 10GB
    # Path to disk cache directory
    path: ./disk
    # Garbage collection algorithm
    gc_algorithm: hybrid

# Upstream server configuration
# The upstream server to proxy requests to
upstream: "https://steam.cdn.com"
```

#### Garbage Collection Algorithms

SteamCache2 supports different garbage collection algorithms for memory and disk caches, allowing you to optimize performance for each storage tier:

**Available GC Algorithms:**

- **`lru`** (default): Least Recently Used - evicts oldest accessed files
- **`lfu`**: Least Frequently Used - evicts least accessed files (good for popular content)
- **`fifo`**: First In, First Out - evicts oldest created files (predictable)
- **`largest`**: Size-based - evicts largest files first (maximizes file count)
- **`smallest`**: Size-based - evicts smallest files first (maximizes cache hit rate)
- **`hybrid`**: Combines access time and file size for optimal eviction

**Recommended Algorithms by Cache Type:**

**For Memory Cache (Fast, Limited Size):**
- **`lru`** - Best overall performance, good balance of speed and hit rate
- **`lfu`** - Excellent for gaming cafes where popular games stay cached
- **`hybrid`** - Optimal for mixed workloads with varying file sizes

**For Disk Cache (Slow, Large Size):**
- **`hybrid`** - Recommended for optimal performance, balances speed and storage efficiency
- **`largest`** - Good for maximizing number of cached files
- **`lru`** - Reliable default with good performance

**Use Cases:**
- **Gaming Cafes**: Use `lfu` for memory, `hybrid` for disk
- **LAN Events**: Use `lfu` for memory, `hybrid` for disk
- **Home Use**: Use `lru` for memory, `hybrid` for disk
- **Testing**: Use `fifo` for predictable behavior
- **Large File Storage**: Use `largest` for disk to maximize file count

### DNS Configuration

Configure your DNS to direct Steam traffic to your SteamCache2 server:

- If you're on Windows and don't want a whole network implementation, see the [Windows Hosts File Override](#windows-hosts-file-override) section below.

### Windows Hosts File Override

1. Open Notepad as Administrator:
    - Click on the Start menu, type `Notepad`, right-click on Notepad, and select `Run as administrator`.

2. Open the Hosts File:
    - In Notepad, go to `File` > `Open`.
    - Navigate to `C:\Windows\System32\drivers\etc`.
    - Select `All Files` from the dropdown menu to see the hosts file.
    - Open the `hosts` file.

3. Add the Override Entry:
    - At the end of the file, add a new line with the IP address of your SteamCache2 server followed by `lancache.steamcontent.com`. For example:
      ```plaintext
      192.168.1.100 lancache.steamcontent.com
      ```
      Replace `192.168.1.100` with the actual IP address of your SteamCache2 server.

4. Save the Hosts File:
    - Save the changes by going to `File` > `Save`.

5. Flush DNS Cache (optional but recommended):
    - Open Command Prompt as Administrator.
    - Run the following command to flush the DNS cache:
      ```sh
      ipconfig /flushdns
      ```

6. Restart
    - Restart Steam or Restart Your PC

This will direct any requests to `lancache.steamcontent.com` to your SteamCache2 server.

## Building from Source

### Prerequisites

- Go 1.19 or later
- Make (optional, but recommended)

### Build Commands

```bash
# Clone the repository
git clone <repository-url>
cd SteamCache2

# Download dependencies
make deps

# Run tests
make test

# Build for current platform
go build -o steamcache2 .

# Build for specific platforms
GOOS=linux GOARCH=amd64 go build -o steamcache2-linux-amd64 .
GOOS=windows GOARCH=amd64 go build -o steamcache2-windows-amd64.exe .
```

### Development

```bash
# Run in development mode with debug logging
make run-debug

# Run all tests and start the application
make
```

## Troubleshooting

### Common Issues

1. **"Config file not found" on first run**
   - This is expected! SteamCache2 will automatically create a default `config.yaml` file
   - Edit the generated config file with your desired settings
   - Run the application again

2. **Permission denied when creating config**
   - Make sure you have write permissions in the current directory
   - Try running with elevated privileges if necessary

3. **Port already in use**
   - Change the `listen_address` in `config.yaml` to a different port (e.g., `:8080`)
   - Or stop the service using the current port

4. **High memory usage**
   - Reduce the memory cache size in `config.yaml`
   - Consider using disk-only caching by setting `memory.size: "0"`

5. **Slow disk performance**
   - Use SSD storage for the disk cache
   - Consider using a different GC algorithm like `hybrid`
   - Adjust the disk cache size to match available storage

### Getting Help

- Check the logs for detailed error messages
- Run with `--log-level debug` for more verbose output
- Ensure your upstream server is accessible
- Verify DNS configuration is working correctly

## License

See the [LICENSE](LICENSE) file for details.
But just for clarity this covers all files in this project unless stated in the individual file.

## Acknowledgements

- Inspired by [Lancache.net](https://lancache.net/)