modelcontextprotocol/registry
Watch
1
0
Fork
You've already forked registry
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(database): support SeedFile import for memory database (#128)

Browse source 
<!-- Provide a brief summary of your changes -->
Add SeedFile import support for memory database to ensure consistent
seed data loading across both MongoDB and memory modes.

## Motivation and Context
<!-- Why is this change needed? What problem does it solve? -->
Previously, SeedFile import was only available when using MongoDB. After
memory database support was added, it lacked this feature, leading to
inconsistent behavior and missing seed data during development or
testing.
This PR solves the problem by enabling the application to load SeedFile
data even when running with a memory database, ensuring consistency and
improving the developer/testing experience.

## How Has This Been Tested?
<!-- Have you tested this in a real application? Which scenarios were
tested? -->


```bash
$ export MCP_REGISTRY_DATABASE_TYPE="memory"
$ ./scripts/test_endpoints.sh
==================================================
MCP Registry Endpoint Test Script
==================================================
This script expects the MCP Registry server to be running locally.
Please ensure the server is started using one of the following methods:
  • Docker Compose: docker compose up
  • Direct execution: go run cmd/registry/main.go
  • Built binary: ./build/registry
==================================================

Testing health endpoint: http://localhost:8080/v0/health
Status Code: 200
Response:
{
  "status": "ok",
  "github_client_id": ""
}
Health check successful
-------------------------------------
Testing servers endpoint: http://localhost:8080/v0/servers
Status Code: 200
Response Summary:
Total registries: 30
servers Names:
io.github.appcypher/awesome-mcp-servers
io.github.kenjihikmatullah/productboard-mcp
io.github.kyrietangsheng/mcp-server-nationalparks
io.github.gongrzhe/redis-mcp-server
io.github.zubeidhendricks/youtube-mcp-server
io.github.zzaebok/mcp-wikidata
io.github.ihor-sokoliuk/mcp-searxng
io.github.sv/mcp-paradex-py
io.github.felores/airtable-mcp
io.github.eqtylab/mcp-guardian
io.github.co-browser/attestable-mcp-server
io.github.ubie-oss/mcp-vertexai-search
io.github.kukapay/crypto-indicators-mcp
io.github.pinecone-io/assistant-mcp
io.github.metricool/mcp-metricool
io.github.r-huijts/strava-mcp
io.github.googleapis/genai-toolbox
io.github.wilsonchenghy/shadertoy-mcp
io.github.klavis-ai/klavis
io.github.fireproof-storage/mcp-database-server
io.github.xxxbrian/mcp-rquest
io.github.geropl/linear-mcp-go
io.github.amornpan/py-mcp-mssql
io.github.chaindead/telegram-mcp
io.github.bazinga012/mcp_code_executor
io.github.lharries/whatsapp-mcp
io.github.mektigboy/server-hyperliquid
io.github.omar-v2/mcp-ical
io.github.open-strategy-partners/osp_marketing_tools
io.github.smn2gnt/mcp-salesforce

Pagination Metadata:
{
  "next_cursor": "0e45cb5a-5b45-47f3-8b5e-12bdf88d176a",
  "count": 30
}

servers Details:
{
  "servers": [
    {
      "id": "0007544a-3948-4934-866b-b4a96fe53b55",
      "name": "io.github.appcypher/awesome-mcp-servers",
      "description": "Awesome MCP Servers - A curated list of Model Context Protocol servers",
      "repository": {
        "url": "https://github.com/appcypher/awesome-mcp-servers",
        "source": "github",
        "id": "895801050"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:16:40Z",
        "is_latest": true
      }
    },
    {
      "id": "00613acb-73e2-4f93-8b96-296df17316c8",
      "name": "io.github.kenjihikmatullah/productboard-mcp",
      "description": "Integrate the Productboard API into agentic workflows via MCP",
      "repository": {
        "url": "https://github.com/kenjihikmatullah/productboard-mcp",
        "source": "github",
        "id": "939104710"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:12:44Z",
        "is_latest": true
      }
    },
    {
      "id": "010904ec-6e39-4bdc-878a-75a6e79d0500",
      "name": "io.github.kyrietangsheng/mcp-server-nationalparks",
      "description": "",
      "repository": {
        "url": "https://github.com/KyrieTangSheng/mcp-server-nationalparks",
        "source": "github",
        "id": "951713109"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:11:05Z",
        "is_latest": true
      }
    },
    {
      "id": "01129bff-3d65-4e3d-8e82-6f2f269f818c",
      "name": "io.github.gongrzhe/redis-mcp-server",
      "description": "A Redis MCP server (pushed to https://github.com/modelcontextprotocol/servers/tree/main/src/redis) implementation for interacting with Redis databases. This server enables LLMs to interact with Redis key-value stores through a set of standardized tools.",
      "repository": {
        "url": "https://github.com/GongRzhe/REDIS-MCP-Server",
        "source": "github",
        "id": "907849235"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:21Z",
        "is_latest": true
      }
    },
    {
      "id": "0278fd92-a009-4a47-a6df-5f77db37e6ab",
      "name": "io.github.zubeidhendricks/youtube-mcp-server",
      "description": "MCP Server for YouTube API, enabling video management, Shorts creation, and advanced analytics",
      "repository": {
        "url": "https://github.com/ZubeidHendricks/youtube-mcp-server",
        "source": "github",
        "id": "909607678"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:16:14Z",
        "is_latest": true
      }
    },
    {
      "id": "02b79b89-cce8-4401-aa1f-255b01587266",
      "name": "io.github.zzaebok/mcp-wikidata",
      "description": "A server implementation for Wikidata API using the Model Context Protocol (MCP).",
      "repository": {
        "url": "https://github.com/zzaebok/mcp-wikidata",
        "source": "github",
        "id": "959274715"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:15:49Z",
        "is_latest": true
      }
    },
    {
      "id": "02cdb980-1dcd-4345-a8d1-d3f3f522d04b",
      "name": "io.github.ihor-sokoliuk/mcp-searxng",
      "description": "MCP Server for SearXNG",
      "repository": {
        "url": "https://github.com/ihor-sokoliuk/mcp-searxng",
        "source": "github",
        "id": "907172461"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:48Z",
        "is_latest": true
      }
    },
    {
      "id": "038a3024-c319-4a07-bd7f-9cf699cfebf1",
      "name": "io.github.sv/mcp-paradex-py",
      "description": "Connect AI agents to the Paradex trading platform. Retrieve market data, manage accounts, and execute trades seamlessly. Enhance your trading experience with automated tools and real-time insights.",
      "repository": {
        "url": "https://github.com/sv/mcp-paradex-py",
        "source": "github",
        "id": "944258239"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:12:24Z",
        "is_latest": true
      }
    },
    {
      "id": "04216a87-0760-4f25-b809-42ffbfbb8962",
      "name": "io.github.felores/airtable-mcp",
      "description": "Search, create and update Airtable bases, tables, fields, and records using Claude Desktop and MCP (Model Context Protocol) clients",
      "repository": {
        "url": "https://github.com/felores/airtable-mcp",
        "source": "github",
        "id": "904238387"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:02:48Z",
        "is_latest": true
      }
    },
    {
      "id": "04b4489b-db48-4aaa-98f6-036bcf5fd483",
      "name": "io.github.eqtylab/mcp-guardian",
      "description": "Manage / Proxy / Secure your MCP Servers",
      "repository": {
        "url": "https://github.com/eqtylab/mcp-guardian",
        "source": "github",
        "id": "926222936"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:16:58Z",
        "is_latest": true
      }
    },
    {
      "id": "05ca6ccc-d6e1-47ab-ab8d-25949db9ada7",
      "name": "io.github.co-browser/attestable-mcp-server",
      "description": "Verify that any MCP server is running the intended and untampered code via hardware attestation.",
      "repository": {
        "url": "https://github.com/co-browser/attestable-mcp-server",
        "source": "github",
        "id": "955641588"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:03:19Z",
        "is_latest": true
      }
    },
    {
      "id": "07ccf835-680a-42b4-bf0b-db28367519ee",
      "name": "io.github.ubie-oss/mcp-vertexai-search",
      "description": "A MCP server for Vertex AI Search",
      "repository": {
        "url": "https://github.com/ubie-oss/mcp-vertexai-search",
        "source": "github",
        "id": "934580342"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:07:44Z",
        "is_latest": true
      }
    },
    {
      "id": "0852caec-a861-4f9c-9e94-a7c8b67a1641",
      "name": "io.github.kukapay/crypto-indicators-mcp",
      "description": "An MCP server providing a range of cryptocurrency technical analysis indicators and strategies.",
      "repository": {
        "url": "https://github.com/kukapay/crypto-indicators-mcp",
        "source": "github",
        "id": "953321792"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:05:01Z",
        "is_latest": true
      }
    },
    {
      "id": "08668c6a-c2f6-47b0-a4e0-75a8ee9bcf10",
      "name": "io.github.pinecone-io/assistant-mcp",
      "description": "Pinecone Assistant MCP server",
      "repository": {
        "url": "https://github.com/pinecone-io/assistant-mcp",
        "source": "github",
        "id": "940446625"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:01:06Z",
        "is_latest": true
      }
    },
    {
      "id": "091ef217-8e6d-4e06-8cb9-bc5ffe5467b1",
      "name": "io.github.metricool/mcp-metricool",
      "description": "This is a Multi-Agent Collaboration Protocol (MCP) server for interacting with the Metricool API. It allows AI agents to access and analyze social media metrics and campaign data from your Metricool account.",
      "repository": {
        "url": "https://github.com/metricool/mcp-metricool",
        "source": "github",
        "id": "967888435"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:10:11Z",
        "is_latest": true
      }
    },
    {
      "id": "09a2ecf8-1774-490e-8542-2b25a6445a58",
      "name": "io.github.r-huijts/strava-mcp",
      "description": "A Model Context Protocol (MCP) server that connects to Strava API, providing tools to access Strava data through LLMs",
      "repository": {
        "url": "https://github.com/r-huijts/strava-mcp",
        "source": "github",
        "id": "961429605"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:14:17Z",
        "is_latest": true
      }
    },
    {
      "id": "09f19715-3a0c-4900-932b-1ff0035aff11",
      "name": "io.github.googleapis/genai-toolbox",
      "description": "MCP Toolbox for Databases is an open source MCP server for databases.",
      "repository": {
        "url": "https://github.com/googleapis/genai-toolbox",
        "source": "github",
        "id": "812044182"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:00:18Z",
        "is_latest": true
      }
    },
    {
      "id": "0b245c5f-ba2b-4e8d-b9db-26681b0fa2e3",
      "name": "io.github.wilsonchenghy/shadertoy-mcp",
      "description": "",
      "repository": {
        "url": "https://github.com/wilsonchenghy/ShaderToy-MCP",
        "source": "github",
        "id": "958998300"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:14:23Z",
        "is_latest": true
      }
    },
    {
      "id": "0bc33e11-876e-4b0f-9c72-75c126d89978",
      "name": "io.github.klavis-ai/klavis",
      "description": "Klavis AI (YC X25):  Open Source MCP integration for AI applications",
      "repository": {
        "url": "https://github.com/Klavis-AI/klavis",
        "source": "github",
        "id": "965974441"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T18:59:59Z",
        "is_latest": true
      }
    },
    {
      "id": "0bee6074-d16a-4482-a315-5b8f0f1abcf1",
      "name": "io.github.fireproof-storage/mcp-database-server",
      "description": "Store and load JSON documents from LLM tool use",
      "repository": {
        "url": "https://github.com/fireproof-storage/mcp-database-server",
        "source": "github",
        "id": "904432283"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T18:58:57Z",
        "is_latest": true
      }
    },
    {
      "id": "0c43f128-7589-4ce6-9382-5399ba24bebd",
      "name": "io.github.xxxbrian/mcp-rquest",
      "description": "A MCP server providing realistic browser-like HTTP request capabilities with accurate TLS/JA3/JA4 fingerprints for bypassing anti-bot measures. It also supports converting PDF and HTML documents to Markdown for easier processing by LLMs.",
      "repository": {
        "url": "https://github.com/xxxbrian/mcp-rquest",
        "source": "github",
        "id": "950863558"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:30Z",
        "is_latest": true
      }
    },
    {
      "id": "0c8e4aae-53ed-4acf-87d9-19d44ac4afd1",
      "name": "io.github.geropl/linear-mcp-go",
      "description": "linear MCP server based on mcp-go",
      "repository": {
        "url": "https://github.com/geropl/linear-mcp-go",
        "source": "github",
        "id": "940084523"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:09:19Z",
        "is_latest": true
      }
    },
    {
      "id": "0c9a70a7-7523-42b7-a951-b4c4b8077710",
      "name": "io.github.amornpan/py-mcp-mssql",
      "description": "py-mcp-mssql",
      "repository": {
        "url": "https://github.com/amornpan/py-mcp-mssql",
        "source": "github",
        "id": "922607489"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:10:17Z",
        "is_latest": true
      }
    },
    {
      "id": "0cd13ce0-2f67-414a-afb1-4e11dd3e4cba",
      "name": "io.github.chaindead/telegram-mcp",
      "description": "Telegram MCP for managing dialogs, messages, drafts, read statuses, and more.",
      "repository": {
        "url": "https://github.com/chaindead/telegram-mcp",
        "source": "github",
        "id": "958652024"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:14:34Z",
        "is_latest": true
      }
    },
    {
      "id": "0cdfed38-6495-42a3-a837-3788f35aadd3",
      "name": "io.github.bazinga012/mcp_code_executor",
      "description": "The MCP Code Executor is an MCP server that allows LLMs to execute Python code within a specified Conda environment.",
      "repository": {
        "url": "https://github.com/bazinga012/mcp_code_executor",
        "source": "github",
        "id": "928420039"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:04:37Z",
        "is_latest": true
      }
    },
    {
      "id": "0d2cbcc1-4b34-4b2b-af66-595d8fb5e78a",
      "name": "io.github.lharries/whatsapp-mcp",
      "description": "WhatsApp MCP server",
      "repository": {
        "url": "https://github.com/lharries/whatsapp-mcp",
        "source": "github",
        "id": "957053334"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:15:45Z",
        "is_latest": true
      }
    },
    {
      "id": "0d57edf7-3fbb-42b4-aa9e-b255e7d6f8fa",
      "name": "io.github.mektigboy/server-hyperliquid",
      "description": "MCP Hyperliquid (https://app.hyperliquid.xyz) server",
      "repository": {
        "url": "https://github.com/mektigboy/server-hyperliquid",
        "source": "github",
        "id": "943734921"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:08:12Z",
        "is_latest": true
      }
    },
    {
      "id": "0d7bc864-fdf3-4afd-8b44-48468b12d550",
      "name": "io.github.omar-v2/mcp-ical",
      "description": "A Model Context Protocol Server that allows you to interact with your MacOS Calendar through natural language.",
      "repository": {
        "url": "https://github.com/Omar-V2/mcp-ical",
        "source": "github",
        "id": "930007673"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:03:05Z",
        "is_latest": true
      }
    },
    {
      "id": "0d8b287c-6023-4809-a5ba-963c5612efa2",
      "name": "io.github.open-strategy-partners/osp_marketing_tools",
      "description": "A Model Context Protocol (MCP) server that empowers LLMs to use some of Open Srategy Partners' core writing and product marketing techniques.",
      "repository": {
        "url": "https://github.com/open-strategy-partners/osp_marketing_tools",
        "source": "github",
        "id": "917730483"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:12:14Z",
        "is_latest": true
      }
    },
    {
      "id": "0e45cb5a-5b45-47f3-8b5e-12bdf88d176a",
      "name": "io.github.smn2gnt/mcp-salesforce",
      "description": "MCP Salesforce connector",
      "repository": {
        "url": "https://github.com/smn2gnt/MCP-Salesforce",
        "source": "github",
        "id": "904538810"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:41Z",
        "is_latest": true
      }
    }
  ],
  "metadata": {
    "next_cursor": "0e45cb5a-5b45-47f3-8b5e-12bdf88d176a",
    "count": 30
  }
}
servers request successful
-------------------------------------
Testing ping endpoint: http://localhost:8080/v0/ping
Status Code: 200
Response:
{
  "status": "ok",
  "version": "dev"
}
Ping successful
-------------------------------------
All tests passed successfully!
```

## Breaking Changes
<!-- Will users need to update their code or configurations? -->
No

## Types of changes
<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [x] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->
- [x] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [x] My code follows the repository's style guidelines
- [x] New and existing tests pass locally
- [x] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

## Additional context
<!-- Add any other context, implementation notes, or design decisions
-->
Close #127
This commit is contained in:
Mingyong Chen 2025-06-07 06:19:28 +08:00 • committed by GitHub
commit 686fbe1e78
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 129 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

40
cmd/registry/main.go
View file

@ -34,16 +34,20 @@ func main() {
log.Printf("Starting MCP Registry Application v%s (commit: %s)", Version, GitCommit)
var (
registryService service.RegistryService
db database.Database
err error
)
// Initialize configuration
cfg := config.NewConfig()
// Initialize services based on environment
var registryService service.RegistryService
switch cfg.DatabaseType {
case config.DatabaseTypeMemory:
memoryDB := database.NewMemoryDB(map[string]*model.Server{})
registryService = service.NewRegistryServiceWithDB(memoryDB)
db = database.NewMemoryDB(map[string]*model.Server{})
registryService = service.NewRegistryServiceWithDB(db)
case config.DatabaseTypeMongoDB:
// Use MongoDB for real registry service in production/other environments
// Create a context with timeout for MongoDB connection
@ -51,39 +55,43 @@ func main() {
defer cancel()
// Connect to MongoDB
mongoDB, err := database.NewMongoDB(ctx, cfg.DatabaseURL, cfg.DatabaseName, cfg.CollectionName)
db, err = database.NewMongoDB(ctx, cfg.DatabaseURL, cfg.DatabaseName, cfg.CollectionName)
if err != nil {
log.Printf("Failed to connect to MongoDB: %v", err)
return
}
// Create registry service with MongoDB
registryService = service.NewRegistryServiceWithDB(mongoDB)
registryService = service.NewRegistryServiceWithDB(db)
log.Printf("MongoDB database name: %s", cfg.DatabaseName)
log.Printf("MongoDB collection name: %s", cfg.CollectionName)
// Store the MongoDB instance for later cleanup
defer func() {
if err := mongoDB.Close(); err != nil {
if err := db.Close(); err != nil {
log.Printf("Error closing MongoDB connection: %v", err)
} else {
log.Println("MongoDB connection closed successfully")
}
}()
if cfg.SeedImport {
log.Println("Importing data...")
if err := database.ImportSeedFile(mongoDB, cfg.SeedFilePath); err != nil {
log.Printf("Failed to import seed file: %v", err)
} else {
log.Println("Data import completed successfully")
}
}
default:
log.Printf("Invalid database type: %s; supported types: %s, %s", cfg.DatabaseType, config.DatabaseTypeMemory, config.DatabaseTypeMongoDB)
return
}
// Import seed data if requested (works for both memory and MongoDB)
if cfg.SeedImport {
log.Println("Importing data...")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
if err := db.ImportSeed(ctx, cfg.SeedFilePath); err != nil {
log.Printf("Failed to import seed file: %v", err)
} else {
log.Println("Data import completed successfully")
}
}
// Initialize authentication services
authService := auth.NewAuthService(cfg)

2
internal/database/database.go
View file

@ -24,6 +24,8 @@ type Database interface {
GetByID(ctx context.Context, id string) (*model.ServerDetail, error)
// Publish adds a new ServerDetail to the database
Publish(ctx context.Context, serverDetail *model.ServerDetail) error
// ImportSeed imports initial data from a seed file
ImportSeed(ctx context.Context, seedFilePath string) error
// Close closes the database connection
Close() error
}

79
internal/database/import.go
View file

@ -1,50 +1,28 @@
package database
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"path/filepath"
"time"
"github.com/modelcontextprotocol/registry/internal/model"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// ImportSeedFile populates the MongoDB database with initial data from a seed file.
func ImportSeedFile(mongo *MongoDB, seedFilePath string) error {
// ReadSeedFile reads and parses the seed.json file - exported for use by all database implementations
func ReadSeedFile(path string) ([]model.ServerDetail, error) {
log.Printf("Reading seed file from %s", path)
// Set default seed file path if not provided
if seedFilePath == "" {
if path == "" {
// Try to find the seed.json in the data directory
seedFilePath = filepath.Join("data", "seed.json")
if _, err := os.Stat(seedFilePath); os.IsNotExist(err) {
return fmt.Errorf("seed file not found at %s", seedFilePath)
path = filepath.Join("data", "seed.json")
if _, err := os.Stat(path); os.IsNotExist(err) {
return nil, fmt.Errorf("seed file not found at %s", path)
}
}
// Create a context with timeout for the database operations
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
// Read the seed file
seedData, err := readSeedFile(seedFilePath)
if err != nil {
return fmt.Errorf("failed to read seed file: %w", err)
}
collection := mongo.collection
importData(ctx, collection, seedData)
return nil
}
// readSeedFile reads and parses the seed.json file
func readSeedFile(path string) ([]model.ServerDetail, error) {
log.Printf("Reading seed file from %s", path)
// Read the file content
fileContent, err := os.ReadFile(path)
if err != nil {
@ -64,44 +42,3 @@ func readSeedFile(path string) ([]model.ServerDetail, error) {
log.Printf("Found %d server entries in seed file", len(servers))
return servers, nil
}
// importData imports the seed data into MongoDB
func importData(ctx context.Context, collection *mongo.Collection, servers []model.ServerDetail) {
log.Printf("Importing %d servers into collection %s", len(servers), collection.Name())
for i, server := range servers {
if server.ID == "" || server.Name == "" {
log.Printf("Skipping server %d: ID or Name is empty", i+1)
continue
}
// Create filter based on server ID
filter := bson.M{"id": server.ID}
if server.VersionDetail.Version == "" {
server.VersionDetail.Version = "0.0.1-seed"
server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
server.VersionDetail.IsLatest = true
}
// Create update document
update := bson.M{"$set": server}
// Use upsert to create if not exists or update if exists
opts := options.Update().SetUpsert(true)
result, err := collection.UpdateOne(ctx, filter, update, opts)
if err != nil {
log.Printf("Error importing server %s: %v", server.ID, err)
continue
}
switch {
case result.UpsertedCount > 0:
log.Printf("[%d/%d] Created server: %s", i+1, len(servers), server.Name)
case result.ModifiedCount > 0:
log.Printf("[%d/%d] Updated server: %s", i+1, len(servers), server.Name)
default:
log.Printf("[%d/%d] Server already up to date: %s", i+1, len(servers), server.Name)
}
}
log.Println("Import completed successfully")
}

43
internal/database/memory.go
View file

@ -2,6 +2,8 @@ package database
import (
"context"
"fmt"
"log"
"sort"
"strconv"
"strings"
@ -249,6 +251,47 @@ func (db *MemoryDB) Publish(ctx context.Context, serverDetail *model.ServerDetai
return nil
}
// ImportSeed imports initial data from a seed file into memory database
func (db *MemoryDB) ImportSeed(ctx context.Context, seedFilePath string) error {
if ctx.Err() != nil {
return ctx.Err()
}
// Read the seed file
seedData, err := ReadSeedFile(seedFilePath)
if err != nil {
return fmt.Errorf("failed to read seed file: %w", err)
}
log.Printf("Importing %d servers into memory database", len(seedData))
db.mu.Lock()
defer db.mu.Unlock()
for i, server := range seedData {
if server.ID == "" || server.Name == "" {
log.Printf("Skipping server %d: ID or Name is empty", i+1)
continue
}
// Set default version information if missing
if server.VersionDetail.Version == "" {
server.VersionDetail.Version = "0.0.1-seed"
server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
server.VersionDetail.IsLatest = true
}
// Store a copy of the server detail
serverDetailCopy := server
db.entries[server.ID] = &serverDetailCopy
log.Printf("[%d/%d] Imported server: %s", i+1, len(seedData), server.Name)
}
log.Println("Memory database import completed successfully")
return nil
}
// Close closes the database connection
// For an in-memory database, this is a no-op
func (db *MemoryDB) Close() error {

52
internal/database/mongo.go
View file

@ -232,6 +232,58 @@ func (db *MongoDB) Publish(ctx context.Context, serverDetail *model.ServerDetail
return nil
}
// ImportSeed imports initial data from a seed file into MongoDB
func (db *MongoDB) ImportSeed(ctx context.Context, seedFilePath string) error {
// Read the seed file
servers, err := ReadSeedFile(seedFilePath)
if err != nil {
return fmt.Errorf("failed to read seed file: %w", err)
}
collection := db.collection
log.Printf("Importing %d servers into collection %s", len(servers), collection.Name())
for i, server := range servers {
if server.ID == "" || server.Name == "" {
log.Printf("Skipping server %d: ID or Name is empty", i+1)
continue
}
if server.VersionDetail.Version == "" {
server.VersionDetail.Version = "0.0.1-seed"
server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
server.VersionDetail.IsLatest = true
}
// Create filter based on server ID
filter := bson.M{"id": server.ID}
// Create update document
update := bson.M{"$set": server}
// Use upsert to create if not exists or update if exists
opts := options.Update().SetUpsert(true)
result, err := collection.UpdateOne(ctx, filter, update, opts)
if err != nil {
log.Printf("Error importing server %s: %v", server.ID, err)
continue
}
switch {
case result.UpsertedCount > 0:
log.Printf("[%d/%d] Created server: %s", i+1, len(servers), server.Name)
case result.ModifiedCount > 0:
log.Printf("[%d/%d] Updated server: %s", i+1, len(servers), server.Name)
default:
log.Printf("[%d/%d] Server already up to date: %s", i+1, len(servers), server.Name)
}
}
log.Println("MongoDB database import completed successfully")
return nil
}
// Close closes the database connection
func (db *MongoDB) Close() error {
return db.client.Disconnect(context.Background())