github.com/goharbor/harbor

The Harbor Go client is auto-generated from OpenAPI specs, which shows in daily use. The API surface is verbose with deeply nested structures that make simple operations cumbersome. You'll spend time navigating through pointer-heavy request/response objects, and the lack of builder patterns means lots of manual struct initialization. The incompatible versioning tag is concerning for production stability.

Connection pooling isn't explicitly configurable through the client interface - you're working directly with HTTP clients under the hood, which means you need to bring your own transport configuration. Timeout handling is basic; default timeouts aren't well-documented and you'll need to wrap calls with context deadlines yourself. Retry logic is entirely absent, so transient network failures require custom middleware.

Error handling is inconsistent. Some operations return structured errors, others return plain strings that require parsing. There's minimal observability support - no built-in hooks for metrics or tracing, making it difficult to monitor client behavior in production. The documentation focuses on API coverage rather than practical usage patterns, leaving you to piece together working examples from the test suite.

Using Harbor's Go package as a client library is challenging due to sparse documentation and unclear API patterns. The auto-generated client code from Swagger definitions lacks idiomatic Go conventions, making it feel awkward compared to hand-crafted SDKs. You'll spend considerable time reading source code and experimenting to figure out basic operations like pushing artifacts or managing projects.

Error messages are often generic HTTP errors that don't provide enough context about what went wrong. Debugging requires diving into the actual HTTP responses and correlating them with Harbor's REST API docs. The GitHub issues are more focused on Harbor the product rather than the Go client library specifically, so finding answers to SDK-specific questions is difficult.

Common tasks like authentication setup, pagination handling, and proper resource cleanup aren't well-documented. Expect to reverse-engineer examples from Harbor's own internal code or integration tests. The package works once configured correctly, but getting there requires significant trial and error.

The Harbor Go client library provides access to Harbor registry APIs but lacks the production-ready polish you'd expect. The API surface is auto-generated from Swagger specs, which means you get comprehensive coverage but inconsistent patterns. Error handling is particularly challenging - many methods return generic errors without structured types, making retry logic and failure classification difficult. You'll often find yourself parsing error strings to understand what went wrong.

Connection pooling isn't explicitly documented, and the default HTTP client configuration requires manual tuning for production loads. Timeout handling is present but defaults aren't production-ready - you must set reasonable timeouts yourself or risk hanging connections. The library doesn't provide built-in retry mechanisms, circuit breakers, or backoff strategies, so you'll need to layer those yourself.

Observability is limited. There are no hooks for request/response logging or metrics collection without wrapping the entire HTTP transport. The '+incompatible' version suffix indicates Go module compatibility issues that can cause dependency management headaches. Configuration is verbose, requiring manual construction of client objects with many required fields.