Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package hcloud-cli for openSUSE:Factory checked in at 2026-10-06 19:17:23 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/hcloud-cli (Old) and /work/SRC/openSUSE:Factory/.hcloud-cli.new.3698736 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "hcloud-cli" Tue Oct 6 19:17:23 2026 rev:25 rq:1382666 version:1.70.0 Changes: -------- --- /work/SRC/openSUSE:Factory/hcloud-cli/hcloud-cli.changes 2026-09-28 10:40:27.200871568 +0200 +++ /work/SRC/openSUSE:Factory/.hcloud-cli.new.3698736/hcloud-cli.changes 2026-10-06 19:17:27.400122558 +0200 @@ -1,0 +2,33 @@ +Tue Oct 06 04:47:33 UTC 2026 - Johannes Kastl <[email protected]> + +- Update to version 1.70.0: + * Load Balancers can now be created with existing Primary IPs + Primary IPs, which were previously available exclusively for + Servers, are now also available for Load Balancers. When + creating a Load Balancer, you can assign an existing Primary IP + instead of having an IP address allocated automatically. + Currently, you cannot change the Primary IP once the Load + Balancer has been created. + To support this change, we added the following flags to the + load balancer create command: + - --primary-ipv4 <primary-ip>: Name or id of an IPv4 Primary IP + to assign to the Load Balancer. + - --primary-ipv6 <primary-ip>: Name or id of an IPv6 Primary IP + to assign to the Load Balancer. + If you omit a property, a new Primary IP of that version is + allocated for the Load Balancer, as before. + A Primary IP can currently only be assigned when the Load + Balancer is created. It stays assigned for the entire lifetime + of the Load Balancer. + Related to + https://docs.hetzner.cloud/changelog#2026-10-05-load-balancers-can-use-existing-primary-ips. + * Features + - load-balancer: allow creating with Primary IPs (#1500) (fe26d1f) + - load-balancer: add health check diagnostic details (#1496) (300430a) + * Dependencies + - deps: update module github.com/hetznercloud/hcloud-go/v2 to + v2.50.0 (#1497) + - deps: update dependency github:golangci/golangci-lint to + v2.14.0 (#1495) + +------------------------------------------------------------------- Old: ---- hcloud-cli-1.69.0.obscpio New: ---- hcloud-cli-1.70.0.obscpio ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ hcloud-cli.spec ++++++ --- /var/tmp/diff_new_pack.lGlZin/_old 2026-10-06 19:17:29.232199223 +0200 +++ /var/tmp/diff_new_pack.lGlZin/_new 2026-10-06 19:17:29.233199265 +0200 @@ -19,7 +19,7 @@ %define executable_name hcloud Name: hcloud-cli -Version: 1.69.0 +Version: 1.70.0 Release: 0 Summary: A command-line interface for Hetzner Cloud License: MIT ++++++ _service ++++++ --- /var/tmp/diff_new_pack.lGlZin/_old 2026-10-06 19:17:29.307202362 +0200 +++ /var/tmp/diff_new_pack.lGlZin/_new 2026-10-06 19:17:29.318202822 +0200 @@ -3,7 +3,7 @@ <param name="url">https://github.com/hetznercloud/cli.git</param> <param name="scm">git</param> <param name="exclude">.git</param> - <param name="revision">refs/tags/v1.69.0</param> + <param name="revision">refs/tags/v1.70.0</param> <param name="versionformat">@PARENT_TAG@</param> <param name="versionrewrite-pattern">v(.*)</param> <param name="changesgenerate">enable</param> ++++++ _servicedata ++++++ --- /var/tmp/diff_new_pack.lGlZin/_old 2026-10-06 19:17:29.364204747 +0200 +++ /var/tmp/diff_new_pack.lGlZin/_new 2026-10-06 19:17:29.381205459 +0200 @@ -3,6 +3,6 @@ <param name="url">https://github.com/hetznercloud/cli</param> <param name="changesrevision">a9f3077b036d9145ef75e17b51483fa4481c0a9f</param></service><service name="tar_scm"> <param name="url">https://github.com/hetznercloud/cli.git</param> - <param name="changesrevision">88350084112192df1317e3cc101419ddcb85c689</param></service></servicedata> + <param name="changesrevision">85e7ffd0cdd958f2dc2c931bad3dea5da213b7d4</param></service></servicedata> (No newline at EOF) ++++++ hcloud-cli-1.69.0.obscpio -> hcloud-cli-1.70.0.obscpio ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/CHANGELOG.md new/hcloud-cli-1.70.0/CHANGELOG.md --- old/hcloud-cli-1.69.0/CHANGELOG.md 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/CHANGELOG.md 2026-10-05 16:28:07.000000000 +0200 @@ -1,5 +1,29 @@ # Changelog +## [v1.70.0](https://github.com/hetznercloud/cli/releases/tag/v1.70.0) + +[Compare to previous version](https://github.com/hetznercloud/cli/compare/v1.69.0...v1.70.0) + +### Load Balancers can now be created with existing Primary IPs + +Primary IPs, which were previously available exclusively for Servers, are now also available for Load Balancers. When creating a Load Balancer, you can assign an [existing Primary IP](https://docs.hetzner.cloud/reference/cloud#tag/primary-ips/list_primary_ips) instead of having an IP address allocated automatically. Currently, you cannot change the Primary IP once the Load Balancer has been created. + +To support this change, we added the following flags to the load balancer create command: + +- `--primary-ipv4 <primary-ip>`: Name or id of an IPv4 Primary IP to assign to the Load Balancer. +- `--primary-ipv6 <primary-ip>`: Name or id of an IPv6 Primary IP to assign to the Load Balancer. + +If you omit a property, a new Primary IP of that version is allocated for the Load Balancer, as before. + +A Primary IP can currently only be assigned when the Load Balancer is created. It stays assigned for the entire lifetime of the Load Balancer. + +Related to https://docs.hetzner.cloud/changelog#2026-10-05-load-balancers-can-use-existing-primary-ips. + +### Features + +- **load-balancer**: allow creating with Primary IPs (#1500) ([fe26d1f](https://github.com/hetznercloud/cli/commit/fe26d1f2a97e9ab06e0ab5e95701aed3da4532f4)) +- **load-balancer**: add health check diagnostic details (#1496) ([300430a](https://github.com/hetznercloud/cli/commit/300430ae11f69ff8686ad7aad1c72d0cf542960f)) + ## [v1.69.0](https://github.com/hetznercloud/cli/releases/tag/v1.69.0) [Compare to previous version](https://github.com/hetznercloud/cli/compare/v1.68.0...v1.69.0) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/docs/reference/manual/hcloud_load-balancer_create.md new/hcloud-cli-1.70.0/docs/reference/manual/hcloud_load-balancer_create.md --- old/hcloud-cli-1.69.0/docs/reference/manual/hcloud_load-balancer_create.md 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/docs/reference/manual/hcloud_load-balancer_create.md 2026-10-05 16:28:07.000000000 +0200 @@ -18,6 +18,8 @@ --network string Name or ID of the Network the Load Balancer should be attached to on creation --network-zone string Network Zone -o, --output stringArray output options: json|yaml + --primary-ipv4 string Primary IPv4 (ID or name) to assign to the Load Balancer + --primary-ipv6 string Primary IPv6 (ID or name) to assign to the Load Balancer --type string Load Balancer Type (ID or name) (required) ``` diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/go.mod new/hcloud-cli-1.70.0/go.mod --- old/hcloud-cli-1.69.0/go.mod 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/go.mod 2026-10-05 16:28:07.000000000 +0200 @@ -12,7 +12,7 @@ github.com/fatih/structs v1.1.0 github.com/goccy/go-yaml v1.19.2 github.com/guptarohit/asciigraph v0.10.0 - github.com/hetznercloud/hcloud-go/v2 v2.49.0 + github.com/hetznercloud/hcloud-go/v2 v2.52.0 github.com/jedib0t/go-pretty/v6 v6.8.3 github.com/spf13/cast v1.10.0 github.com/spf13/cobra v1.10.2 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/go.sum new/hcloud-cli-1.70.0/go.sum --- old/hcloud-cli-1.69.0/go.sum 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/go.sum 2026-10-05 16:28:07.000000000 +0200 @@ -37,8 +37,8 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/guptarohit/asciigraph v0.10.0 h1:LmbFXSHZOhaQxjJYexdRk7TzoC5sJ7vDTEjP1YUbKgY= github.com/guptarohit/asciigraph v0.10.0/go.mod h1:dYl5wwK4gNsnFf9Zp+l06rFiDZ5YtXM6x7SRWZ3KGag= -github.com/hetznercloud/hcloud-go/v2 v2.49.0 h1:QXONxfgXIF99PFJknkVw+LrQQB4PB5IbEjEDh4Hfmig= -github.com/hetznercloud/hcloud-go/v2 v2.49.0/go.mod h1:J9QH6j8pRH0K3+HlqgOlQ8abXagWTD/GpTkfra2et+g= +github.com/hetznercloud/hcloud-go/v2 v2.52.0 h1:BrQSFNuPhPZrWNdXKSEACX1hcS1TRzKSHMfFcXYRhDA= +github.com/hetznercloud/hcloud-go/v2 v2.52.0/go.mod h1:J9QH6j8pRH0K3+HlqgOlQ8abXagWTD/GpTkfra2et+g= github.com/iancoleman/orderedmap v0.3.0 h1:5cbR2grmZR/DiVt+VJopEhtVs9YGInGIxAoMJn+Ichc= github.com/iancoleman/orderedmap v0.3.0/go.mod h1:XuLcCUkdL5owUCQeF2Ue9uuw1EptkJDkXXS7VoV7XGE= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/create.go new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/create.go --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/create.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/create.go 2026-10-05 16:28:07.000000000 +0200 @@ -48,6 +48,12 @@ cmd.Flags().String("network", "", "Name or ID of the Network the Load Balancer should be attached to on creation") _ = cmd.RegisterFlagCompletionFunc("network", cmpl.SuggestCandidatesF(client.Network().Names)) + cmd.Flags().String("primary-ipv4", "", "Primary IPv4 (ID or name) to assign to the Load Balancer") + _ = cmd.RegisterFlagCompletionFunc("primary-ipv4", cmpl.SuggestCandidatesF(client.PrimaryIP().Names(true, false, hcloud.Ptr(hcloud.PrimaryIPTypeIPv4)))) + + cmd.Flags().String("primary-ipv6", "", "Primary IPv6 (ID or name) to assign to the Load Balancer") + _ = cmd.RegisterFlagCompletionFunc("primary-ipv6", cmpl.SuggestCandidatesF(client.PrimaryIP().Names(true, false, hcloud.Ptr(hcloud.PrimaryIPTypeIPv6)))) + return cmd }, Run: func(s state.State, cmd *cobra.Command, _ []string) (*hcloud.LoadBalancer, any, error) { @@ -59,6 +65,8 @@ labels, _ := cmd.Flags().GetStringToString("label") protection, _ := cmd.Flags().GetStringSlice("enable-protection") network, _ := cmd.Flags().GetString("network") + primaryIPv4IDOrName, _ := cmd.Flags().GetString("primary-ipv4") + primaryIPv6IDOrName, _ := cmd.Flags().GetString("primary-ipv6") protectionOpts, err := ChangeProtectionCmds.GetChangeProtectionOpts(true, protection) if err != nil { @@ -99,6 +107,30 @@ } createOpts.Network = net } + publicNet := &hcloud.LoadBalancerCreateOptsPublicNet{} + if primaryIPv4IDOrName != "" { + primaryIPv4, _, err := s.Client().PrimaryIP().Get(s, primaryIPv4IDOrName) + if err != nil { + return nil, nil, err + } + if primaryIPv4 == nil { + return nil, nil, fmt.Errorf("Primary IPv4 not found: %s", primaryIPv4IDOrName) + } + publicNet.IPv4 = primaryIPv4 + } + if primaryIPv6IDOrName != "" { + primaryIPv6, _, err := s.Client().PrimaryIP().Get(s, primaryIPv6IDOrName) + if err != nil { + return nil, nil, err + } + if primaryIPv6 == nil { + return nil, nil, fmt.Errorf("Primary IPv6 not found: %s", primaryIPv6IDOrName) + } + publicNet.IPv6 = primaryIPv6 + } + if primaryIPv4IDOrName != "" || primaryIPv6IDOrName != "" { + createOpts.PublicNet = publicNet + } result, _, err := s.Client().LoadBalancer().Create(s, createOpts) if err != nil { return nil, nil, err diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/create_test.go new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/create_test.go --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/create_test.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/create_test.go 2026-10-05 16:28:07.000000000 +0200 @@ -66,6 +66,83 @@ assert.Equal(t, expOut, out) } +func TestCreatePrimaryIPs(t *testing.T) { + fx := testutil.NewFixture(t) + defer fx.Finish() + + cmd := loadbalancer.CreateCmd.CobraCommand(fx.State()) + fx.ExpectEnsureToken() + + primaryIPv4 := &hcloud.PrimaryIP{ + ID: 1, + Name: "myPrimaryIP", + Type: hcloud.PrimaryIPTypeIPv4, + IP: net.ParseIP("192.168.2.1"), + } + primaryIPv6 := &hcloud.PrimaryIP{ + ID: 2, + Name: "myPrimaryIPv6", + Type: hcloud.PrimaryIPTypeIPv6, + IP: net.IPv6zero, + } + + fx.Client.LoadBalancerTypeClient.EXPECT(). + Get(gomock.Any(), "lb11"). + Return(&hcloud.LoadBalancerType{Name: "lb11"}, nil, nil) + fx.Client.PrimaryIPClient.EXPECT(). + Get(gomock.Any(), "myPrimaryIP"). + Return(primaryIPv4, nil, nil) + fx.Client.PrimaryIPClient.EXPECT(). + Get(gomock.Any(), "myPrimaryIPv6"). + Return(primaryIPv6, nil, nil) + fx.Client.LoadBalancerClient.EXPECT(). + Create(gomock.Any(), hcloud.LoadBalancerCreateOpts{ + Name: "myLoadBalancer", + LoadBalancerType: &hcloud.LoadBalancerType{Name: "lb11"}, + Location: &hcloud.Location{Name: "fsn1"}, + Labels: make(map[string]string), + PublicNet: &hcloud.LoadBalancerCreateOptsPublicNet{ + IPv4: primaryIPv4, + IPv6: primaryIPv6, + }, + }). + Return(hcloud.LoadBalancerCreateResult{ + LoadBalancer: &hcloud.LoadBalancer{ID: 123}, + Action: &hcloud.Action{ID: 321}, + }, nil, nil) + fx.ActionWaiter.EXPECT().WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 321}).Return(nil) + fx.Client.LoadBalancerClient.EXPECT(). + GetByID(gomock.Any(), int64(123)). + Return(&hcloud.LoadBalancer{ + ID: 123, + PublicNet: hcloud.LoadBalancerPublicNet{ + IPv4: hcloud.LoadBalancerPublicNetIPv4{ + IP: net.ParseIP("192.168.2.1"), + }, + IPv6: hcloud.LoadBalancerPublicNetIPv6{ + IP: net.IPv6zero, + }, + }, + }, nil, nil) + + out, errOut, err := fx.Run(cmd, []string{ + "--name", "myLoadBalancer", + "--type", "lb11", + "--location", "fsn1", + "--primary-ipv4", "myPrimaryIP", + "--primary-ipv6", "myPrimaryIPv6", + }) + + expOut := `Load Balancer 123 created +IPv4: 192.168.2.1 +IPv6: :: +` + + require.NoError(t, err) + assert.Empty(t, errOut) + assert.Equal(t, expOut, out) +} + func TestCreateJSON(t *testing.T) { fx := testutil.NewFixture(t) defer fx.Finish() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/delete.go new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/delete.go --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/delete.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/delete.go 2026-10-05 16:28:07.000000000 +0200 @@ -18,7 +18,7 @@ return s.Client().LoadBalancer().Get(s, idOrName) }, Delete: func(s state.State, _ *cobra.Command, loadBalancer *hcloud.LoadBalancer) ([]*hcloud.Action, error) { - _, err := s.Client().LoadBalancer().Delete(s, loadBalancer) - return nil, err + result, _, err := s.Client().LoadBalancer().DeleteWithResult(s, loadBalancer) + return []*hcloud.Action{result.Action}, err }, } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/delete_test.go new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/delete_test.go --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/delete_test.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/delete_test.go 2026-10-05 16:28:07.000000000 +0200 @@ -28,8 +28,12 @@ Get(gomock.Any(), "test"). Return(loadBalancer, nil, nil) fx.Client.LoadBalancerClient.EXPECT(). - Delete(gomock.Any(), loadBalancer). - Return(nil, nil) + DeleteWithResult(gomock.Any(), loadBalancer). + Return(hcloud.LoadBalancerDeleteResult{ + Action: &hcloud.Action{ID: 321}, + }, nil, nil) + fx.ActionWaiter.EXPECT(). + WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 321}) out, errOut, err := fx.Run(cmd, []string{"test"}) @@ -69,10 +73,15 @@ Get(gomock.Any(), lb.Name). Return(lb, nil, nil) fx.Client.LoadBalancerClient.EXPECT(). - Delete(gomock.Any(), lb). - Return(nil, nil) + DeleteWithResult(gomock.Any(), lb). + Return(hcloud.LoadBalancerDeleteResult{ + Action: &hcloud.Action{ID: 321}, + }, nil, nil) } + fx.ActionWaiter.EXPECT(). + WaitForActions(gomock.Any(), gomock.Any(), &hcloud.Action{ID: 321}) + out, errOut, err := fx.Run(cmd, names) require.NoError(t, err) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/describe.go new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/describe.go --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/describe.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/describe.go 2026-10-05 16:28:07.000000000 +0200 @@ -122,10 +122,7 @@ fmt.Fprintf(out, " Name:\t%s\n", s.Client().Server().ServerName(target.Server.Server.ID)) fmt.Fprintf(out, " Use Private IP:\t%s\n", util.YesNo(target.UsePrivateIP)) fmt.Fprintf(out, " Status:\t\n") - for _, healthStatus := range target.HealthStatus { - fmt.Fprintf(out, " - Service:\t%d\n", healthStatus.ListenPort) - fmt.Fprintf(out, " Status:\t%s\n", healthStatus.Status) - } + describeHealthStatus(out, target.HealthStatus, " ") case hcloud.LoadBalancerTargetTypeLabelSelector: fmt.Fprintf(out, " Label Selector:\t%s\n", target.LabelSelector.Selector) fmt.Fprintf(out, " Targets: (%d)\t\n", len(target.Targets)) @@ -139,18 +136,12 @@ fmt.Fprintf(out, " - Type:\t%s\n", lbtarget.Type) fmt.Fprintf(out, " Server ID:\t%d\n", lbtarget.Server.Server.ID) fmt.Fprintf(out, " Status:\t\n") - for _, healthStatus := range lbtarget.HealthStatus { - fmt.Fprintf(out, " - Service:\t%d\n", healthStatus.ListenPort) - fmt.Fprintf(out, " Status:\t%s\n", healthStatus.Status) - } + describeHealthStatus(out, lbtarget.HealthStatus, " ") } case hcloud.LoadBalancerTargetTypeIP: fmt.Fprintf(out, " IP:\t%s\n", target.IP.IP) fmt.Fprintf(out, " Status:\t\n") - for _, healthStatus := range target.HealthStatus { - fmt.Fprintf(out, " - Service:\t%d\n", healthStatus.ListenPort) - fmt.Fprintf(out, " Status:\t%s\n", healthStatus.Status) - } + describeHealthStatus(out, target.HealthStatus, " ") } } } @@ -171,3 +162,16 @@ return nil }, } + +func describeHealthStatus(out io.Writer, healthStatuses []hcloud.LoadBalancerTargetHealthStatus, indent string) { + for _, healthStatus := range healthStatuses { + fmt.Fprintf(out, "%s- Service:\t%d\n", indent, healthStatus.ListenPort) + fmt.Fprintf(out, "%s Status:\t%s\n", indent, healthStatus.Status) + if healthStatus.Detail != nil { + fmt.Fprintf(out, "%s Detail:\t%s\n", indent, *healthStatus.Detail) + } + if healthStatus.HTTPStatusCode != nil { + fmt.Fprintf(out, "%s HTTP Status Code:\t%d\n", indent, *healthStatus.HTTPStatusCode) + } + } +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/describe_test.go new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/describe_test.go --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/describe_test.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/describe_test.go 2026-10-05 16:28:07.000000000 +0200 @@ -83,6 +83,24 @@ IncludedTraffic: 20 * util.Tebibyte, IngoingTraffic: 10 * util.Tebibyte, OutgoingTraffic: 10 * util.Tebibyte, + Targets: []hcloud.LoadBalancerTarget{ + { + Type: hcloud.LoadBalancerTargetTypeIP, + IP: &hcloud.LoadBalancerTargetIP{IP: "10.0.0.1"}, + HealthStatus: []hcloud.LoadBalancerTargetHealthStatus{ + { + ListenPort: 80, + Status: hcloud.LoadBalancerTargetHealthStatusStatusHealthy, + }, + { + ListenPort: 443, + Status: hcloud.LoadBalancerTargetHealthStatusStatusUnhealthy, + Detail: hcloud.Ptr(hcloud.LoadBalancerTargetHealthStatusDetailUnexpectedHTTPStatus), + HTTPStatusCode: hcloud.Ptr(500), + }, + }, + }, + }, } fx.Client.LoadBalancerClient.EXPECT(). @@ -136,7 +154,15 @@ Status Codes: [200 201] Targets: - No targets + - Type: ip + IP: 10.0.0.1 + Status: + - Service: 80 + Status: healthy + - Service: 443 + Status: unhealthy + Detail: unexpected_http_status + HTTP Status Code: 500 Traffic: Outgoing: 10 TiB diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/testdata/create_response.json new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/testdata/create_response.json --- old/hcloud-cli-1.69.0/internal/cmd/loadbalancer/testdata/create_response.json 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/cmd/loadbalancer/testdata/create_response.json 2026-10-05 16:28:07.000000000 +0200 @@ -39,11 +39,15 @@ "public_net": { "enabled": false, "ipv4": { + "blocked": false, "dns_ptr": "", + "id": 0, "ip": "192.168.2.1" }, "ipv6": { + "blocked": false, "dns_ptr": "", + "id": 0, "ip": "::" } }, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/hcapi2/mock/zz_hcapi_mock.go new/hcloud-cli-1.70.0/internal/hcapi2/mock/zz_hcapi_mock.go --- old/hcloud-cli-1.69.0/internal/hcapi2/mock/zz_hcapi_mock.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/hcapi2/mock/zz_hcapi_mock.go 2026-10-05 16:28:07.000000000 +0200 @@ -2048,6 +2048,22 @@ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockLoadBalancerClient)(nil).DeleteService), ctx, loadBalancer, listenPort) } +// DeleteWithResult mocks base method. +func (m *MockLoadBalancerClient) DeleteWithResult(ctx context.Context, loadBalancer *hcloud.LoadBalancer) (hcloud.LoadBalancerDeleteResult, *hcloud.Response, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteWithResult", ctx, loadBalancer) + ret0, _ := ret[0].(hcloud.LoadBalancerDeleteResult) + ret1, _ := ret[1].(*hcloud.Response) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// DeleteWithResult indicates an expected call of DeleteWithResult. +func (mr *MockLoadBalancerClientMockRecorder) DeleteWithResult(ctx, loadBalancer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWithResult", reflect.TypeOf((*MockLoadBalancerClient)(nil).DeleteWithResult), ctx, loadBalancer) +} + // DetachFromNetwork mocks base method. func (m *MockLoadBalancerClient) DetachFromNetwork(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerDetachFromNetworkOpts) (*hcloud.Action, *hcloud.Response, error) { m.ctrl.T.Helper() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/internal/version/version.go new/hcloud-cli-1.70.0/internal/version/version.go --- old/hcloud-cli-1.69.0/internal/version/version.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/internal/version/version.go 2026-10-05 16:28:07.000000000 +0200 @@ -4,7 +4,7 @@ var ( // version is a semver version (https://semver.org). - version = "1.69.0" // x-releaser-pleaser-version + version = "1.70.0" // x-releaser-pleaser-version // versionPrerelease is a semver version pre-release identifier (https://semver.org). // diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/mise.toml new/hcloud-cli-1.70.0/mise.toml --- old/hcloud-cli-1.69.0/mise.toml 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/mise.toml 2026-10-05 16:28:07.000000000 +0200 @@ -1,7 +1,7 @@ [tools] go = "1.26.8" "go:go.uber.org/mock/mockgen" = "v0.6.0" -"github:golangci/golangci-lint" = "2.13.2" +"github:golangci/golangci-lint" = "2.14.0" "github:goreleaser/goreleaser" = "v2.18.2" "github:anchore/quill" = "v0.7.1" "github:jstemmer/go-junit-report" = "v2.1.0" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/hcloud-cli-1.69.0/test/e2e/datacenter_test.go new/hcloud-cli-1.70.0/test/e2e/datacenter_test.go --- old/hcloud-cli-1.69.0/test/e2e/datacenter_test.go 2026-09-24 16:48:58.000000000 +0200 +++ new/hcloud-cli-1.70.0/test/e2e/datacenter_test.go 1970-01-01 01:00:00.000000000 +0100 @@ -1,75 +0,0 @@ -//go:build e2e - -package e2e - -import ( - "encoding/json" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestDatacenter(t *testing.T) { - t.Parallel() - - t.Run("list", func(t *testing.T) { - t.Run("table", func(t *testing.T) { - out, err := runCommand(t, "datacenter", "list") - require.NoError(t, err) - assert.Regexp(t, - NewRegex().Start(). - SeparatedByWhitespace("ID", "NAME", "DESCRIPTION", "LOCATION").Newline(). - AnyTimes(NewRegex().Int().Whitespace().Identifier().Whitespace().AnyString().Whitespace().LocationName().Newline()). - End(), - out, - ) - }) - - t.Run("json", func(t *testing.T) { - out, err := runCommand(t, "datacenter", "list", "-o=json") - require.NoError(t, err) - require.NoError(t, json.Unmarshal([]byte(out), new([]any))) - }) - }) - - t.Run("describe", func(t *testing.T) { - t.Run("non-existing", func(t *testing.T) { - out, err := runCommand(t, "datacenter", "describe", "123456") - require.EqualError(t, err, "Datacenter not found: 123456") - assert.Empty(t, out) - }) - - t.Run("normal", func(t *testing.T) { - out, err := runCommand(t, "datacenter", "describe", TestDatacenterID) - require.NoError(t, err) - - assert.Regexp(t, - NewRegex().Start(). - Lit("ID:").Whitespace().Int().Newline(). - Lit("Name:").Whitespace().Identifier().Newline(). - Lit("Description:").Whitespace().AnyString().Newline(). - Newline(). - Lit("Location:").Newline(). - Lit(" ID:").Whitespace().Int().Newline(). - Lit(" Name:").Whitespace().LocationName().Newline(). - Lit(" Description:").Whitespace().AnyString().Newline(). - Lit(" Network Zone:").Whitespace().OneOfLit("eu-central", "us-east", "us-west", "ap-southeast").Newline(). - Lit(" Country:").Whitespace().CountryCode().Newline(). - Lit(" City:").Whitespace().AnyString().Newline(). - Lit(" Latitude:").Whitespace().Float().Newline(). - Lit(" Longitude:").Whitespace().Float().Newline(). - Newline(). - Lit("Server Types:").Newline(). - AnyTimes( - NewRegex(). - Lit(" - ID: ").Int().Whitespace(). - Lit("Name: ").Identifier().Whitespace(). - Lit("Supported: ").OneOfLit("true", "false").Whitespace(). - Lit("Available: ").OneOfLit("true", "false").Newline(), - ).End(), - out, - ) - }) - }) -} ++++++ hcloud-cli.obsinfo ++++++ --- /var/tmp/diff_new_pack.lGlZin/_old 2026-10-06 19:17:30.536253793 +0200 +++ /var/tmp/diff_new_pack.lGlZin/_new 2026-10-06 19:17:30.547254253 +0200 @@ -1,5 +1,5 @@ name: hcloud-cli -version: 1.69.0 -mtime: 1790261338 -commit: 88350084112192df1317e3cc101419ddcb85c689 +version: 1.70.0 +mtime: 1791210487 +commit: 85e7ffd0cdd958f2dc2c931bad3dea5da213b7d4 ++++++ vendor.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/error.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/error.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/error.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/error.go 2026-10-05 16:28:07.000000000 +0200 @@ -32,7 +32,6 @@ ErrorCodeRobotUnavailable ErrorCode = "robot_unavailable" // Robot was not available. The caller may retry the operation after a short delay ErrorCodeResourceLocked ErrorCode = "resource_locked" // The resource is locked. The caller should contact support ErrorCodeServerError ErrorCode = "server_error" // Error within the API backend - ErrorCodeTokenReadonly ErrorCode = "token_readonly" // The token is only allowed to perform GET requests ErrorCodeBadGateway ErrorCode = "bad_gateway" // The request could not be answered by the API backend, please retry ErrorCodeTimeout ErrorCode = "timeout" // The request could not be answered in time, please retry ErrorUnsupportedError ErrorCode = "unsupported_error" // The given resource does not support this @@ -111,6 +110,14 @@ // //go:fix inline ErrorCodeLimitReached = ErrorCodeRateLimitExceeded + + // ErrorCodeTokenReadonly is returned if the token is only allowed to perform GET + // requests + // + // Deprecated: This error code is deprecated, please use [ErrorCodeForbidden] instead. + // + //go:fix inline + ErrorCodeTokenReadonly = ErrorCodeForbidden ) // Error is an error returned from the API. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/internal/version/version.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/internal/version/version.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/internal/version/version.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/internal/version/version.go 2026-10-05 16:28:07.000000000 +0200 @@ -1,4 +1,4 @@ package version // Version is the library's version following Semantic Versioning. -const Version = "2.49.0" // x-releaser-pleaser-version +const Version = "2.52.0" // x-releaser-pleaser-version diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/load_balancer.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/load_balancer.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/load_balancer.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/load_balancer.go 2026-10-05 16:28:07.000000000 +0200 @@ -48,14 +48,18 @@ // LoadBalancerPublicNetIPv4 represents a Load Balancer's public IPv4 address. type LoadBalancerPublicNetIPv4 struct { - IP net.IP - DNSPtr string + ID int64 + IP net.IP + Blocked bool + DNSPtr string } // LoadBalancerPublicNetIPv6 represents a Load Balancer's public IPv6 address. type LoadBalancerPublicNetIPv6 struct { - IP net.IP - DNSPtr string + ID int64 + IP net.IP + Blocked bool + DNSPtr string } // LoadBalancerPrivateNet represents a Load Balancer's private network. @@ -193,10 +197,32 @@ LoadBalancerTargetHealthStatusStatusUnhealthy LoadBalancerTargetHealthStatusStatus = "unhealthy" ) +// LoadBalancerTargetHealthStatusDetail describes additional details about why +// a health check failed. It is only present when the health status is +// unhealthy. +type LoadBalancerTargetHealthStatusDetail string + +const ( + // LoadBalancerTargetHealthStatusDetailUnspecified denotes that the reason for a failed health check is unspecified. + LoadBalancerTargetHealthStatusDetailUnspecified LoadBalancerTargetHealthStatusDetail = "unspecified" + // LoadBalancerTargetHealthStatusDetailLayer4NoConnection denotes that no connection could be established to the target. + LoadBalancerTargetHealthStatusDetailLayer4NoConnection LoadBalancerTargetHealthStatusDetail = "layer4_no_connection" + // LoadBalancerTargetHealthStatusDetailLayer4Timeout denotes that the target did not respond in time. + LoadBalancerTargetHealthStatusDetailLayer4Timeout LoadBalancerTargetHealthStatusDetail = "layer4_timeout" + // LoadBalancerTargetHealthStatusDetailLayer7Timeout denotes that the target did not respond in time. + LoadBalancerTargetHealthStatusDetailLayer7Timeout LoadBalancerTargetHealthStatusDetail = "layer7_timeout" + // LoadBalancerTargetHealthStatusDetailUnexpectedHTTPStatus denotes that the target responded with an unexpected HTTP status code. + LoadBalancerTargetHealthStatusDetailUnexpectedHTTPStatus LoadBalancerTargetHealthStatusDetail = "unexpected_http_status" + // LoadBalancerTargetHealthStatusDetailUnexpectedHTTPContent denotes that the target responded with unexpected HTTP content. + LoadBalancerTargetHealthStatusDetailUnexpectedHTTPContent LoadBalancerTargetHealthStatusDetail = "unexpected_http_content" +) + // LoadBalancerTargetHealthStatus describes a target's health for a specific service. type LoadBalancerTargetHealthStatus struct { - ListenPort int - Status LoadBalancerTargetHealthStatusStatus + ListenPort int + Status LoadBalancerTargetHealthStatusStatus + Detail *LoadBalancerTargetHealthStatusDetail + HTTPStatusCode *int } // LoadBalancerProtection represents the protection level of a Load Balancer. @@ -378,6 +404,7 @@ Targets []LoadBalancerCreateOptsTarget Services []LoadBalancerCreateOptsService PublicInterface *bool + PublicNet *LoadBalancerCreateOptsPublicNet Network *Network } @@ -391,6 +418,13 @@ UsePrivateIP *bool } +// LoadBalancerCreateOptsPublicNet holds options for specifying the public network +// when creating a new Load Balancer. +type LoadBalancerCreateOptsPublicNet struct { + IPv4 *PrimaryIP + IPv6 *PrimaryIP +} + // LoadBalancerCreateOptsTargetServer holds options for specifying a server target // when creating a new Load Balancer. type LoadBalancerCreateOptsTargetServer struct { @@ -481,13 +515,35 @@ } // Delete deletes a Load Balancer. +// +// Deprecated: Use [LoadBalancerClient.DeleteWithResult] instead. func (c *LoadBalancerClient) Delete(ctx context.Context, loadBalancer *LoadBalancer) (*Response, error) { + _, resp, err := c.DeleteWithResult(ctx, loadBalancer) + return resp, err +} + +// LoadBalancerDeleteResult is the result of a delete [LoadBalancer] operation. +type LoadBalancerDeleteResult struct { + Action *Action +} + +// DeleteWithResult deletes a Load Balancer and returns an [Action]. +func (c *LoadBalancerClient) DeleteWithResult(ctx context.Context, loadBalancer *LoadBalancer) (LoadBalancerDeleteResult, *Response, error) { const opPath = "/load_balancers/%d" ctx = ctxutil.SetOpPath(ctx, opPath) reqPath := fmt.Sprintf(opPath, loadBalancer.ID) - return deleteRequestNoResult(ctx, c.client, reqPath) + result := LoadBalancerDeleteResult{} + + respBody, resp, err := deleteRequest[schema.ActionGetResponse](ctx, c.client, reqPath) + if err != nil { + return result, resp, err + } + + result.Action = ActionFromSchema(respBody.Action) + + return result, resp, nil } func (c *LoadBalancerClient) addTarget(ctx context.Context, loadBalancer *LoadBalancer, reqBody schema.LoadBalancerActionAddTargetRequest) (*Action, *Response, error) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema/load_balancer.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema/load_balancer.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema/load_balancer.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema/load_balancer.go 2026-10-05 16:28:07.000000000 +0200 @@ -27,13 +27,17 @@ } type LoadBalancerPublicNetIPv4 struct { - IP string `json:"ip"` - DNSPtr string `json:"dns_ptr"` + ID int64 `json:"id"` + IP string `json:"ip"` + Blocked bool `json:"blocked"` + DNSPtr string `json:"dns_ptr"` } type LoadBalancerPublicNetIPv6 struct { - IP string `json:"ip"` - DNSPtr string `json:"dns_ptr"` + ID int64 `json:"id"` + IP string `json:"ip"` + Blocked bool `json:"blocked"` + DNSPtr string `json:"dns_ptr"` } type LoadBalancerPrivateNet struct { @@ -95,8 +99,10 @@ } type LoadBalancerTargetHealthStatus struct { - ListenPort int `json:"listen_port"` - Status string `json:"status"` + ListenPort int `json:"listen_port"` + Status string `json:"status"` + Detail *string `json:"detail"` + HTTPStatusCode *int `json:"http_status_code"` } type LoadBalancerTargetServer struct { @@ -262,6 +268,7 @@ Targets []LoadBalancerCreateRequestTarget `json:"targets,omitempty"` Services []LoadBalancerCreateRequestService `json:"services,omitempty"` PublicInterface *bool `json:"public_interface,omitempty"` + PublicNet *LoadBalancerCreateRequestPublicNet `json:"public_net,omitempty"` Network *int64 `json:"network,omitempty"` } @@ -269,6 +276,11 @@ Type string `json:"type"` } +type LoadBalancerCreateRequestPublicNet struct { + IPv4 int64 `json:"ipv4,omitempty"` + IPv6 int64 `json:"ipv6,omitempty"` +} + type LoadBalancerCreateRequestTarget struct { Type string `json:"type"` Server *LoadBalancerCreateRequestTargetServer `json:"server,omitempty"` diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema_gen.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema_gen.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema_gen.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/schema_gen.go 2026-10-05 16:28:07.000000000 +0200 @@ -58,6 +58,7 @@ // goverter:extend int64FromZone // goverter:extend floatingIPFromInt64 // goverter:extend int64FromFloatingIP +// goverter:extend int64FromPrimaryIP // goverter:extend storageBoxFromInt64 // goverter:extend int64FromStorageBox // goverter:extend mapFromFloatingIPDNSPtrSchema @@ -641,6 +642,13 @@ if f == nil { return 0 } + return f.ID +} + +func int64FromPrimaryIP(f *PrimaryIP) int64 { + if f == nil { + return 0 + } return f.ID } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_load_balancer_client_iface.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_load_balancer_client_iface.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_load_balancer_client_iface.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_load_balancer_client_iface.go 2026-10-05 16:28:07.000000000 +0200 @@ -30,7 +30,11 @@ // Create creates a new Load Balancer. Create(ctx context.Context, opts LoadBalancerCreateOpts) (LoadBalancerCreateResult, *Response, error) // Delete deletes a Load Balancer. + // + // Deprecated: Use [LoadBalancerClient.DeleteWithResult] instead. Delete(ctx context.Context, loadBalancer *LoadBalancer) (*Response, error) + // DeleteWithResult deletes a Load Balancer and returns an [Action]. + DeleteWithResult(ctx context.Context, loadBalancer *LoadBalancer) (LoadBalancerDeleteResult, *Response, error) // AddServerTarget adds a server target to a Load Balancer. AddServerTarget(ctx context.Context, loadBalancer *LoadBalancer, opts LoadBalancerAddServerTargetOpts) (*Action, *Response, error) // RemoveServerTarget removes a server target from a Load Balancer. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_schema_converter.go new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_schema_converter.go --- old/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_schema_converter.go 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/github.com/hetznercloud/hcloud-go/v2/hcloud/zz_schema_converter.go 2026-10-05 16:28:07.000000000 +0200 @@ -254,6 +254,11 @@ var hcloudLoadBalancerTargetHealthStatus LoadBalancerTargetHealthStatus hcloudLoadBalancerTargetHealthStatus.ListenPort = source.ListenPort hcloudLoadBalancerTargetHealthStatus.Status = LoadBalancerTargetHealthStatusStatus(source.Status) + if source.Detail != nil { + hcloudLoadBalancerTargetHealthStatusDetail := LoadBalancerTargetHealthStatusDetail(*source.Detail) + hcloudLoadBalancerTargetHealthStatus.Detail = &hcloudLoadBalancerTargetHealthStatusDetail + } + hcloudLoadBalancerTargetHealthStatus.HTTPStatusCode = source.HTTPStatusCode return hcloudLoadBalancerTargetHealthStatus } func (c *converterImpl) LoadBalancerTargetServerFromSchema(source schema.LoadBalancerTargetServer) LoadBalancerTargetServer { @@ -697,6 +702,7 @@ } } schemaLoadBalancerCreateRequest.PublicInterface = source.PublicInterface + schemaLoadBalancerCreateRequest.PublicNet = c.pHcloudLoadBalancerCreateOptsPublicNetToPSchemaLoadBalancerCreateRequestPublicNet(source.PublicNet) schemaLoadBalancerCreateRequest.Network = c.pHcloudNetworkToPInt64(source.Network) return schemaLoadBalancerCreateRequest } @@ -761,6 +767,11 @@ var schemaLoadBalancerTargetHealthStatus schema.LoadBalancerTargetHealthStatus schemaLoadBalancerTargetHealthStatus.ListenPort = source.ListenPort schemaLoadBalancerTargetHealthStatus.Status = string(source.Status) + if source.Detail != nil { + xstring := string(*source.Detail) + schemaLoadBalancerTargetHealthStatus.Detail = &xstring + } + schemaLoadBalancerTargetHealthStatus.HTTPStatusCode = source.HTTPStatusCode return schemaLoadBalancerTargetHealthStatus } func (c *converterImpl) SchemaFromLoadBalancerType(source *LoadBalancerType) schema.LoadBalancerType { @@ -1883,13 +1894,17 @@ } func (c *converterImpl) hcloudLoadBalancerPublicNetIPv4ToSchemaLoadBalancerPublicNetIPv4(source LoadBalancerPublicNetIPv4) schema.LoadBalancerPublicNetIPv4 { var schemaLoadBalancerPublicNetIPv4 schema.LoadBalancerPublicNetIPv4 + schemaLoadBalancerPublicNetIPv4.ID = source.ID schemaLoadBalancerPublicNetIPv4.IP = stringFromIP(source.IP) + schemaLoadBalancerPublicNetIPv4.Blocked = source.Blocked schemaLoadBalancerPublicNetIPv4.DNSPtr = source.DNSPtr return schemaLoadBalancerPublicNetIPv4 } func (c *converterImpl) hcloudLoadBalancerPublicNetIPv6ToSchemaLoadBalancerPublicNetIPv6(source LoadBalancerPublicNetIPv6) schema.LoadBalancerPublicNetIPv6 { var schemaLoadBalancerPublicNetIPv6 schema.LoadBalancerPublicNetIPv6 + schemaLoadBalancerPublicNetIPv6.ID = source.ID schemaLoadBalancerPublicNetIPv6.IP = stringFromIP(source.IP) + schemaLoadBalancerPublicNetIPv6.Blocked = source.Blocked schemaLoadBalancerPublicNetIPv6.DNSPtr = source.DNSPtr return schemaLoadBalancerPublicNetIPv6 } @@ -2263,6 +2278,16 @@ } return pSchemaLoadBalancerCreateRequestAlgorithm } +func (c *converterImpl) pHcloudLoadBalancerCreateOptsPublicNetToPSchemaLoadBalancerCreateRequestPublicNet(source *LoadBalancerCreateOptsPublicNet) *schema.LoadBalancerCreateRequestPublicNet { + var pSchemaLoadBalancerCreateRequestPublicNet *schema.LoadBalancerCreateRequestPublicNet + if source != nil { + var schemaLoadBalancerCreateRequestPublicNet schema.LoadBalancerCreateRequestPublicNet + schemaLoadBalancerCreateRequestPublicNet.IPv4 = int64FromPrimaryIP((*source).IPv4) + schemaLoadBalancerCreateRequestPublicNet.IPv6 = int64FromPrimaryIP((*source).IPv6) + pSchemaLoadBalancerCreateRequestPublicNet = &schemaLoadBalancerCreateRequestPublicNet + } + return pSchemaLoadBalancerCreateRequestPublicNet +} func (c *converterImpl) pHcloudLoadBalancerCreateOptsServiceHTTPToPSchemaLoadBalancerCreateRequestServiceHTTP(source *LoadBalancerCreateOptsServiceHTTP) *schema.LoadBalancerCreateRequestServiceHTTP { var pSchemaLoadBalancerCreateRequestServiceHTTP *schema.LoadBalancerCreateRequestServiceHTTP if source != nil { @@ -2981,13 +3006,17 @@ } func (c *converterImpl) schemaLoadBalancerPublicNetIPv4ToHcloudLoadBalancerPublicNetIPv4(source schema.LoadBalancerPublicNetIPv4) LoadBalancerPublicNetIPv4 { var hcloudLoadBalancerPublicNetIPv4 LoadBalancerPublicNetIPv4 + hcloudLoadBalancerPublicNetIPv4.ID = source.ID hcloudLoadBalancerPublicNetIPv4.IP = ipFromString(source.IP) + hcloudLoadBalancerPublicNetIPv4.Blocked = source.Blocked hcloudLoadBalancerPublicNetIPv4.DNSPtr = source.DNSPtr return hcloudLoadBalancerPublicNetIPv4 } func (c *converterImpl) schemaLoadBalancerPublicNetIPv6ToHcloudLoadBalancerPublicNetIPv6(source schema.LoadBalancerPublicNetIPv6) LoadBalancerPublicNetIPv6 { var hcloudLoadBalancerPublicNetIPv6 LoadBalancerPublicNetIPv6 + hcloudLoadBalancerPublicNetIPv6.ID = source.ID hcloudLoadBalancerPublicNetIPv6.IP = ipFromString(source.IP) + hcloudLoadBalancerPublicNetIPv6.Blocked = source.Blocked hcloudLoadBalancerPublicNetIPv6.DNSPtr = source.DNSPtr return hcloudLoadBalancerPublicNetIPv6 } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/modules.txt new/vendor/modules.txt --- old/vendor/modules.txt 2026-09-24 16:48:58.000000000 +0200 +++ new/vendor/modules.txt 2026-10-05 16:28:07.000000000 +0200 @@ -56,7 +56,7 @@ # github.com/guptarohit/asciigraph v0.10.0 ## explicit; go 1.11 github.com/guptarohit/asciigraph -# github.com/hetznercloud/hcloud-go/v2 v2.49.0 +# github.com/hetznercloud/hcloud-go/v2 v2.52.0 ## explicit; go 1.25.0 github.com/hetznercloud/hcloud-go/v2/hcloud github.com/hetznercloud/hcloud-go/v2/hcloud/exp/actionutil
