Merge branch 'master' into issue11286

Author: nzhan126

Dockerfile.dapper

@@ -1,4 +1,4 @@
-FROM registry.suse.com/bci/golang:1.24
+FROM registry.suse.com/bci/golang:1.25
 
 ARG DAPPER_HOST_ARCH
 ARG http_proxy
@@ -18,6 +18,9 @@ WORKDIR ${DAPPER_SOURCE}
 ENTRYPOINT ["./scripts/entry"]
 CMD ["ci"]
 
+RUN zypper -n ref && \
+    zypper update -y
+
 RUN zypper -n install gcc ca-certificates git wget curl vim less file python3-tox python3-devel iptables libdevmapper1_03 libltdl7 awk docker zip unzip && \
     rm -rf /var/cache/zypp/*
 

api/model.go

@@ -69,21 +69,22 @@ func NewRouter(s *Server) *mux.Router {
 	r.Methods("DELETE").Path("/v1/volumes/{name}").Handler(f(schemas, s.VolumeDelete))
 	r.Methods("POST").Path("/v1/volumes").Handler(f(schemas, s.fwd.Handler(s.fwd.HandleProxyRequestByNodeID, s.fwd.GetHTTPAddressByNodeID(NodeHasDefaultEngineImage(s.m)), s.VolumeCreate)))
 	volumeActions := map[string]func(http.ResponseWriter, *http.Request) error{
-		"attach":                            s.VolumeAttach,
-		"detach":                            s.VolumeDetach,
-		"salvage":                           s.VolumeSalvage,
-		"updateDataLocality":                s.VolumeUpdateDataLocality,
-		"updateAccessMode":                  s.VolumeUpdateAccessMode,
-		"updateUnmapMarkSnapChainRemoved":   s.VolumeUpdateUnmapMarkSnapChainRemoved,
-		"updateSnapshotMaxCount":            s.VolumeUpdateSnapshotMaxCount,
-		"updateSnapshotMaxSize":             s.VolumeUpdateSnapshotMaxSize,
-		"updateReplicaSoftAntiAffinity":     s.VolumeUpdateReplicaSoftAntiAffinity,
-		"updateReplicaZoneSoftAntiAffinity": s.VolumeUpdateReplicaZoneSoftAntiAffinity,
-		"updateReplicaDiskSoftAntiAffinity": s.VolumeUpdateReplicaDiskSoftAntiAffinity,
-		"activate":                          s.VolumeActivate,
-		"expand":                            s.VolumeExpand,
-		"cancelExpansion":                   s.VolumeCancelExpansion,
-		"offlineReplicaRebuilding":          s.VolumeOfflineRebuilding,
+		"attach":                                s.VolumeAttach,
+		"detach":                                s.VolumeDetach,
+		"salvage":                               s.VolumeSalvage,
+		"updateDataLocality":                    s.VolumeUpdateDataLocality,
+		"updateAccessMode":                      s.VolumeUpdateAccessMode,
+		"updateUnmapMarkSnapChainRemoved":       s.VolumeUpdateUnmapMarkSnapChainRemoved,
+		"updateSnapshotMaxCount":                s.VolumeUpdateSnapshotMaxCount,
+		"updateSnapshotMaxSize":                 s.VolumeUpdateSnapshotMaxSize,
+		"updateReplicaRebuildingBandwidthLimit": s.VolumeUpdateReplicaRebuildingBandwidthLimit,
+		"updateReplicaSoftAntiAffinity":         s.VolumeUpdateReplicaSoftAntiAffinity,
+		"updateReplicaZoneSoftAntiAffinity":     s.VolumeUpdateReplicaZoneSoftAntiAffinity,
+		"updateReplicaDiskSoftAntiAffinity":     s.VolumeUpdateReplicaDiskSoftAntiAffinity,
+		"activate":                              s.VolumeActivate,
+		"expand":                                s.VolumeExpand,
+		"cancelExpansion":                       s.VolumeCancelExpansion,
+		"offlineReplicaRebuilding":              s.VolumeOfflineRebuilding,
 
 		"updateReplicaCount":                s.VolumeUpdateReplicaCount,
 		"updateReplicaAutoBalance":          s.VolumeUpdateReplicaAutoBalance,
@@ -291,5 +292,13 @@ func NewRouter(s *Server) *mux.Router {
 	r.Path("/v1/ws/events").Handler(f(schemas, eventListStream))
 	r.Path("/v1/ws/{period}/events").Handler(f(schemas, eventListStream))
 
+	// VolumeAttachment routes
+	r.Methods("GET").Path("/v1/volumeattachments").Handler(f(schemas, s.VolumeAttachmentList))
+	r.Methods("GET").Path("/v1/volumeattachments/{name}").Handler(f(schemas, s.VolumeAttachmentGet))
+
+	volumeAttachmentListStream := NewStreamHandlerFunc("volumeattachments", s.wsc.NewWatcher("volumeAttachment"), s.volumeAttachmentList)
+	r.Path("/v1/ws/volumeattachments").Handler(f(schemas, volumeAttachmentListStream))
+	r.Path("/v1/ws/{period}/volumeattachments").Handler(f(schemas, volumeAttachmentListStream))
+
 	return r
 }

api/router.go

@@ -172,36 +172,44 @@ func (s *Server) VolumeCreate(rw http.ResponseWriter, req *http.Request) error {
 		return errors.Wrap(err, "failed to parse snapshot max size")
 	}
 
+	backupBlockSize, err := util.ConvertSize(volume.BackupBlockSize)
+	if err != nil {
+		return errors.Wrapf(err, "failed to parse backup block size %v", volume.BackupBlockSize)
+	}
+
 	v, err := s.m.Create(volume.Name, &longhorn.VolumeSpec{
-		Size:                        size,
-		AccessMode:                  volume.AccessMode,
-		Migratable:                  volume.Migratable,
-		Encrypted:                   volume.Encrypted,
-		Frontend:                    volume.Frontend,
-		FromBackup:                  volume.FromBackup,
-		RestoreVolumeRecurringJob:   volume.RestoreVolumeRecurringJob,
-		DataSource:                  volume.DataSource,
-		NumberOfReplicas:            volume.NumberOfReplicas,
-		ReplicaAutoBalance:          volume.ReplicaAutoBalance,
-		DataLocality:                volume.DataLocality,
-		StaleReplicaTimeout:         volume.StaleReplicaTimeout,
-		BackingImage:                volume.BackingImage,
-		Standby:                     volume.Standby,
-		RevisionCounterDisabled:     volume.RevisionCounterDisabled,
-		DiskSelector:                volume.DiskSelector,
-		NodeSelector:                volume.NodeSelector,
-		SnapshotDataIntegrity:       volume.SnapshotDataIntegrity,
-		SnapshotMaxCount:            volume.SnapshotMaxCount,
-		SnapshotMaxSize:             snapshotMaxSize,
-		BackupCompressionMethod:     volume.BackupCompressionMethod,
-		UnmapMarkSnapChainRemoved:   volume.UnmapMarkSnapChainRemoved,
-		ReplicaSoftAntiAffinity:     volume.ReplicaSoftAntiAffinity,
-		ReplicaZoneSoftAntiAffinity: volume.ReplicaZoneSoftAntiAffinity,
-		ReplicaDiskSoftAntiAffinity: volume.ReplicaDiskSoftAntiAffinity,
-		DataEngine:                  volume.DataEngine,
-		FreezeFilesystemForSnapshot: volume.FreezeFilesystemForSnapshot,
-		BackupTargetName:            volume.BackupTargetName,
-		OfflineRebuilding:           volume.OfflineRebuilding,
+		Size:                            size,
+		AccessMode:                      volume.AccessMode,
+		Migratable:                      volume.Migratable,
+		Encrypted:                       volume.Encrypted,
+		Frontend:                        volume.Frontend,
+		FromBackup:                      volume.FromBackup,
+		RestoreVolumeRecurringJob:       volume.RestoreVolumeRecurringJob,
+		DataSource:                      volume.DataSource,
+		CloneMode:                       volume.CloneMode,
+		NumberOfReplicas:                volume.NumberOfReplicas,
+		ReplicaAutoBalance:              volume.ReplicaAutoBalance,
+		DataLocality:                    volume.DataLocality,
+		StaleReplicaTimeout:             volume.StaleReplicaTimeout,
+		BackingImage:                    volume.BackingImage,
+		Standby:                         volume.Standby,
+		RevisionCounterDisabled:         volume.RevisionCounterDisabled,
+		DiskSelector:                    volume.DiskSelector,
+		NodeSelector:                    volume.NodeSelector,
+		SnapshotDataIntegrity:           volume.SnapshotDataIntegrity,
+		SnapshotMaxCount:                volume.SnapshotMaxCount,
+		SnapshotMaxSize:                 snapshotMaxSize,
+		ReplicaRebuildingBandwidthLimit: volume.ReplicaRebuildingBandwidthLimit,
+		BackupCompressionMethod:         volume.BackupCompressionMethod,
+		BackupBlockSize:                 backupBlockSize,
+		UnmapMarkSnapChainRemoved:       volume.UnmapMarkSnapChainRemoved,
+		ReplicaSoftAntiAffinity:         volume.ReplicaSoftAntiAffinity,
+		ReplicaZoneSoftAntiAffinity:     volume.ReplicaZoneSoftAntiAffinity,
+		ReplicaDiskSoftAntiAffinity:     volume.ReplicaDiskSoftAntiAffinity,
+		DataEngine:                      volume.DataEngine,
+		FreezeFilesystemForSnapshot:     volume.FreezeFilesystemForSnapshot,
+		BackupTargetName:                volume.BackupTargetName,
+		OfflineRebuilding:               volume.OfflineRebuilding,
 	}, volume.RecurringJobSelector)
 	if err != nil {
 		return errors.Wrap(err, "failed to create volume")
@@ -839,6 +847,33 @@ func (s *Server) VolumeUpdateSnapshotMaxSize(rw http.ResponseWriter, req *http.R
 	return s.responseWithVolume(rw, req, "", v)
 }
 
+func (s *Server) VolumeUpdateReplicaRebuildingBandwidthLimit(rw http.ResponseWriter, req *http.Request) error {
+	var input UpdateReplicaRebuildingBandwidthLimit
+	id := mux.Vars(req)["name"]
+
+	apiContext := api.GetApiContext(req)
+	if err := apiContext.Read(&input); err != nil {
+		return errors.Wrap(err, "failed to read ReplicaRebuildingBandwidthLimit input")
+	}
+
+	replicaRebuildingBandwidthLimit, err := util.ConvertSize(input.ReplicaRebuildingBandwidthLimit)
+	if err != nil {
+		return fmt.Errorf("failed to parse replica rebuilding bandwidth limit %v", err)
+	}
+
+	obj, err := util.RetryOnConflictCause(func() (interface{}, error) {
+		return s.m.UpdateReplicaRebuildingBandwidthLimit(id, replicaRebuildingBandwidthLimit)
+	})
+	if err != nil {
+		return err
+	}
+	v, ok := obj.(*longhorn.Volume)
+	if !ok {
+		return fmt.Errorf("failed to convert to volume %v object", id)
+	}
+	return s.responseWithVolume(rw, req, "", v)
+}
+
 func (s *Server) VolumeUpdateFreezeFilesystemForSnapshot(rw http.ResponseWriter, req *http.Request) error {
 	var input UpdateFreezeFilesystemForSnapshotInput
 	id := mux.Vars(req)["name"]

api/volume.go

@@ -0,0 +1,43 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/pkg/errors"
+
+	"github.com/rancher/go-rancher/api"
+	"github.com/rancher/go-rancher/client"
+)
+
+func (s *Server) VolumeAttachmentGet(rw http.ResponseWriter, req *http.Request) error {
+	apiContext := api.GetApiContext(req)
+
+	id := mux.Vars(req)["name"]
+
+	volumeAttachment, err := s.m.GetVolumeAttachment(id)
+	if err != nil {
+		return errors.Wrapf(err, "failed to get volume attachment  '%s'", id)
+	}
+	apiContext.Write(toVolumeAttachmentResource(volumeAttachment))
+	return nil
+}
+
+func (s *Server) VolumeAttachmentList(rw http.ResponseWriter, req *http.Request) (err error) {
+	apiContext := api.GetApiContext(req)
+
+	volumeAttachmentList, err := s.m.ListVolumeAttachment()
+	if err != nil {
+		return errors.Wrap(err, "failed to list volume attachments")
+	}
+	apiContext.Write(toVolumeAttachmentCollection(volumeAttachmentList, apiContext))
+	return nil
+}
+
+func (s *Server) volumeAttachmentList(apiContext *api.ApiContext) (*client.GenericCollection, error) {
+	volumeAttachmentList, err := s.m.ListVolumeAttachment()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to list volume attachments")
+	}
+	return toVolumeAttachmentCollection(volumeAttachmentList, apiContext), nil
+}

api/volumeattachment.go

@@ -182,7 +182,7 @@ func startWebhooksByLeaderElection(ctx context.Context, kubeconfigPath, currentN
 			if err != nil {
 				return err
 			}
-			if err := webhook.CheckWebhookServiceAvailability(types.WebhookTypeConversion); err != nil {
+			if err := webhook.CheckWebhookServiceAvailability(types.WebhookTypeConversion, clientsWithoutDatastore); err != nil {
 				return err
 			}
 		}
@@ -200,7 +200,7 @@ func startWebhooksByLeaderElection(ctx context.Context, kubeconfigPath, currentN
 			return err
 		}
 
-		if err := webhook.CheckWebhookServiceAvailability(types.WebhookTypeAdmission); err != nil {
+		if err := webhook.CheckWebhookServiceAvailability(types.WebhookTypeAdmission, clients); err != nil {
 			return err
 		}
 

app/daemon.go

@@ -7,8 +7,12 @@ const (
 type Backup struct {
 	Resource `yaml:"-"`
 
+	BackupMode string `json:"backupMode,omitempty" yaml:"backup_mode,omitempty"`
+
 	BackupTargetName string `json:"backupTargetName,omitempty" yaml:"backup_target_name,omitempty"`
 
+	BlockSize string `json:"blockSize,omitempty" yaml:"block_size,omitempty"`
+
 	CompressionMethod string `json:"compressionMethod,omitempty" yaml:"compression_method,omitempty"`
 
 	Created string `json:"created,omitempty" yaml:"created,omitempty"`
@@ -21,8 +25,12 @@ type Backup struct {
 
 	Name string `json:"name,omitempty" yaml:"name,omitempty"`
 
+	NewlyUploadDataSize string `json:"newlyUploadDataSize,omitempty" yaml:"newly_upload_data_size,omitempty"`
+
 	Progress int64 `json:"progress,omitempty" yaml:"progress,omitempty"`
 
+	ReUploadedDataSize string `json:"reUploadedDataSize,omitempty" yaml:"re_uploaded_data_size,omitempty"`
+
 	Size string `json:"size,omitempty" yaml:"size,omitempty"`
 
 	SnapshotCreated string `json:"snapshotCreated,omitempty" yaml:"snapshot_created,omitempty"`

client/generated_backup.go

@@ -7,6 +7,10 @@ const (
 type BackupBackingImage struct {
 	Resource `yaml:"-"`
 
+	BackingImageName string `json:"backingImageName,omitempty" yaml:"backing_image_name,omitempty"`
+
+	BackupTargetName string `json:"backupTargetName,omitempty" yaml:"backup_target_name,omitempty"`
+
 	CompressionMethod string `json:"compressionMethod,omitempty" yaml:"compression_method,omitempty"`
 
 	Created string `json:"created,omitempty" yaml:"created,omitempty"`
@@ -23,7 +27,7 @@ type BackupBackingImage struct {
 
 	Secret string `json:"secret,omitempty" yaml:"secret,omitempty"`
 
-	SecretNamespace string `json:"secretNamespace,omitempty" yaml:"secretNamespace,omitempty"`
+	SecretNamespace string `json:"secretNamespace,omitempty" yaml:"secret_namespace,omitempty"`
 
 	Size int64 `json:"size,omitempty" yaml:"size,omitempty"`
 

client/generated_backup_backing_image.go

@@ -36,6 +36,10 @@ type BackupTargetOperations interface {
 	Update(existing *BackupTarget, updates interface{}) (*BackupTarget, error)
 	ById(id string) (*BackupTarget, error)
 	Delete(container *BackupTarget) error
+
+	ActionBackupTargetSync(*BackupTarget, *SyncBackupResource) (*BackupTargetListOutput, error)
+
+	ActionBackupTargetUpdate(*BackupTarget, *BackupTarget) (*BackupTargetListOutput, error)
 }
 
 func newBackupTargetClient(rancherClient *RancherClient) *BackupTargetClient {
@@ -87,3 +91,21 @@ func (c *BackupTargetClient) ById(id string) (*BackupTarget, error) {
 func (c *BackupTargetClient) Delete(container *BackupTarget) error {
 	return c.rancherClient.doResourceDelete(BACKUP_TARGET_TYPE, &container.Resource)
 }
+
+func (c *BackupTargetClient) ActionBackupTargetSync(resource *BackupTarget, input *SyncBackupResource) (*BackupTargetListOutput, error) {
+
+	resp := &BackupTargetListOutput{}
+
+	err := c.rancherClient.doAction(BACKUP_TARGET_TYPE, "backupTargetSync", &resource.Resource, input, resp)
+
+	return resp, err
+}
+
+func (c *BackupTargetClient) ActionBackupTargetUpdate(resource *BackupTarget, input *BackupTarget) (*BackupTargetListOutput, error) {
+
+	resp := &BackupTargetListOutput{}
+
+	err := c.rancherClient.doAction(BACKUP_TARGET_TYPE, "backupTargetUpdate", &resource.Resource, input, resp)
+
+	return resp, err
+}

client/generated_backup_target.go

@@ -0,0 +1,79 @@
+package client
+
+const (
+	BACKUP_TARGET_LIST_OUTPUT_TYPE = "backupTargetListOutput"
+)
+
+type BackupTargetListOutput struct {
+	Resource `yaml:"-"`
+
+	Data []BackupTarget `json:"data,omitempty" yaml:"data,omitempty"`
+}
+
+type BackupTargetListOutputCollection struct {
+	Collection
+	Data   []BackupTargetListOutput `json:"data,omitempty"`
+	client *BackupTargetListOutputClient
+}
+
+type BackupTargetListOutputClient struct {
+	rancherClient *RancherClient
+}
+
+type BackupTargetListOutputOperations interface {
+	List(opts *ListOpts) (*BackupTargetListOutputCollection, error)
+	Create(opts *BackupTargetListOutput) (*BackupTargetListOutput, error)
+	Update(existing *BackupTargetListOutput, updates interface{}) (*BackupTargetListOutput, error)
+	ById(id string) (*BackupTargetListOutput, error)
+	Delete(container *BackupTargetListOutput) error
+}
+
+func newBackupTargetListOutputClient(rancherClient *RancherClient) *BackupTargetListOutputClient {
+	return &BackupTargetListOutputClient{
+		rancherClient: rancherClient,
+	}
+}
+
+func (c *BackupTargetListOutputClient) Create(container *BackupTargetListOutput) (*BackupTargetListOutput, error) {
+	resp := &BackupTargetListOutput{}
+	err := c.rancherClient.doCreate(BACKUP_TARGET_LIST_OUTPUT_TYPE, container, resp)
+	return resp, err
+}
+
+func (c *BackupTargetListOutputClient) Update(existing *BackupTargetListOutput, updates interface{}) (*BackupTargetListOutput, error) {
+	resp := &BackupTargetListOutput{}
+	err := c.rancherClient.doUpdate(BACKUP_TARGET_LIST_OUTPUT_TYPE, &existing.Resource, updates, resp)
+	return resp, err
+}
+
+func (c *BackupTargetListOutputClient) List(opts *ListOpts) (*BackupTargetListOutputCollection, error) {
+	resp := &BackupTargetListOutputCollection{}
+	err := c.rancherClient.doList(BACKUP_TARGET_LIST_OUTPUT_TYPE, opts, resp)
+	resp.client = c
+	return resp, err
+}
+
+func (cc *BackupTargetListOutputCollection) Next() (*BackupTargetListOutputCollection, error) {
+	if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
+		resp := &BackupTargetListOutputCollection{}
+		err := cc.client.rancherClient.doNext(cc.Pagination.Next, resp)
+		resp.client = cc.client
+		return resp, err
+	}
+	return nil, nil
+}
+
+func (c *BackupTargetListOutputClient) ById(id string) (*BackupTargetListOutput, error) {
+	resp := &BackupTargetListOutput{}
+	err := c.rancherClient.doById(BACKUP_TARGET_LIST_OUTPUT_TYPE, id, resp)
+	if apiError, ok := err.(*ApiError); ok {
+		if apiError.StatusCode == 404 {
+			return nil, nil
+		}
+	}
+	return resp, err
+}
+
+func (c *BackupTargetListOutputClient) Delete(container *BackupTargetListOutput) error {
+	return c.rancherClient.doResourceDelete(BACKUP_TARGET_LIST_OUTPUT_TYPE, &container.Resource)
+}