{"id":32143052,"url":"https://github.com/coenttb/swift-resource-pool","last_synced_at":"2026-02-21T15:01:45.285Z","repository":{"id":318493242,"uuid":"1071524013","full_name":"coenttb/swift-resource-pool","owner":"coenttb","description":"A Swift package for actor-based resource pooling.","archived":false,"fork":false,"pushed_at":"2025-12-21T21:24:27.000Z","size":79,"stargazers_count":3,"open_issues_count":0,"forks_count":1,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-12-23T09:29:17.997Z","etag":null,"topics":["actor","concurrency","pooling","resource-management","resource-pool","swift","swift-concurrency","utilities"],"latest_commit_sha":null,"homepage":"https://coenttb.com","language":"Swift","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/coenttb.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null},"funding":{"github":["coenttb"],"patreon":null,"open_collective":null,"ko_fi":null,"tidelift":null,"community_bridge":null,"liberapay":null,"issuehunt":null,"lfx_crowdfunding":null,"polar":null,"buy_me_a_coffee":null,"thanks_dev":null,"custom":null}},"created_at":"2025-10-07T13:16:10.000Z","updated_at":"2025-12-21T21:21:01.000Z","dependencies_parsed_at":"2025-10-07T15:22:44.195Z","dependency_job_id":"85c4562e-6c29-493d-ac79-ca8ea7bb868c","html_url":"https://github.com/coenttb/swift-resource-pool","commit_stats":null,"previous_names":["coenttb/swift-resource-pool"],"tags_count":6,"template":false,"template_full_name":null,"purl":"pkg:github/coenttb/swift-resource-pool","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/coenttb%2Fswift-resource-pool","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/coenttb%2Fswift-resource-pool/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/coenttb%2Fswift-resource-pool/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/coenttb%2Fswift-resource-pool/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/coenttb","download_url":"https://codeload.github.com/coenttb/swift-resource-pool/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/coenttb%2Fswift-resource-pool/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29684068,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-21T14:31:22.911Z","status":"ssl_error","status_checked_at":"2026-02-21T14:31:22.570Z","response_time":107,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["actor","concurrency","pooling","resource-management","resource-pool","swift","swift-concurrency","utilities"],"created_at":"2025-10-21T07:48:22.970Z","updated_at":"2026-02-21T15:01:45.279Z","avatar_url":"https://github.com/coenttb.png","language":"Swift","funding_links":["https://github.com/sponsors/coenttb"],"categories":[],"sub_categories":[],"readme":"# swift-resource-pool\n\n[![CI](https://github.com/coenttb/swift-resource-pool/workflows/CI/badge.svg)](https://github.com/coenttb/swift-resource-pool/actions/workflows/ci.yml)\n![Development Status](https://img.shields.io/badge/status-active--development-blue.svg)\n\nActor-based resource pool for Swift with thread-safe pooling, FIFO fairness, and automatic resource management.\n\n## Table of Contents\n\n- [Overview](#overview)\n- [Why swift-resource-pool?](#why-swift-resource-pool)\n- [Quick Start](#quick-start)\n- [Core Concepts](#core-concepts)\n- [Real-World Examples](#real-world-examples)\n- [Performance Characteristics](#performance-characteristics)\n- [API Reference](#api-reference)\n- [Advanced Usage](#advanced-usage)\n- [Error Handling](#error-handling)\n- [Requirements](#requirements)\n- [Related Packages](#related-packages)\n- [Dependencies](#dependencies)\n- [Contributing](#contributing)\n- [License](#license)\n\n## Overview\n\n**swift-resource-pool** provides a generic, high-performance resource pooling solution built with Swift's actor model. It eliminates the thundering herd problem through direct resource handoff, ensures fairness with FIFO ordering, and offers comprehensive metrics for production monitoring.\n\n```swift\nimport ResourcePool\n\n// Define your poolable resource\nactor DatabaseConnection: PoolableResource {\n    struct Config: Sendable {\n        let host: String\n        let port: Int\n    }\n    \n    static func create(config: Config) async throws -\u003e DatabaseConnection {\n        // Create and return connection\n        return DatabaseConnection()\n    }\n    \n    func validate() async -\u003e Bool {\n        // Check if connection is still alive\n        return true\n    }\n    \n    func reset() async throws {\n        // Reset connection state for reuse\n    }\n}\n\n// Create a pool with 10 connections\nlet pool = try await ResourcePool\u003cDatabaseConnection\u003e(\n    capacity: 10,\n    resourceConfig: .init(host: \"localhost\", port: 5432),\n    warmup: true\n)\n\n// Use resources safely with automatic cleanup\nlet results = try await pool.withResource { connection in\n    try await connection.query(\"SELECT * FROM users\")\n}\n```\n\n## Key Features\n\n### Efficient Resource Handoff\n- Direct handoff to exactly one waiting task without broadcast storms\n- O(1) wakeup efficiency with 90-95% direct handoff rate under sustained load\n- Linear scalability up to 200+ concurrent waiters without performance degradation\n\n### Fairness and Reliability\n- FIFO queue ensures waiters are served in arrival order\n- Guaranteed cleanup even during task cancellation\n- Thread-safe actor-isolated implementation without locks\n- Comprehensive production metrics for utilization tracking\n\n### Performance Characteristics\n- Lazy resource creation on-demand up to capacity limits\n- Optional warmup for pre-created resources\n- Automatic validation and reset between resource uses\n- Per-waiter efficient timeout deadlines\n- 45 test scenarios with proven stability\n\n## Quick Start\n\n### Installation\n\nAdd swift-resource-pool to your Swift package:\n\n```swift\ndependencies: [\n    .package(url: \"https://github.com/coenttb/swift-resource-pool\", from: \"0.1.0\")\n]\n```\n\nFor Xcode projects, add the package URL: `https://github.com/coenttb/swift-resource-pool`\n\n### Your First Resource Pool\n\n```swift\nimport ResourcePool\n\n// Simple mock resource for demonstration\nactor SimpleResource: PoolableResource {\n    struct Config: Sendable {\n        let name: String\n    }\n    \n    let id = UUID()\n    private var useCount = 0\n    \n    static func create(config: Config) async throws -\u003e SimpleResource {\n        return SimpleResource()\n    }\n    \n    func validate() async -\u003e Bool {\n        return true\n    }\n    \n    func reset() async throws {\n        // Reset any state\n    }\n    \n    func use() {\n        useCount += 1\n    }\n}\n\n// Create pool\nlet pool = try await ResourcePool\u003cSimpleResource\u003e(\n    capacity: 5,\n    resourceConfig: .init(name: \"my-resource\"),\n    warmup: true\n)\n\n// Use resource with automatic cleanup\nlet result = try await pool.withResource(timeout: .seconds(10)) { resource in\n    await resource.use()\n    return \"Success\"\n}\n```\n\n## Core Concepts\n\n### 🏗️ Poolable Resources\n\nResources must conform to `PoolableResource` protocol:\n\n```swift\npublic protocol PoolableResource: Sendable, AnyObject {\n    associatedtype Config: Sendable\n    \n    /// Create a new resource instance\n    static func create(config: Config) async throws -\u003e Self\n    \n    /// Check if the resource is still valid and can be reused\n    func validate() async -\u003e Bool\n    \n    /// Reset the resource to a clean state for reuse\n    func reset() async throws\n}\n```\n\n**Important**: Resources MUST be reference types (classes or actors) because the pool tracks them using `ObjectIdentifier`.\n\n### 🔄 Resource Lifecycle\n\n```swift\n// Pool manages complete lifecycle:\n// 1. Create (lazy or warmup)\nlet resource = try await factory.create()\n\n// 2. Acquire (immediate or wait)\nlet resource = try await pool.withResource { resource in\n    // 3. Use safely\n    try await resource.performWork()\n    // 4. Validate after use\n    let isValid = await resource.validate()\n    // 5. Reset for reuse\n    try await resource.reset()\n    // 6. Return to pool or discard\n}\n```\n\n### 📊 Pool Statistics\n\nMonitor pool behavior in real-time:\n\n```swift\nlet stats = await pool.statistics\nprint(\"Available: \\(stats.available)\")\nprint(\"Leased: \\(stats.leased)\")\nprint(\"Utilization: \\(stats.utilization * 100)%\")\nprint(\"Queue depth: \\(stats.waitQueueDepth)\")\nprint(\"Backpressure: \\(stats.hasBackpressure)\")\n\nlet metrics = await pool.metrics\nprint(\"Total acquisitions: \\(metrics.totalAcquisitions)\")\nprint(\"Timeouts: \\(metrics.timeouts)\")\nprint(\"Handoff rate: \\(metrics.handoffRate * 100)%\")\nprint(\"Avg wait time: \\(metrics.averageWaitTime?.formatted() ?? \"N/A\")\")\n```\n\n## Real-World Examples\n\n### 🗄️ Database Connection Pool\n\n```swift\nimport PostgresNIO\n\nactor PostgresConnection: PoolableResource {\n    struct Config: Sendable {\n        let host: String\n        let port: Int\n        let database: String\n        let user: String\n        let password: String\n    }\n    \n    private var connection: PostgresConnection?\n    \n    static func create(config: Config) async throws -\u003e PostgresConnection {\n        let conn = try await PostgresConnection.connect(\n            host: config.host,\n            port: config.port,\n            username: config.user,\n            password: config.password,\n            database: config.database\n        )\n        return PostgresConnection(connection: conn)\n    }\n    \n    func validate() async -\u003e Bool {\n        guard let connection else { return false }\n        return !connection.isClosed\n    }\n    \n    func reset() async throws {\n        // Rollback any uncommitted transactions\n        try await connection?.query(\"ROLLBACK\")\n    }\n    \n    func query\u003cT\u003e(_ sql: String) async throws -\u003e [T] {\n        // Execute query\n    }\n}\n\n// Create pool\nlet dbPool = try await ResourcePool\u003cPostgresConnection\u003e(\n    capacity: 20,\n    resourceConfig: .init(\n        host: \"localhost\",\n        port: 5432,\n        database: \"myapp\",\n        user: \"postgres\",\n        password: \"password\"\n    )\n)\n\n// Use in your application\nstruct UserRepository {\n    let pool: ResourcePool\u003cPostgresConnection\u003e\n    \n    func fetchUser(id: UUID) async throws -\u003e User? {\n        try await pool.withResource(timeout: .seconds(5)) { conn in\n            try await conn.query(\"SELECT * FROM users WHERE id = \\(id)\")\n        }\n    }\n}\n```\n\n### 🌐 HTTP Client Pool\n\n```swift\nimport Foundation\n\nactor HTTPClient: PoolableResource {\n    struct Config: Sendable {\n        let timeout: TimeInterval\n    }\n    \n    private let session: URLSession\n    \n    static func create(config: Config) async throws -\u003e HTTPClient {\n        let configuration = URLSessionConfiguration.default\n        configuration.timeoutIntervalForRequest = config.timeout\n        return HTTPClient(session: URLSession(configuration: configuration))\n    }\n    \n    func validate() async -\u003e Bool {\n        return true\n    }\n    \n    func reset() async throws {\n        session.invalidateAndCancel()\n    }\n    \n    func fetch(url: URL) async throws -\u003e Data {\n        let (data, _) = try await session.data(from: url)\n        return data\n    }\n}\n\n// Create pool for API clients\nlet httpPool = try await ResourcePool\u003cHTTPClient\u003e(\n    capacity: 10,\n    resourceConfig: .init(timeout: 30)\n)\n\n// Make requests with automatic pooling\nlet data = try await httpPool.withResource { client in\n    try await client.fetch(url: apiURL)\n}\n```\n\n### 📄 WKWebView Pool (PDF Generation)\n\n```swift\n#if canImport(WebKit)\nimport WebKit\n\nactor WebViewResource: PoolableResource {\n    struct Config: Sendable {}\n    \n    private var webView: WKWebView!\n    \n    static func create(config: Config) async throws -\u003e WebViewResource {\n        return await WebViewResource()\n    }\n    \n    @MainActor\n    init() {\n        self.webView = WKWebView()\n    }\n    \n    func validate() async -\u003e Bool {\n        return webView != nil\n    }\n    \n    func reset() async throws {\n        await MainActor.run {\n            webView.stopLoading()\n            webView.loadHTMLString(\"\", baseURL: nil)\n        }\n    }\n    \n    func renderPDF(html: String) async throws -\u003e Data {\n        // Render HTML to PDF\n    }\n}\n\n// Pool for PDF generation\nlet pdfPool = try await ResourcePool\u003cWebViewResource\u003e(\n    capacity: 3,\n    resourceConfig: .init(),\n    warmup: true\n)\n\n// Generate PDFs with pooled WebViews\nlet pdfData = try await pdfPool.withResource { webView in\n    try await webView.renderPDF(html: invoiceHTML)\n}\n#endif\n```\n\n## Performance Characteristics\n\nBased on comprehensive test suite with 45 scenarios:\n\n### Throughput Benchmarks\n\n| Pool Capacity | Concurrent Tasks | Total Ops | Throughput | Avg Wait |\n|--------------|------------------|-----------|------------|----------|\n| 2            | 10               | 200       | 277 ops/s  | 28.1ms   |\n| 5            | 30               | 300       | 646 ops/s  | 36.8ms   |\n| 10           | 50               | 500       | 1,267 ops/s| 30.0ms   |\n| 20           | 100              | 500       | 2,395 ops/s| 30.1ms   |\n\n### Scalability Results\n\n| Concurrent Waiters | Duration | Ops/Sec | Max Queue | Handoff Rate |\n|--------------------|----------|---------|-----------|--------------|\n| 10                 | 1.06s    | 9.4     | 0         | 0.0%         |\n| 30                 | 1.07s    | 28.1    | 20        | 66.7%        |\n| 50                 | 1.09s    | 45.9    | 40        | 80.0%        |\n| 100                | 1.09s    | 92.1    | 90        | 90.0%        |\n| 200                | 1.09s    | 183.8   | 190       | 95.0%        |\n\n**Key Insights:**\n- ✅ Linear scalability up to 200 concurrent waiters\n- ✅ Zero timeouts even under extreme load (500 concurrent ops)\n- ✅ High handoff rate (90%+) indicates efficient queue management\n- ✅ Consistent throughput with minimal degradation\n\n### Latency Distribution (Under Contention)\n\nPool capacity: 5, Concurrent ops: 200\n\n| Percentile | Latency  |\n|------------|----------|\n| Min        | 15.9ms   |\n| P50        | 160.9ms  |\n| P90        | 165.7ms  |\n| P95        | 167.0ms  |\n| P99        | 167.9ms  |\n| Max        | 167.9ms  |\n| Avg        | 143.8ms  |\n\n**P99/Avg ratio: 1.2x** (excellent tail latency)\n\n## API Reference\n\n### Initialization\n\n```swift\ninit(\n    capacity: Int,\n    resourceConfig: Resource.Config,\n    warmup: Bool = true\n) async throws\n```\n\n**Parameters:**\n- `capacity`: Maximum resources to create (must be \u003e 0)\n- `resourceConfig`: Configuration for creating resources\n- `warmup`: If true, pre-create all resources; if false, create lazily\n\n### Core Methods\n\n```swift\n// Use a resource with automatic cleanup\nfunc withResource\u003cT\u003e(\n    timeout: Duration = .seconds(30),\n    _ operation: (Resource) async throws -\u003e T\n) async throws -\u003e T\n\n// Get current pool state\nvar statistics: Statistics { get async }\n\n// Get production metrics\nvar metrics: Metrics { get async }\n\n// Graceful shutdown\nfunc drain(timeout: Duration = .seconds(30)) async throws\n\n// Immediate shutdown\nfunc close() async\n```\n\n### Statistics\n\n```swift\nstruct Statistics: Sendable, Equatable {\n    let available: Int           // Resources ready for use\n    let leased: Int             // Resources currently in use\n    let capacity: Int           // Maximum pool capacity\n    let waitQueueDepth: Int     // Tasks waiting for resources\n    \n    var inUse: Int              // Alias for leased\n    var utilization: Double     // 0.0 to 1.0\n    var hasBackpressure: Bool   // Queue depth \u003e 0\n}\n```\n\n### Metrics\n\n```swift\nstruct Metrics: Sendable {\n    let currentStatistics: Statistics\n    let totalAcquisitions: Int\n    let timeouts: Int\n    let validationFailures: Int\n    let resetFailures: Int\n    let creationFailures: Int\n    let successfulReturns: Int\n    let waitersQueued: Int\n    let directHandoffs: Int\n    \n    var averageWaitTime: Duration?\n    var handoffRate: Double\n}\n```\n\n## Advanced Usage\n\n### Handling Failures\n\n```swift\n// Resource that can fail validation\nactor UnreliableResource: PoolableResource {\n    struct Config: Sendable {}\n    private var failureCount = 0\n    \n    func validate() async -\u003e Bool {\n        // Simulate intermittent failures\n        failureCount += 1\n        return failureCount % 5 != 0\n    }\n    \n    // Pool automatically discards invalid resources\n}\n```\n\n### Custom Timeouts\n\n```swift\n// Short timeout for quick operations\nlet fastResult = try await pool.withResource(timeout: .seconds(1)) { resource in\n    try await resource.quickOperation()\n}\n\n// Long timeout for expensive operations\nlet slowResult = try await pool.withResource(timeout: .seconds(60)) { resource in\n    try await resource.expensiveOperation()\n}\n```\n\n### Monitoring and Observability\n\n```swift\n// Periodic monitoring\nTask {\n    while !Task.isCancelled {\n        let stats = await pool.statistics\n        let metrics = await pool.metrics\n        \n        logger.info(\"Pool stats\", metadata: [\n            \"available\": .string(String(stats.available)),\n            \"leased\": .string(String(stats.leased)),\n            \"utilization\": .string(String(format: \"%.1f%%\", stats.utilization * 100)),\n            \"queue_depth\": .string(String(stats.waitQueueDepth)),\n            \"handoff_rate\": .string(String(format: \"%.1f%%\", metrics.handoffRate * 100))\n        ])\n        \n        try await Task.sleep(for: .seconds(30))\n    }\n}\n```\n\n### Graceful Shutdown\n\n```swift\n// Application shutdown\nfunc shutdown() async throws {\n    do {\n        // Wait for active operations to complete\n        try await pool.drain(timeout: .seconds(30))\n        logger.info(\"Pool drained successfully\")\n    } catch PoolError.drainTimeout {\n        logger.warning(\"Pool drain timed out, some resources still leased\")\n        // Force close if needed\n        await pool.close()\n    }\n}\n```\n\n### Sharing Pools Globally\n\n**IMPORTANT:** For system-limited resources (WebViews, database connections, file handles), creating multiple pool instances can lead to resource exhaustion. Use a global actor to ensure a single shared pool:\n\n```swift\n// ❌ BAD: Each operation creates its own pool\nfunc generatePDF(html: String) async throws -\u003e Data {\n    let pool = try await ResourcePool\u003cWKWebViewResource\u003e(capacity: 8, ...)\n    // Problem: 7 parallel calls = 56 WebViews trying to initialize!\n    return try await pool.withResource { ... }\n}\n\n// ✅ GOOD: Single shared pool via global actor\n@globalActor\npublic actor WebViewPoolActor {\n    public static let shared = WebViewPoolActor()\n\n    private var sharedPool: ResourcePool\u003cWKWebViewResource\u003e?\n\n    public func getPool() async throws -\u003e ResourcePool\u003cWKWebViewResource\u003e {\n        if let existing = sharedPool {\n            return existing\n        }\n\n        let pool = try await ResourcePool\u003cWKWebViewResource\u003e(\n            capacity: 8,\n            resourceConfig: .default,\n            warmup: true\n        )\n        sharedPool = pool\n        return pool\n    }\n}\n\n// Usage: All callers share the same pool\nfunc generatePDF(html: String) async throws -\u003e Data {\n    let pool = try await WebViewPoolActor.shared.getPool()\n    return try await pool.withResource { webView in\n        try await webView.renderPDF(html: html)\n    }\n}\n```\n\n**Why this matters:**\n- 7 parallel operations × 8 WebViews each = **56 WebViews** (exhausts system)\n- 7 parallel operations sharing 1 pool of 8 = **8 WebViews** (graceful queueing)\n- **56x improvement** in test performance (76s → 1.4s)\n- Proper FIFO queueing ensures fairness\n- One warmup cost amortized across all users\n\n**When NOT to share:**\n- Different resource configurations needed\n- Isolated testing scenarios\n- Short-lived, bounded workloads\n- Resources with incompatible lifecycles\n\n### Multiple Pools\n\nEach `ResourcePool` is independent. When running multiple pools of **different types**, consider your total system resource budget:\n\n```swift\n// Each pool maxes out independently\nlet dbPool = ResourcePool\u003cDatabaseConnection\u003e(capacity: 10)    // ~100MB\nlet httpPool = ResourcePool\u003cHTTPClient\u003e(capacity: 20)          // ~100MB\nlet webViewPool = ResourcePool\u003cWKWebView\u003e(capacity: 3)         // ~600MB\n// Total: ~800MB\n```\n\n## Error Handling\n\n```swift\npublic enum PoolError: Error, Sendable, Equatable {\n    case timeout                    // Acquisition timeout expired\n    case closed                     // Pool is closed\n    case creationFailed(String)     // Resource creation failed\n    case resetFailed(String)        // Resource reset failed\n    case drainTimeout               // Drain timeout with leased resources\n}\n```\n\n## Requirements\n\n- Swift 5.9+ (Swift 6.0 language mode for strict concurrency)\n- Platforms:\n  - macOS 13+\n  - iOS 16+\n  - tvOS 16+\n  - watchOS 9+\n\n## Related Packages\n\n### Used By\n\n- [swift-html-to-pdf](https://github.com/coenttb/swift-html-to-pdf): The Swift package for printing HTML to PDF.\n\n## Dependencies\n\nThis package has **zero external dependencies** - it only uses Foundation and Swift standard library.\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.\n\n## Support\n\n- **[Issue Tracker](https://github.com/coenttb/swift-resource-pool/issues)** - Report bugs or request features\n- **[Discussions](https://github.com/coenttb/swift-resource-pool/discussions)** - Ask questions and share ideas\n- **[Newsletter](http://coenttb.com/en/newsletter/subscribe)** - Stay updated\n- **[X (Twitter)](http://x.com/coenttb)** - Follow for updates\n- **[LinkedIn](https://www.linkedin.com/in/tenthijeboonkkamp)** - Connect professionally\n\n## License\n\nThis project is licensed under the Apache License 2.0. See [LICENSE](LICENSE) for details.\n\n---\n\n\u003cp align=\"center\"\u003e\n  Made by \u003ca href=\"https://coenttb.com\"\u003ecoenttb\u003c/a\u003e\n\u003c/p\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcoenttb%2Fswift-resource-pool","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcoenttb%2Fswift-resource-pool","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcoenttb%2Fswift-resource-pool/lists"}