Dragonfly2

1
/*
2
 *     Copyright 2020 The Dragonfly Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package service
18

19
import (
20
	"context"
21
	"errors"
22

23
	"d7y.io/dragonfly/v2/manager/models"
24
	"d7y.io/dragonfly/v2/manager/types"
25
	"d7y.io/dragonfly/v2/pkg/structure"
26
)
27

28
func (s *service) CreateSchedulerCluster(ctx context.Context, json types.CreateSchedulerClusterRequest) (*models.SchedulerCluster, error) {
29
	config, err := structure.StructToMap(json.Config)
30
	if err != nil {
31
		return nil, err
32
	}
33

34
	clientConfig, err := structure.StructToMap(json.ClientConfig)
35
	if err != nil {
36
		return nil, err
37
	}
38

39
	scopes, err := structure.StructToMap(json.Scopes)
40
	if err != nil {
41
		return nil, err
42
	}
43

44
	schedulerCluster := models.SchedulerCluster{
45
		Name:         json.Name,
46
		BIO:          json.BIO,
47
		Config:       config,
48
		ClientConfig: clientConfig,
49
		Scopes:       scopes,
50
		IsDefault:    json.IsDefault,
51
	}
52

53
	if err := s.db.WithContext(ctx).Create(&schedulerCluster).Error; err != nil {
54
		return nil, err
55
	}
56

57
	if json.SeedPeerClusterID > 0 {
58
		if err := s.AddSchedulerClusterToSeedPeerCluster(ctx, json.SeedPeerClusterID, schedulerCluster.ID); err != nil {
59
			return nil, err
60
		}
61
	}
62

63
	return &schedulerCluster, nil
64
}
65

66
func (s *service) DestroySchedulerCluster(ctx context.Context, id uint) error {
67
	schedulerCluster := models.SchedulerCluster{}
68
	if err := s.db.WithContext(ctx).Preload("Schedulers").First(&schedulerCluster, id).Error; err != nil {
69
		return err
70
	}
71

72
	if len(schedulerCluster.Schedulers) != 0 {
73
		return errors.New("scheduler cluster exists scheduler")
74
	}
75

76
	if err := s.db.WithContext(ctx).Unscoped().Delete(&models.SchedulerCluster{}, id).Error; err != nil {
77
		return err
78
	}
79

80
	return nil
81
}
82

83
func (s *service) UpdateSchedulerCluster(ctx context.Context, id uint, json types.UpdateSchedulerClusterRequest) (*models.SchedulerCluster, error) {
84
	var (
85
		config map[string]any
86
		err    error
87
	)
88
	if json.Config != nil {
89
		config, err = structure.StructToMap(json.Config)
90
		if err != nil {
91
			return nil, err
92
		}
93
	}
94

95
	var clientConfig map[string]any
96
	if json.ClientConfig != nil {
97
		clientConfig, err = structure.StructToMap(json.ClientConfig)
98
		if err != nil {
99
			return nil, err
100
		}
101
	}
102

103
	var scopes map[string]any
104
	if json.Scopes != nil {
105
		scopes, err = structure.StructToMap(json.Scopes)
106
		if err != nil {
107
			return nil, err
108
		}
109
	}
110

111
	schedulerCluster := models.SchedulerCluster{}
112
	if err := s.db.WithContext(ctx).First(&schedulerCluster, id).Updates(models.SchedulerCluster{
113
		Name:         json.Name,
114
		BIO:          json.BIO,
115
		Config:       config,
116
		ClientConfig: clientConfig,
117
		Scopes:       scopes,
118
	}).Error; err != nil {
119
		return nil, err
120
	}
121

122
	// Updates does not accept bool as false.
123
	// Refer to https://stackoverflow.com/questions/56653423/gorm-doesnt-update-boolean-field-to-false.
124
	if json.IsDefault != schedulerCluster.IsDefault {
125
		if err := s.db.WithContext(ctx).First(&schedulerCluster, id).Update("is_default", json.IsDefault).Error; err != nil {
126
			return nil, err
127
		}
128
	}
129

130
	if json.SeedPeerClusterID > 0 {
131
		if err := s.AddSchedulerClusterToSeedPeerCluster(ctx, json.SeedPeerClusterID, schedulerCluster.ID); err != nil {
132
			return nil, err
133
		}
134
	}
135

136
	return &schedulerCluster, nil
137
}
138

139
func (s *service) GetSchedulerCluster(ctx context.Context, id uint) (*models.SchedulerCluster, error) {
140
	schedulerCluster := models.SchedulerCluster{}
141
	if err := s.db.WithContext(ctx).Preload("SeedPeerClusters").First(&schedulerCluster, id).Error; err != nil {
142
		return nil, err
143
	}
144

145
	return &schedulerCluster, nil
146
}
147

148
func (s *service) GetSchedulerClusters(ctx context.Context, q types.GetSchedulerClustersQuery) ([]models.SchedulerCluster, int64, error) {
149
	var count int64
150
	var schedulerClusters []models.SchedulerCluster
151
	if err := s.db.WithContext(ctx).Scopes(models.Paginate(q.Page, q.PerPage)).Where(&models.SchedulerCluster{
152
		Name: q.Name,
153
	}).Preload("SeedPeerClusters").Find(&schedulerClusters).Limit(-1).Offset(-1).Count(&count).Error; err != nil {
154
		return nil, 0, err
155
	}
156

157
	return schedulerClusters, count, nil
158
}
159

160
func (s *service) AddSchedulerToSchedulerCluster(ctx context.Context, id, schedulerID uint) error {
161
	schedulerCluster := models.SchedulerCluster{}
162
	if err := s.db.WithContext(ctx).First(&schedulerCluster, id).Error; err != nil {
163
		return err
164
	}
165

166
	scheduler := models.Scheduler{}
167
	if err := s.db.WithContext(ctx).First(&scheduler, schedulerID).Error; err != nil {
168
		return err
169
	}
170

171
	if err := s.db.WithContext(ctx).Model(&schedulerCluster).Association("Schedulers").Append(&scheduler); err != nil {
172
		return err
173
	}
174

175
	return nil
176
}
177