Refactor configuration management and enhance build process

- Introduced a YAML-based configuration system, allowing for automatic generation of a default `config.yaml` file.
- Updated the application to load configuration settings from the YAML file, improving flexibility and ease of use.
- Added a Makefile to streamline development tasks, including running the application, testing, and managing dependencies.
- Enhanced `.gitignore` to include build artifacts and configuration files.
- Removed unused Prometheus metrics and related code to simplify the codebase.
- Updated dependencies in `go.mod` and `go.sum` for improved functionality and performance.

steamcache/steamcache_test.go

@@ -110,46 +110,6 @@ func TestCacheMissAndHit(t *testing.T) {
 	}
 }
 
-func TestHashExtraction(t *testing.T) {
-	// Test the specific key from the user's issue
-	testCases := []struct {
-		filename       string
-		expectedHash   string
-		shouldHaveHash bool
-	}{
-		{
-			filename:       "e89c81a1a926eb4732e146bc806491da8a7d89ca",
-			expectedHash:   "e89c81a1a926eb4732e146bc806491da8a7d89ca",
-			shouldHaveHash: true, // Now it should work with the new standalone hash pattern
-		},
-		{
-			filename:       "chunk_e89c81a1a926eb4732e146bc806491da8a7d89ca",
-			expectedHash:   "",
-			shouldHaveHash: false, // No longer supported with simplified patterns
-		},
-		{
-			filename:       "file.e89c81a1a926eb4732e146bc806491da8a7d89ca.chunk",
-			expectedHash:   "",
-			shouldHaveHash: false, // No longer supported with simplified patterns
-		},
-		{
-			filename:       "chunk_abc123def456",
-			expectedHash:   "",
-			shouldHaveHash: false, // Not 40 chars
-		},
-	}
-
-	for _, tc := range testCases {
-		hash, hasHash := extractHashFromFilename(tc.filename)
-		if hasHash != tc.shouldHaveHash {
-			t.Errorf("filename: %s, expected hasHash: %v, got: %v", tc.filename, tc.shouldHaveHash, hasHash)
-		}
-		if hasHash && hash != tc.expectedHash {
-			t.Errorf("filename: %s, expected hash: %s, got: %s", tc.filename, tc.expectedHash, hash)
-		}
-	}
-}
-
 func TestHashCalculation(t *testing.T) {
 	// Test data
 	testData := []byte("Hello, World!")
@@ -211,23 +171,23 @@ func TestResponseHashCalculation(t *testing.T) {
 	}
 
 	bodyData := []byte("Hello, World!")
-	
+
 	// Calculate response hash
 	responseHash := calculateResponseHash(resp, bodyData)
-	
+
 	// The hash should be different from just the body hash
 	bodyHash := calculateFileHash(bodyData)
-	
+
 	if responseHash == bodyHash {
 		t.Error("Response hash should be different from body hash when headers are present")
 	}
-	
+
 	// Test that the same response produces the same hash
 	responseHash2 := calculateResponseHash(resp, bodyData)
 	if responseHash != responseHash2 {
 		t.Error("Response hash should be consistent for the same response")
 	}
-	
+
 	// Test with different headers
 	resp2 := &http.Response{
 		StatusCode: 200,
@@ -237,9 +197,74 @@ func TestResponseHashCalculation(t *testing.T) {
 			"Content-Length": []string{"13"},
 		},
 	}
-	
+
 	responseHash3 := calculateResponseHash(resp2, bodyData)
 	if responseHash == responseHash3 {
 		t.Error("Response hash should be different for different headers")
 	}
 }
+
+func TestSteamKeySharding(t *testing.T) {
+	sc := New("localhost:8080", "0", "1G", t.TempDir(), "", "lru", "lru")
+
+	// Test with a Steam-style key that should trigger sharding
+	steamKey := "steam/0016cfc5019b8baa6026aa1cce93e685d6e06c6e"
+	testData := []byte("test steam cache data")
+
+	// Create a file with the steam key
+	w, err := sc.vfs.Create(steamKey, int64(len(testData)))
+	if err != nil {
+		t.Fatalf("Failed to create file with steam key: %v", err)
+	}
+	w.Write(testData)
+	w.Close()
+
+	// Verify we can read it back
+	rc, err := sc.vfs.Open(steamKey)
+	if err != nil {
+		t.Fatalf("Failed to open file with steam key: %v", err)
+	}
+	got, _ := io.ReadAll(rc)
+	rc.Close()
+
+	if string(got) != string(testData) {
+		t.Errorf("Data mismatch: expected %s, got %s", testData, got)
+	}
+
+	// Verify that the file was created (sharding is working if no error occurred)
+	// The key difference is that with sharding, the file should be created successfully
+	// and be readable, whereas without sharding it might not work correctly
+}
+
+func TestKeyGeneration(t *testing.T) {
+	testCases := []struct {
+		input    string
+		expected string
+		desc     string
+	}{
+		{
+			input:    "/depot/1684171/chunk/0016cfc5019b8baa6026aa1cce93e685d6e06c6e",
+			expected: "steam/0016cfc5019b8baa6026aa1cce93e685d6e06c6e",
+			desc:     "chunk file URL",
+		},
+		{
+			input:    "/depot/1684171/manifest/944076726177422892/5/12001286503415372840",
+			expected: "steam/12001286503415372840",
+			desc:     "manifest file URL",
+		},
+		{
+			input:    "/depot/invalid/path",
+			expected: "",
+			desc:     "invalid depot URL format",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			result := generateSteamCacheKey(tc.input)
+			if result != tc.expected {
+				t.Errorf("generateSteamCacheKey(%s) = %s, expected %s", tc.input, result, tc.expected)
+			}
+		})
+	}
+}