bwilliams
67215a6aaa
CODE_CONVENTIONS.md sets out the conventions for Go code in this repository: naming, layout, comments, errors, logging, configuration and tests. .golangci.json enables the linters that check the parts that can be checked (each limited to the rules the conventions use); the rest is applied by hand. Applied across the codebase: - Naming: full-word names in application code, initialisms in one case (BuyerID, PrintJSON, PrintYAML, ocdsGetBuyerID), no names shadowing built-ins (min/max are minGap/maxGap), mustRaw renamed rawJSON as it returns nil rather than panicking, and config.ConfigLevelToLogLevel renamed LevelToLogLevel. - Layout: lines kept to 80 characters where possible, assignments taken out of if and for statements that don't fit, wrapped arguments all on one line or one per line, steps separated by blank lines, no else after a return, function and struct literals wrapped. - Comments: doc comments on every exported name (including each section's Map, Flatten, TypeOf, ValueOf and SetValue), section banners, British spelling. - Errors: a created error starts with its package name, a wrapping error adds only what was being done, sentinels in one commented var block, errors.Is and errors.As in place of == and type assertions, and no err := shadowing of a named result. That fixes the mock server losing its access log's close error. - Logging: the fetcher passes its workers an untagged logger, so findatender's lines are tagged with their own component rather than with fetcher's as well; cmd/mock-fts logs "stopped" with slog. - Configuration: util.WithTimeout (moved from the websocket package) applies a timeout of 0 or less as no limit, used for the websocket write and ping, TCP close and tcpserver shutdown timeouts; every setting documents what 0 or empty means, including the rate limit rule's keys in internal/config/README.md. - Tests: related tests merged into table-driven ones with named cases. Separately from CODE_CONVENTIONS.md, internal/store/README.md gains a soft SQL style convention for the queries in internal/store/queries.go, and the queries are reformatted to follow it.
121 lines
3.2 KiB
Go
121 lines
3.2 KiB
Go
package findatender
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"time"
|
|
|
|
resty "resty.dev/v3"
|
|
|
|
"git.avsdev.uk/Go/job-search/internal/config"
|
|
"git.avsdev.uk/Go/job-search/internal/types"
|
|
)
|
|
|
|
// FindATender is a client for the Find a Tender OCDS API (or the mock
|
|
// server). Create it with New and call Shutdown when finished with it.
|
|
type FindATender struct {
|
|
httpClient *resty.Client
|
|
config *config.JobSearchConfig
|
|
apiRoot string
|
|
ctx context.Context
|
|
log *slog.Logger
|
|
}
|
|
|
|
// Option configures a FindATender client.
|
|
type Option func(*FindATender)
|
|
|
|
// WithLogger makes the client log to logger instead of slog.Default().
|
|
func WithLogger(logger *slog.Logger) Option {
|
|
return func(ft *FindATender) {
|
|
ft.log = logger
|
|
}
|
|
}
|
|
|
|
// New returns a client for the OCDS API at apiRoot. Requests time out after
|
|
// 60 seconds and are retried once. Call Shutdown when finished with it. It
|
|
// logs to slog.Default() unless given WithLogger.
|
|
func New(
|
|
conf *config.JobSearchConfig, apiRoot string, opts ...Option,
|
|
) *FindATender {
|
|
findATender := &FindATender{
|
|
config: conf,
|
|
apiRoot: apiRoot,
|
|
}
|
|
for _, opt := range opts {
|
|
opt(findATender)
|
|
}
|
|
|
|
findATender.httpClient = resty.New().
|
|
SetTimeout(60 * time.Second).
|
|
SetRetryCount(1)
|
|
|
|
return findATender
|
|
}
|
|
|
|
// logger returns the logger the client logs to, tagged with its component.
|
|
func (ft *FindATender) logger() *slog.Logger {
|
|
log := ft.log
|
|
if log == nil {
|
|
log = slog.Default()
|
|
}
|
|
return log.With("component", "findatender")
|
|
}
|
|
|
|
// ReloadConfig replaces the configuration the client reads, such as the log
|
|
// level. The HTTP client and API root set by New are not changed.
|
|
func (ft *FindATender) ReloadConfig(conf *config.JobSearchConfig) {
|
|
ft.config = conf
|
|
}
|
|
|
|
// With returns a copy of the client whose requests use ctx, so they stop
|
|
// when it is cancelled. A nil ctx returns the client unchanged.
|
|
func (ft *FindATender) With(ctx context.Context) *FindATender {
|
|
if ctx == nil {
|
|
return ft
|
|
}
|
|
|
|
copied := *ft
|
|
copied.ctx = ctx
|
|
return &copied
|
|
}
|
|
|
|
// Shutdown closes the client's HTTP connections. A failure to close is
|
|
// logged, as there is nothing a caller could do about it.
|
|
func (ft *FindATender) Shutdown() {
|
|
if err := ft.httpClient.Close(); err != nil {
|
|
ft.logger().Warn("closing http client failed", "error", err)
|
|
}
|
|
}
|
|
|
|
// FetchOnce fetches the first page of releases updated since since, and
|
|
// converts them to opportunities. If allowRateLimit is true, a 429 response
|
|
// is waited out and retried; otherwise it fails with ErrRateLimitExceeded.
|
|
func (ft *FindATender) FetchOnce(
|
|
since time.Time, allowRateLimit bool,
|
|
) ([]*types.Opportunity, error) {
|
|
releases, err := ft.fetchOnce(RequestOptions{
|
|
Since: since,
|
|
AllowRateLimit: allowRateLimit,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return Convert(releases), nil
|
|
}
|
|
|
|
// FetchAll fetches every page of releases updated since since, following
|
|
// each page's next link, and converts them to opportunities. allowRateLimit
|
|
// behaves as for FetchOnce.
|
|
func (ft *FindATender) FetchAll(
|
|
since time.Time, allowRateLimit bool,
|
|
) ([]*types.Opportunity, error) {
|
|
releases, err := ft.fetchAll(RequestOptions{
|
|
Since: since,
|
|
AllowRateLimit: allowRateLimit,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return Convert(releases), nil
|
|
}
|