github.com/sacloud/iaas-api-go@v1.12.0/internal/define/database.go (about)

     1  // Copyright 2022-2023 The sacloud/iaas-api-go Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package define
    16  
    17  import (
    18  	"net/http"
    19  
    20  	"github.com/sacloud/iaas-api-go/internal/define/names"
    21  	"github.com/sacloud/iaas-api-go/internal/define/ops"
    22  	"github.com/sacloud/iaas-api-go/internal/dsl"
    23  	"github.com/sacloud/iaas-api-go/internal/dsl/meta"
    24  	"github.com/sacloud/iaas-api-go/naked"
    25  )
    26  
    27  const (
    28  	databaseAPIName     = "Database"
    29  	databaseAPIPathName = "appliance"
    30  )
    31  
    32  var databaseAPI = &dsl.Resource{
    33  	Name:       databaseAPIName,
    34  	PathName:   databaseAPIPathName,
    35  	PathSuffix: dsl.CloudAPISuffix,
    36  	Operations: dsl.Operations{
    37  		// find
    38  		ops.FindAppliance(databaseAPIName, databaseNakedType, findParameter, databaseView),
    39  
    40  		// create
    41  		ops.CreateAppliance(databaseAPIName, databaseNakedType, databaseCreateParam, databaseView),
    42  
    43  		// read
    44  		ops.ReadAppliance(databaseAPIName, databaseNakedType, databaseView),
    45  
    46  		// update
    47  		ops.UpdateAppliance(databaseAPIName, databaseNakedType, databaseUpdateParam, databaseView),
    48  
    49  		// updateSettings
    50  		ops.UpdateApplianceSettings(databaseAPIName, databaseUpdateSettingsNakedType, databaseUpdateSettingsParam, databaseView),
    51  
    52  		// delete
    53  		ops.Delete(databaseAPIName),
    54  
    55  		// config
    56  		ops.Config(databaseAPIName),
    57  
    58  		// power management(boot/shutdown/reset)
    59  		ops.Boot(databaseAPIName),
    60  		ops.Shutdown(databaseAPIName),
    61  		ops.Reset(databaseAPIName),
    62  
    63  		// monitor
    64  		ops.MonitorChild(databaseAPIName, "CPU", "cpu",
    65  			monitorParameter, monitors.cpuTimeModel()),
    66  		ops.MonitorChild(databaseAPIName, "Disk", "disk/0",
    67  			monitorParameter, monitors.diskModel()),
    68  		ops.MonitorChild(databaseAPIName, "Interface", "interface",
    69  			monitorParameter, monitors.interfaceModel()),
    70  		ops.MonitorChild(databaseAPIName, "Database", "database",
    71  			monitorParameter, monitors.databaseModel()),
    72  
    73  		// status
    74  		{
    75  			ResourceName: databaseAPIName,
    76  			Name:         "Status",
    77  			PathFormat:   dsl.IDAndSuffixPathFormat("status"),
    78  			Method:       http.MethodGet,
    79  			Arguments: dsl.Arguments{
    80  				dsl.ArgumentID,
    81  			},
    82  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    83  				Type: meta.Static(naked.DatabaseStatusResponse{}),
    84  				Name: "Appliance",
    85  			}),
    86  			Results: dsl.Results{
    87  				{
    88  					SourceField: "Appliance",
    89  					DestField:   databaseStatusView.Name,
    90  					IsPlural:    false,
    91  					Model:       databaseStatusView,
    92  				},
    93  			},
    94  		},
    95  		// Parameter
    96  		{
    97  			ResourceName: databaseAPIName,
    98  			Name:         "GetParameter",
    99  			PathFormat:   dsl.IDAndSuffixPathFormat("database/parameter"),
   100  			Method:       http.MethodGet,
   101  			Arguments: dsl.Arguments{
   102  				dsl.ArgumentID,
   103  			},
   104  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   105  				Type: databaseParameterNakedType,
   106  				Name: "Database",
   107  			}),
   108  			Results: dsl.Results{
   109  				{
   110  					SourceField: "Database",
   111  					DestField:   databaseParameterView.Name,
   112  					IsPlural:    false,
   113  					Model:       databaseParameterView,
   114  				},
   115  			},
   116  		},
   117  		{
   118  			ResourceName: databaseAPIName,
   119  			Name:         "SetParameter",
   120  			PathFormat:   dsl.IDAndSuffixPathFormat("database/parameter"),
   121  			Method:       http.MethodPut,
   122  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   123  				Type: meta.Static(naked.DatabaseParameterSetting{}),
   124  				Name: "Parameter",
   125  			}),
   126  			Arguments: dsl.Arguments{
   127  				dsl.ArgumentID,
   128  				{
   129  					Name:       "param",
   130  					Type:       meta.Static(map[string]interface{}{}),
   131  					MapConvTag: "Parameter.Attr",
   132  				},
   133  			},
   134  		},
   135  	},
   136  }
   137  
   138  var (
   139  	databaseNakedType               = meta.Static(naked.Database{})
   140  	databaseUpdateSettingsNakedType = meta.Static(naked.DatabaseSettingsUpdate{})
   141  	databaseStatusNakedType         = meta.Static(naked.DatabaseStatus{})
   142  	databaseParameterNakedType      = meta.Static(naked.DatabaseParameter{})
   143  
   144  	databaseView = &dsl.Model{
   145  		Name:      databaseAPIName,
   146  		NakedType: databaseNakedType,
   147  		Fields: []*dsl.FieldDesc{
   148  			fields.ID(),
   149  			fields.Class(),
   150  			fields.Name(),
   151  			fields.Description(),
   152  			fields.Tags(),
   153  			fields.Availability(),
   154  			fields.IconID(),
   155  			fields.CreatedAt(),
   156  			fields.ModifiedAt(),
   157  			// settings
   158  			fields.DatabaseSettingsCommon(),
   159  			fields.DatabaseSettingsBackup(),
   160  			fields.DatabaseSettingsReplication(),
   161  			fields.DatabaseSettingsInterfaces(),
   162  			fields.SettingsHash(),
   163  
   164  			// instance
   165  			fields.InstanceHostName(),
   166  			fields.InstanceHostInfoURL(),
   167  			fields.InstanceStatus(),
   168  			fields.InstanceStatusChangedAt(),
   169  			// plan
   170  			fields.AppliancePlanID(),
   171  			// switch
   172  			fields.ApplianceSwitchID(),
   173  			// remark
   174  			fields.RemarkDBConf(),
   175  			fields.RemarkDefaultRoute(),
   176  			fields.RemarkNetworkMaskLen(),
   177  			fields.RemarkServerIPAddress(),
   178  			fields.RemarkZoneID(),
   179  			// interfaces
   180  			fields.Interfaces(),
   181  		},
   182  	}
   183  
   184  	databaseCreateParam = &dsl.Model{
   185  		Name:      names.CreateParameterName(databaseAPIName),
   186  		NakedType: databaseNakedType,
   187  		ConstFields: []*dsl.ConstFieldDesc{
   188  			{
   189  				Name:  "Class",
   190  				Type:  meta.TypeString,
   191  				Value: `"database"`,
   192  			},
   193  		},
   194  		Fields: []*dsl.FieldDesc{
   195  			fields.AppliancePlanID(),
   196  			fields.ApplianceSwitchID(),
   197  			fields.ApplianceIPAddresses(),
   198  			fields.RemarkNetworkMaskLen(),
   199  			fields.RemarkDefaultRoute(),
   200  			fields.RemarkDBConf(),
   201  			fields.RemarkSourceAppliance(),
   202  
   203  			fields.DatabaseSettingsCommon(),
   204  			fields.DatabaseSettingsBackup(),
   205  			fields.DatabaseSettingsReplication(),
   206  			fields.DatabaseSettingsInterfaces(),
   207  
   208  			fields.Name(),
   209  			fields.Description(),
   210  			fields.Tags(),
   211  			fields.IconID(),
   212  		},
   213  	}
   214  
   215  	databaseUpdateParam = &dsl.Model{
   216  		Name:      names.UpdateParameterName(databaseAPIName),
   217  		NakedType: databaseNakedType,
   218  		Fields: []*dsl.FieldDesc{
   219  			// common fields
   220  			fields.Name(),
   221  			fields.Description(),
   222  			fields.Tags(),
   223  			fields.IconID(),
   224  
   225  			// settings
   226  			fields.DatabaseSettingsCommon(),
   227  			fields.DatabaseSettingsBackup(),
   228  			fields.DatabaseSettingsReplication(),
   229  			fields.DatabaseSettingsInterfaces(),
   230  			// settings hash
   231  			fields.SettingsHash(),
   232  		},
   233  	}
   234  
   235  	databaseUpdateSettingsParam = &dsl.Model{
   236  		Name:      names.UpdateSettingsParameterName(databaseAPIName),
   237  		NakedType: databaseNakedType,
   238  		Fields: []*dsl.FieldDesc{
   239  			// settings
   240  			fields.DatabaseSettingsCommon(),
   241  			fields.DatabaseSettingsBackup(),
   242  			fields.DatabaseSettingsReplication(),
   243  			fields.DatabaseSettingsInterfaces(),
   244  			// settings hash
   245  			fields.SettingsHash(),
   246  		},
   247  	}
   248  
   249  	databaseStatusView = &dsl.Model{
   250  		Name:      "DatabaseStatus",
   251  		NakedType: databaseStatusNakedType,
   252  		Fields: []*dsl.FieldDesc{
   253  			{
   254  				Name: "Status",
   255  				Type: meta.TypeInstanceStatus,
   256  				Tags: &dsl.FieldTags{
   257  					MapConv: "SettingsResponse.Status",
   258  				},
   259  			},
   260  			{
   261  				Name: "MariaDBStatus",
   262  				Type: meta.TypeString,
   263  				Tags: &dsl.FieldTags{
   264  					MapConv: "SettingsResponse.DBConf.MariaDB.Status",
   265  				},
   266  			},
   267  			{
   268  				Name: "PostgresStatus",
   269  				Type: meta.TypeString,
   270  				Tags: &dsl.FieldTags{
   271  					MapConv: "SettingsResponse.DBConf.Postgres.Status",
   272  				},
   273  			},
   274  			{
   275  				Name: "IsFatal",
   276  				Type: meta.TypeFlag,
   277  				Tags: &dsl.FieldTags{
   278  					MapConv: "SettingsResponse.IsFatal",
   279  				},
   280  			},
   281  			{
   282  				Name: "Version",
   283  				Type: databaseStatusVersionView,
   284  				Tags: &dsl.FieldTags{
   285  					MapConv: "SettingsResponse.DBConf.Version,recursive",
   286  				},
   287  			},
   288  			{
   289  				Name: "Logs",
   290  				Type: databaseStatusLogView,
   291  				Tags: &dsl.FieldTags{
   292  					MapConv: "SettingsResponse.DBConf.[]Log,recursive",
   293  				},
   294  			},
   295  			{
   296  				Name: "Backups",
   297  				Type: databaseStatusBackupHistoryView,
   298  				Tags: &dsl.FieldTags{
   299  					MapConv: "SettingsResponse.DBConf.Backup.[]History,recursive",
   300  				},
   301  			},
   302  		},
   303  	}
   304  
   305  	databaseStatusVersionView = &dsl.Model{
   306  		Name:      "DatabaseVersionInfo",
   307  		NakedType: meta.Static(naked.DatabaseStatusVersion{}),
   308  		Fields: []*dsl.FieldDesc{
   309  			fields.Def("LastModified", meta.TypeString),
   310  			fields.Def("CommitHash", meta.TypeString),
   311  			fields.Def("Status", meta.TypeString),
   312  			fields.Def("Tag", meta.TypeString),
   313  			fields.Def("Expire", meta.TypeString),
   314  		},
   315  	}
   316  
   317  	databaseStatusLogView = &dsl.Model{
   318  		Name:      "DatabaseLog",
   319  		NakedType: meta.Static(naked.DatabaseLog{}),
   320  		IsArray:   true,
   321  		Fields: []*dsl.FieldDesc{
   322  			fields.Def("Name", meta.TypeString),
   323  			fields.Def("Data", meta.TypeString),
   324  			fields.Def("Size", meta.TypeStringNumber),
   325  		},
   326  	}
   327  	databaseStatusBackupHistoryView = &dsl.Model{
   328  		Name:      "DatabaseBackupHistory",
   329  		NakedType: meta.Static(naked.DatabaseBackupHistory{}),
   330  		IsArray:   true,
   331  		Fields: []*dsl.FieldDesc{
   332  			fields.Def("CreatedAt", meta.TypeTime),
   333  			fields.Def("Availability", meta.TypeString),
   334  			fields.Def("RecoveredAt", meta.TypeTime),
   335  			fields.Def("Size", meta.TypeInt64),
   336  		},
   337  	}
   338  
   339  	databaseParameterView = &dsl.Model{
   340  		Name:      "DatabaseParameter",
   341  		NakedType: databaseParameterNakedType,
   342  		Fields: []*dsl.FieldDesc{
   343  			{
   344  				Name: "Settings",
   345  				Type: meta.Static(map[string]interface{}{}),
   346  				Tags: &dsl.FieldTags{
   347  					MapConv: "Parameter.Attr",
   348  				},
   349  			},
   350  			{
   351  				Name: "MetaInfo",
   352  				Type: databaseParameterMeta,
   353  				Tags: &dsl.FieldTags{
   354  					MapConv: "Remark.[]Form,recursive",
   355  				},
   356  			},
   357  		},
   358  	}
   359  
   360  	databaseParameterMeta = &dsl.Model{
   361  		Name:      "DatabaseParameterMeta",
   362  		NakedType: meta.Static(naked.DatabaseParameterFormMeta{}),
   363  		IsArray:   true,
   364  		Fields: []*dsl.FieldDesc{
   365  			{
   366  				Name: "Type",
   367  				Type: meta.TypeString,
   368  				Tags: mapConvTag("Options.Type"),
   369  			},
   370  			fields.Def("Name", meta.TypeString),
   371  			fields.Def("Label", meta.TypeString),
   372  			{
   373  				Name: "Text",
   374  				Type: meta.TypeString,
   375  				Tags: mapConvTag("Options.Text"),
   376  			},
   377  			{
   378  				Name: "Example",
   379  				Type: meta.TypeString,
   380  				Tags: mapConvTag("Options.Example"),
   381  			},
   382  			{
   383  				Name: "Min",
   384  				Type: meta.TypeFloat64,
   385  				Tags: mapConvTag("Options.Min"),
   386  			},
   387  			{
   388  				Name: "Max",
   389  				Type: meta.TypeFloat64,
   390  				Tags: mapConvTag("Options.Max"),
   391  			},
   392  			{
   393  				Name: "MaxLen",
   394  				Type: meta.TypeInt,
   395  				Tags: mapConvTag("Options.MaxLen"),
   396  			},
   397  			{
   398  				Name: "Reboot",
   399  				Type: meta.TypeString,
   400  				Tags: mapConvTag("Options.Reboot"),
   401  			},
   402  		},
   403  	}
   404  )