Skip to content

Commit

Permalink
Merge branch 'master' into issue-5023
Browse files Browse the repository at this point in the history
  • Loading branch information
innobead committed Dec 8, 2022
2 parents 2d33f0a + 5a07e68 commit 729e9c3
Show file tree
Hide file tree
Showing 125 changed files with 16,266 additions and 87 deletions.
2 changes: 1 addition & 1 deletion Dockerfile.dapper
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@ ARG http_proxy
ARG https_proxy
ENV HOST_ARCH=${DAPPER_HOST_ARCH} ARCH=${DAPPER_HOST_ARCH}

RUN zypper -n install gcc ca-certificates git wget curl vim less file python3-tox python3-devel iptables libdevmapper1_03 libltdl7 awk docker && \
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 -f /bin/sh && ln -s /bin/bash /bin/sh && \
rm -rf /var/cache/zypp/*

Expand Down
116 changes: 116 additions & 0 deletions api/model.go
Original file line number Diff line number Diff line change
Expand Up @@ -321,6 +321,34 @@ type SupportBundleInitateInput struct {
Description string `json:"description"`
}

type SystemBackup struct {
client.Resource
Name string `json:"name"`
Version string `json:"version,omitempty"`
ManagerImage string `json:"managerImage,omitempty"`
State longhorn.SystemBackupState `json:"state,omitempty"`
CreatedAt string `json:"createdAt,omitempty"`
Error string `json:"error,omitempty"`
}

type SystemBackupInput struct {
Name string `json:"name"`
}

type SystemRestore struct {
client.Resource
Name string `json:"name"`
SystemBackup string `json:"systemBackup"`
State longhorn.SystemRestoreState `json:"state,omitempty"`
CreatedAt string `json:"createdAt,omitempty"`
Error string `json:"error,omitempty"`
}

type SystemRestoreInput struct {
Name string `json:"name"`
SystemBackup string `json:"systemBackup"`
}

type Tag struct {
client.Resource
Name string `json:"name"`
Expand Down Expand Up @@ -481,6 +509,8 @@ func NewSchema() *client.Schemas {
kubernetesStatusSchema(schemas.AddType("kubernetesStatus", longhorn.KubernetesStatus{}))
backupListOutputSchema(schemas.AddType("backupListOutput", BackupListOutput{}))
snapshotListOutputSchema(schemas.AddType("snapshotListOutput", SnapshotListOutput{}))
systemBackupSchema(schemas.AddType("systemBackup", SystemBackup{}))
systemRestoreSchema(schemas.AddType("systemRestore", SystemRestore{}))

return schemas
}
Expand Down Expand Up @@ -935,6 +965,33 @@ func snapshotListOutputSchema(snapshotList *client.Schema) {
snapshotList.ResourceFields["data"] = data
}

func systemBackupSchema(systemBackup *client.Schema) {
systemBackup.CollectionMethods = []string{"GET", "POST"}
systemBackup.ResourceMethods = []string{"GET", "DELETE"}

name := systemBackup.ResourceFields["name"]
name.Required = true
name.Unique = true
name.Create = true
systemBackup.ResourceFields["name"] = name
}

func systemRestoreSchema(systemRestore *client.Schema) {
systemRestore.CollectionMethods = []string{"GET", "POST"}
systemRestore.ResourceMethods = []string{"GET", "DELETE"}

name := systemRestore.ResourceFields["name"]
name.Required = true
name.Unique = true
name.Create = true
systemRestore.ResourceFields["name"] = name

systemBackup := systemRestore.ResourceFields["systemBackup"]
systemBackup.Required = true
systemBackup.Unique = true
systemRestore.ResourceFields["systemBackup"] = systemBackup
}

func toSettingResource(setting *longhorn.Setting) *Setting {
definition, _ := types.GetSettingDefinition(types.SettingName(setting.Name))

Expand Down Expand Up @@ -1596,6 +1653,65 @@ func toSupportBundleResource(nodeID string, supportBundle *manager.SupportBundle
}
}

func toSystemBackupCollection(systemBackups []*longhorn.SystemBackup) *client.GenericCollection {
data := []interface{}{}
for _, systemBackup := range systemBackups {
data = append(data, toSystemBackupResource(systemBackup))
}
return &client.GenericCollection{Data: data, Collection: client.Collection{ResourceType: "systemBackup"}}
}

func toSystemBackupResource(systemBackup *longhorn.SystemBackup) *SystemBackup {
err := ""
if systemBackup.Status.State == longhorn.SystemBackupStateError {
errCondition := types.GetCondition(systemBackup.Status.Conditions, longhorn.SystemBackupConditionTypeError)
if errCondition.Status == longhorn.ConditionStatusTrue {
err = fmt.Sprintf("%v: %v", errCondition.Reason, errCondition.Message)
}
}
return &SystemBackup{
Resource: client.Resource{
Id: systemBackup.Name,
Type: "systemBackup",
},
Name: systemBackup.Name,
Version: systemBackup.Status.Version,
ManagerImage: systemBackup.Status.ManagerImage,
State: systemBackup.Status.State,
CreatedAt: systemBackup.Status.CreatedAt.String(),
Error: err,
}
}

func toSystemRestoreCollection(systemRestores []*longhorn.SystemRestore) *client.GenericCollection {
data := []interface{}{}
for _, systemRestore := range systemRestores {
data = append(data, toSystemRestoreResource(systemRestore))
}
return &client.GenericCollection{Data: data, Collection: client.Collection{ResourceType: "systemRestore"}}
}

func toSystemRestoreResource(systemRestore *longhorn.SystemRestore) *SystemRestore {
err := ""
if systemRestore.Status.State == longhorn.SystemRestoreStateError {
errCondition := types.GetCondition(systemRestore.Status.Conditions, longhorn.SystemRestoreConditionTypeError)
if errCondition.Status == longhorn.ConditionStatusTrue {
err = fmt.Sprintf("%v: %v", errCondition.Reason, errCondition.Message)
}
}
return &SystemRestore{
Resource: client.Resource{
Id: systemRestore.Name,
Type: "systemRestore",
},
Name: systemRestore.Name,
SystemBackup: systemRestore.Spec.SystemBackup,
State: systemRestore.Status.State,
CreatedAt: systemRestore.CreationTimestamp.String(),
Error: err,
}
}

func toTagResource(tag string, tagType string, apiContext *api.ApiContext) *Tag {
t := &Tag{
Resource: client.Resource{
Expand Down
18 changes: 18 additions & 0 deletions api/router.go
Original file line number Diff line number Diff line change
Expand Up @@ -173,6 +173,16 @@ func NewRouter(s *Server) *mux.Router {
r.Methods("DELETE").Path("/v1/supportbundles/{name}/{bundleName}").Handler(f(schemas,
s.fwd.Handler(s.fwd.HandleProxyRequestByNodeID, s.fwd.GetHTTPAddressByNodeID(OwnerIDFromNode(s.m)), s.SupportBundleDelete)))

r.Methods("POST").Path("/v1/systembackups").Handler(f(schemas, s.SystemBackupCreate))
r.Methods("GET").Path("/v1/systembackups").Handler(f(schemas, s.SystemBackupList))
r.Methods("GET").Path("/v1/systembackups/{name}").Handler(f(schemas, s.SystemBackupGet))
r.Methods("DELETE").Path("/v1/systembackups/{name}").Handler(f(schemas, s.SystemBackupDelete))

r.Methods("POST").Path("/v1/systemrestores").Handler(f(schemas, s.SystemRestoreCreate))
r.Methods("GET").Path("/v1/systemrestores").Handler(f(schemas, s.SystemRestoreList))
r.Methods("GET").Path("/v1/systemrestores/{name}").Handler(f(schemas, s.SystemRestoreGet))
r.Methods("DELETE").Path("/v1/systemrestores/{name}").Handler(f(schemas, s.SystemRestoreDelete))

settingListStream := NewStreamHandlerFunc("settings", s.wsc.NewWatcher("setting"), s.settingList)
r.Path("/v1/ws/settings").Handler(f(schemas, settingListStream))
r.Path("/v1/ws/{period}/settings").Handler(f(schemas, settingListStream))
Expand Down Expand Up @@ -217,6 +227,14 @@ func NewRouter(s *Server) *mux.Router {
r.Path("/v1/ws/backups").Handler(f(schemas, backupStream))
r.Path("/v1/ws/{period}/backups").Handler(f(schemas, backupStream))

systemBackupStream := NewStreamHandlerFunc("systembackups", s.wsc.NewWatcher("systemBackup"), s.systemBackupList)
r.Path("/v1/ws/systembackups").Handler(f(schemas, systemBackupStream))
r.Path("/v1/ws/{period}/systembackups").Handler(f(schemas, systemBackupStream))

systemRestoreStream := NewStreamHandlerFunc("systemrestores", s.wsc.NewWatcher("systemRestore"), s.systemRestoreList)
r.Path("/v1/ws/systemrestores").Handler(f(schemas, systemRestoreStream))
r.Path("/v1/ws/{period}/systemrestores").Handler(f(schemas, systemRestoreStream))

eventListStream := NewStreamHandlerFunc("events", s.wsc.NewWatcher("event"), s.eventList)
r.Path("/v1/ws/events").Handler(f(schemas, eventListStream))
r.Path("/v1/ws/{period}/events").Handler(f(schemas, eventListStream))
Expand Down
71 changes: 71 additions & 0 deletions api/systembackup.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,71 @@
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) SystemBackupCreate(w http.ResponseWriter, req *http.Request) error {
var input SystemBackupInput
var err error

apiContext := api.GetApiContext(req)
if err := apiContext.Read(&input); err != nil {
return err
}

systemBackup, err := s.m.CreateSystemBackup(input.Name)
if err != nil {
return errors.Wrapf(err, "failed to create SystemBackup")
}

apiContext.Write(toSystemBackupResource(systemBackup))
return nil
}

func (s *Server) SystemBackupDelete(w http.ResponseWriter, req *http.Request) error {
name := mux.Vars(req)["name"]

err := s.m.DeleteSystemBackup(name)
if err != nil {
return errors.Wrap(err, "failed to delete SystemBackup")
}
return nil
}

func (s *Server) SystemBackupGet(rw http.ResponseWriter, req *http.Request) error {
apiContext := api.GetApiContext(req)

name := mux.Vars(req)["name"]

systemBackup, err := s.m.GetSystemBackup(name)
if err != nil {
return errors.Wrapf(err, "error get SystemBackup '%s'", name)
}
apiContext.Write(toSystemBackupResource(systemBackup))
return nil
}

func (s *Server) SystemBackupList(w http.ResponseWriter, req *http.Request) error {
systemBackups, err := s.m.ListSystemBackupsSorted()
if err != nil {
return errors.Wrapf(err, "failed to list SystemBackups")
}

apiContext := api.GetApiContext(req)
apiContext.Write(toSystemBackupCollection(systemBackups))
return nil
}

func (s *Server) systemBackupList(apiContext *api.ApiContext) (*client.GenericCollection, error) {
systemBackups, err := s.m.ListSystemBackupsSorted()
if err != nil {
return nil, errors.Wrapf(err, "failed to list SystemBackups")
}
return toSystemBackupCollection(systemBackups), nil
}
69 changes: 69 additions & 0 deletions api/systemrestore.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,69 @@
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) SystemRestoreCreate(w http.ResponseWriter, req *http.Request) error {
var input SystemRestoreInput
var err error

apiContext := api.GetApiContext(req)
if err := apiContext.Read(&input); err != nil {
return err
}

systemRestore, err := s.m.CreateSystemRestore(input.Name, input.SystemBackup)
if err != nil {
return errors.Wrapf(err, "failed to create SystemRestore %v", input.Name)
}

apiContext.Write(toSystemRestoreResource(systemRestore))
return nil
}

func (s *Server) SystemRestoreDelete(w http.ResponseWriter, req *http.Request) error {
name := mux.Vars(req)["name"]

err := s.m.DeleteSystemRestore(name)
if err != nil {
return errors.Wrapf(err, "failed to delete SystemRestore %v", name)
}
return nil
}

func (s *Server) SystemRestoreGet(rw http.ResponseWriter, req *http.Request) error {
name := mux.Vars(req)["name"]
systemRestore, err := s.m.GetSystemRestore(name)
if err != nil {
return errors.Wrapf(err, "error get SystemRestore '%s'", name)
}

apiContext := api.GetApiContext(req)
apiContext.Write(toSystemRestoreResource(systemRestore))
return nil
}

func (s *Server) SystemRestoreList(w http.ResponseWriter, req *http.Request) error {
systemRestores, err := s.m.ListSystemRestoresSorted()
if err != nil {
return errors.Wrap(err, "failed to list SystemRestores")
}

apiContext := api.GetApiContext(req)
apiContext.Write(toSystemRestoreCollection(systemRestores))
return nil
}

func (s *Server) systemRestoreList(apiContext *api.ApiContext) (*client.GenericCollection, error) {
systemRestores, err := s.m.ListSystemRestoresSorted()
if err != nil {
return nil, errors.Wrap(err, "failed to list SystemRestores")
}
return toSystemRestoreCollection(systemRestores), nil
}

0 comments on commit 729e9c3

Please sign in to comment.