Skip to content
Commits on Source (10)
Hide whitespace changes
Inline Side-by-side
.gitlab-ci.yml
View file @ a00ec047
......@@ -3,7 +3,7 @@ include:
ref: 2.1.4
file: '/gitlab-ci-template.yml'
image: docker.io/library/golang:1.22.2@sha256:450e3822c7a135e1463cd83e51c8e2eb03b86a02113c89424e6f0f8344bb4168
image: docker.io/library/golang:1.22.3@sha256:b1e05e2c918f52c59d39ce7d5844f73b2f4511f7734add8bb98c9ecdd4443365
variables:
REPO_NAME: ${CI_SERVER_HOST}/${CI_PROJECT_PATH_SLUG}
......
Dockerfile
View file @ a00ec047
FROM gcr.io/distroless/base-debian12:nonroot@sha256:1c99fceaba16f833d6eb030c07d6304bce68f18350e1a0c69a85b8781afc00d9
FROM gcr.io/distroless/base-debian12:nonroot@sha256:53745e95f227cd66e8058d52f64efbbeb6c6af2c193e3c16981137e5083e6a32
COPY ./hcloud-dynfw /hcloud-dynfw
......
go.mod
View file @ a00ec047
......@@ -2,7 +2,7 @@ module hcloud-dynfw
go 1.21
require github.com/hetznercloud/hcloud-go/v2 v2.7.2
require github.com/hetznercloud/hcloud-go/v2 v2.8.0
require (
github.com/beorn7/perks v1.0.1 // indirect
......
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/action.go
View file @ a00ec047
......@@ -120,172 +120,6 @@ func (c *ActionClient) AllWithOpts(ctx context.Context, opts ActionListOpts) ([]
return c.action.All(ctx, opts)
}
// WatchOverallProgress watches several actions' progress until they complete
// with success or error. This watching happens in a goroutine and updates are
// provided through the two returned channels:
//
// - The first channel receives percentage updates of the progress, based on
// the number of completed versus total watched actions. The return value
// is an int between 0 and 100.
// - The second channel returned receives errors for actions that did not
// complete successfully, as well as any errors that happened while
// querying the API.
//
// By default, the method keeps watching until all actions have finished
// processing. If you want to be able to cancel the method or configure a
// timeout, use the [context.Context]. Once the method has stopped watching,
// both returned channels are closed.
//
// WatchOverallProgress uses the [WithPollBackoffFunc] of the [Client] to wait
// until sending the next request.
func (c *ActionClient) WatchOverallProgress(ctx context.Context, actions []*Action) (<-chan int, <-chan error) {
errCh := make(chan error, len(actions))
progressCh := make(chan int)
go func() {
defer close(errCh)
defer close(progressCh)
completedIDs := make([]int64, 0, len(actions))
watchIDs := make(map[int64]struct{}, len(actions))
for _, action := range actions {
watchIDs[action.ID] = struct{}{}
}
retries := 0
previousProgress := 0
for {
select {
case <-ctx.Done():
errCh <- ctx.Err()
return
case <-time.After(c.action.client.pollBackoffFunc(retries)):
retries++
}
opts := ActionListOpts{}
for watchID := range watchIDs {
opts.ID = append(opts.ID, watchID)
}
as, err := c.AllWithOpts(ctx, opts)
if err != nil {
errCh <- err
return
}
if len(as) == 0 {
// No actions returned for the provided IDs, they do not exist in the API.
// We need to catch and fail early for this, otherwise the loop will continue
// indefinitely.
errCh <- fmt.Errorf("failed to wait for actions: remaining actions (%v) are not returned from API", opts.ID)
return
}
progress := 0
for _, a := range as {
switch a.Status {
case ActionStatusRunning:
progress += a.Progress
case ActionStatusSuccess:
delete(watchIDs, a.ID)
completedIDs = append(completedIDs, a.ID)
case ActionStatusError:
delete(watchIDs, a.ID)
completedIDs = append(completedIDs, a.ID)
errCh <- fmt.Errorf("action %d failed: %w", a.ID, a.Error())
}
}
progress += len(completedIDs) * 100
if progress != 0 && progress != previousProgress {
sendProgress(progressCh, progress/len(actions))
previousProgress = progress
}
if len(watchIDs) == 0 {
return
}
}
}()
return progressCh, errCh
}
// WatchProgress watches one action's progress until it completes with success
// or error. This watching happens in a goroutine and updates are provided
// through the two returned channels:
//
// - The first channel receives percentage updates of the progress, based on
// the progress percentage indicated by the API. The return value is an int
// between 0 and 100.
// - The second channel receives any errors that happened while querying the
// API, as well as the error of the action if it did not complete
// successfully, or nil if it did.
//
// By default, the method keeps watching until the action has finished
// processing. If you want to be able to cancel the method or configure a
// timeout, use the [context.Context]. Once the method has stopped watching,
// both returned channels are closed.
//
// WatchProgress uses the [WithPollBackoffFunc] of the [Client] to wait until
// sending the next request.
func (c *ActionClient) WatchProgress(ctx context.Context, action *Action) (<-chan int, <-chan error) {
errCh := make(chan error, 1)
progressCh := make(chan int)
go func() {
defer close(errCh)
defer close(progressCh)
retries := 0
for {
select {
case <-ctx.Done():
errCh <- ctx.Err()
return
case <-time.After(c.action.client.pollBackoffFunc(retries)):
retries++
}
a, _, err := c.GetByID(ctx, action.ID)
if err != nil {
errCh <- err
return
}
if a == nil {
errCh <- fmt.Errorf("failed to wait for action %d: action not returned from API", action.ID)
return
}
switch a.Status {
case ActionStatusRunning:
sendProgress(progressCh, a.Progress)
case ActionStatusSuccess:
sendProgress(progressCh, 100)
errCh <- nil
return
case ActionStatusError:
errCh <- a.Error()
return
}
}
}()
return progressCh, errCh
}
// sendProgress allows the user to only read from the error channel and ignore any progress updates.
func sendProgress(progressCh chan int, p int) {
select {
case progressCh <- p:
break
default:
break
}
}
// ResourceActionClient is a client for the actions API exposed by the resource.
type ResourceActionClient struct {
resource string
......
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/action_waiter.go 0 → 100644
View file @ a00ec047
package hcloud
import (
"context"
"fmt"
"maps"
"slices"
"time"
)
type ActionWaiter interface {
WaitForFunc(ctx context.Context, handleUpdate func(update *Action) error, actions ...*Action) error
WaitFor(ctx context.Context, actions ...*Action) error
}
var _ ActionWaiter = (*ActionClient)(nil)
// WaitForFunc waits until all actions are completed by polling the API at the interval
// defined by [WithPollBackoffFunc]. An action is considered as complete when its status is
// either [ActionStatusSuccess] or [ActionStatusError].
//
// The handleUpdate callback is called every time an action is updated.
func (c *ActionClient) WaitForFunc(ctx context.Context, handleUpdate func(update *Action) error, actions ...*Action) error {
running := make(map[int64]struct{}, len(actions))
for _, action := range actions {
if action.Status == ActionStatusRunning {
running[action.ID] = struct{}{}
} else if handleUpdate != nil {
// We filter out already completed actions from the API polling loop; while
// this isn't a real update, the caller should be notified about the new
// state.
if err := handleUpdate(action); err != nil {
return err
}
}
}
retries := 0
for {
if len(running) == 0 {
break
}
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(c.action.client.pollBackoffFunc(retries)):
retries++
}
opts := ActionListOpts{
Sort: []string{"status", "id"},
ID: make([]int64, 0, len(running)),
}
for actionID := range running {
opts.ID = append(opts.ID, actionID)
}
slices.Sort(opts.ID)
updates, err := c.AllWithOpts(ctx, opts)
if err != nil {
return err
}
if len(updates) != len(running) {
// Some actions may not exist in the API, also fail early to prevent an
// infinite loop when updates == 0.
notFound := maps.Clone(running)
for _, update := range updates {
delete(notFound, update.ID)
}
notFoundIDs := make([]int64, 0, len(notFound))
for unknownID := range notFound {
notFoundIDs = append(notFoundIDs, unknownID)
}
return fmt.Errorf("actions not found: %v", notFoundIDs)
}
for _, update := range updates {
if update.Status != ActionStatusRunning {
delete(running, update.ID)
}
if handleUpdate != nil {
if err := handleUpdate(update); err != nil {
return err
}
}
}
}
return nil
}
// WaitFor waits until all actions succeed by polling the API at the interval defined by
// [WithPollBackoffFunc]. An action is considered as succeeded when its status is either
// [ActionStatusSuccess].
//
// If a single action fails, the function will stop waiting and the error set in the
// action will be returned as an [ActionError].
//
// For more flexibility, see the [ActionClient.WaitForFunc] function.
func (c *ActionClient) WaitFor(ctx context.Context, actions ...*Action) error {
return c.WaitForFunc(
ctx,
func(update *Action) error {
if update.Status == ActionStatusError {
return update.Error()
}
return nil
},
actions...,
)
}
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/action_watch.go 0 → 100644
View file @ a00ec047
package hcloud
import (
"context"
"fmt"
)
// WatchOverallProgress watches several actions' progress until they complete
// with success or error. This watching happens in a goroutine and updates are
// provided through the two returned channels:
//
// - The first channel receives percentage updates of the progress, based on
// the number of completed versus total watched actions. The return value
// is an int between 0 and 100.
// - The second channel returned receives errors for actions that did not
// complete successfully, as well as any errors that happened while
// querying the API.
//
// By default, the method keeps watching until all actions have finished
// processing. If you want to be able to cancel the method or configure a
// timeout, use the [context.Context]. Once the method has stopped watching,
// both returned channels are closed.
//
// WatchOverallProgress uses the [WithPollBackoffFunc] of the [Client] to wait
// until sending the next request.
//
// Deprecated: WatchOverallProgress is deprecated, use [WaitForFunc] instead.
func (c *ActionClient) WatchOverallProgress(ctx context.Context, actions []*Action) (<-chan int, <-chan error) {
errCh := make(chan error, len(actions))
progressCh := make(chan int)
go func() {
defer close(errCh)
defer close(progressCh)
previousGlobalProgress := 0
progressByAction := make(map[int64]int, len(actions))
err := c.WaitForFunc(ctx, func(update *Action) error {
switch update.Status {
case ActionStatusRunning:
progressByAction[update.ID] = update.Progress
case ActionStatusSuccess:
progressByAction[update.ID] = 100
case ActionStatusError:
progressByAction[update.ID] = 100
errCh <- fmt.Errorf("action %d failed: %w", update.ID, update.Error())
}
// Compute global progress
progressSum := 0
for _, value := range progressByAction {
progressSum += value
}
globalProgress := progressSum / len(actions)
// Only send progress when it changed
if globalProgress != 0 && globalProgress != previousGlobalProgress {
sendProgress(progressCh, globalProgress)
previousGlobalProgress = globalProgress
}
return nil
}, actions...)
if err != nil {
errCh <- err
}
}()
return progressCh, errCh
}
// WatchProgress watches one action's progress until it completes with success
// or error. This watching happens in a goroutine and updates are provided
// through the two returned channels:
//
// - The first channel receives percentage updates of the progress, based on
// the progress percentage indicated by the API. The return value is an int
// between 0 and 100.
// - The second channel receives any errors that happened while querying the
// API, as well as the error of the action if it did not complete
// successfully, or nil if it did.
//
// By default, the method keeps watching until the action has finished
// processing. If you want to be able to cancel the method or configure a
// timeout, use the [context.Context]. Once the method has stopped watching,
// both returned channels are closed.
//
// WatchProgress uses the [WithPollBackoffFunc] of the [Client] to wait until
// sending the next request.
//
// Deprecated: WatchProgress is deprecated, use [WaitForFunc] instead.
func (c *ActionClient) WatchProgress(ctx context.Context, action *Action) (<-chan int, <-chan error) {
errCh := make(chan error, 1)
progressCh := make(chan int)
go func() {
defer close(errCh)
defer close(progressCh)
err := c.WaitForFunc(ctx, func(update *Action) error {
switch update.Status {
case ActionStatusRunning:
sendProgress(progressCh, update.Progress)
case ActionStatusSuccess:
sendProgress(progressCh, 100)
case ActionStatusError:
// Do not wrap the action error
return update.Error()
}
return nil
}, action)
if err != nil {
errCh <- err
}
}()
return progressCh, errCh
}
// sendProgress allows the user to only read from the error channel and ignore any progress updates.
func sendProgress(progressCh chan int, p int) {
select {
case progressCh <- p:
break
default:
break
}
}
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/client.go
View file @ a00ec047
......@@ -236,6 +236,8 @@ func (c *Client) NewRequest(ctx context.Context, method, path string, body io.Re
}
// Do performs an HTTP request against the API.
// v can be nil, an io.Writer to write the response body to or a pointer to
// a struct to json.Unmarshal the response to.
func (c *Client) Do(r *http.Request, v interface{}) (*Response, error) {
var retries int
var body []byte
......@@ -377,6 +379,10 @@ func errorFromResponse(resp *Response, body []byte) error {
return hcErr
}
const (
headerCorrelationID = "X-Correlation-Id"
)
// Response represents a response from the API. It embeds http.Response.
type Response struct {
*http.Response
......@@ -410,6 +416,12 @@ func (r *Response) readMeta(body []byte) error {
return nil
}
// internalCorrelationID returns the unique ID of the request as set by the API. This ID can help with support requests,
// as it allows the people working on identify this request in particular.
func (r *Response) internalCorrelationID() string {
return r.Header.Get(headerCorrelationID)
}
// Meta represents meta information included in an API response.
type Meta struct {
Pagination *Pagination
......
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/error.go
View file @ a00ec047
......@@ -100,6 +100,13 @@ type Error struct {
}
func (e Error) Error() string {
if resp := e.Response(); resp != nil {
correlationID := resp.internalCorrelationID()
if correlationID != "" {
// For easier debugging, the error string contains the Correlation ID of the response.
return fmt.Sprintf("%s (%s, %s)", e.Message, e.Code, correlationID)
}
}
return fmt.Sprintf("%s (%s)", e.Message, e.Code)
}
......
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/hcloud.go
View file @ a00ec047
......@@ -2,4 +2,4 @@
package hcloud
// Version is the library's version following Semantic Versioning.
const Version = "2.7.2" // x-release-please-version
const Version = "2.8.0" // x-release-please-version
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/interface_gen.go
View file @ a00ec047
package hcloud
//go:generate go run github.com/vburenin/ifacemaker -f action.go -s ActionClient -i IActionClient -p hcloud -o zz_action_client_iface.go
//go:generate go run github.com/vburenin/ifacemaker -f action.go -f action_watch.go -f action_waiter.go -s ActionClient -i IActionClient -p hcloud -o zz_action_client_iface.go
//go:generate go run github.com/vburenin/ifacemaker -f action.go -s ResourceActionClient -i IResourceActionClient -p hcloud -o zz_resource_action_client_iface.go
//go:generate go run github.com/vburenin/ifacemaker -f datacenter.go -s DatacenterClient -i IDatacenterClient -p hcloud -o zz_datacenter_client_iface.go
//go:generate go run github.com/vburenin/ifacemaker -f floating_ip.go -s FloatingIPClient -i IFloatingIPClient -p hcloud -o zz_floating_ip_client_iface.go
......
vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_action_client_iface.go
View file @ a00ec047
......@@ -37,6 +37,8 @@ type IActionClient interface {
//
// WatchOverallProgress uses the [WithPollBackoffFunc] of the [Client] to wait
// until sending the next request.
//
// Deprecated: WatchOverallProgress is deprecated, use [WaitForFunc] instead.
WatchOverallProgress(ctx context.Context, actions []*Action) (<-chan int, <-chan error)
// WatchProgress watches one action's progress until it completes with success
// or error. This watching happens in a goroutine and updates are provided
......@@ -56,5 +58,22 @@ type IActionClient interface {
//
// WatchProgress uses the [WithPollBackoffFunc] of the [Client] to wait until
// sending the next request.
//
// Deprecated: WatchProgress is deprecated, use [WaitForFunc] instead.
WatchProgress(ctx context.Context, action *Action) (<-chan int, <-chan error)
// WaitForFunc waits until all actions are completed by polling the API at the interval
// defined by [WithPollBackoffFunc]. An action is considered as complete when its status is
// either [ActionStatusSuccess] or [ActionStatusError].
//
// The handleUpdate callback is called every time an action is updated.
WaitForFunc(ctx context.Context, handleUpdate func(update *Action) error, actions ...*Action) error
// WaitFor waits until all actions succeed by polling the API at the interval defined by
// [WithPollBackoffFunc]. An action is considered as succeeded when its status is either
// [ActionStatusSuccess].
//
// If a single action fails, the function will stop waiting and the error set in the
// action will be returned as an [ActionError].
//
// For more flexibility, see the [ActionClient.WaitForFunc] function.
WaitFor(ctx context.Context, actions ...*Action) error
}
vendor/modules.txt
View file @ a00ec047
......@@ -6,8 +6,8 @@ github.com/beorn7/perks/quantile
github.com/cespare/xxhash/v2
# github.com/golang/protobuf v1.5.3
## explicit; go 1.9
# github.com/hetznercloud/hcloud-go/v2 v2.7.2
## explicit; go 1.20
# github.com/hetznercloud/hcloud-go/v2 v2.8.0
## explicit; go 1.21
github.com/hetznercloud/hcloud-go/v2/hcloud
github.com/hetznercloud/hcloud-go/v2/hcloud/internal/instrumentation
github.com/hetznercloud/hcloud-go/v2/hcloud/schema
......