github.com/sacloud/libsacloud/v2@v2.32.3/internal/define/database.go (about)

     1  // Copyright 2016-2022 The Libsacloud 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/libsacloud/v2/internal/define/names"
    21  	"github.com/sacloud/libsacloud/v2/internal/define/ops"
    22  	"github.com/sacloud/libsacloud/v2/internal/dsl"
    23  	"github.com/sacloud/libsacloud/v2/internal/dsl/meta"
    24  	"github.com/sacloud/libsacloud/v2/sacloud/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.SettingsHash(),
   162  
   163  			// instance
   164  			fields.InstanceHostName(),
   165  			fields.InstanceHostInfoURL(),
   166  			fields.InstanceStatus(),
   167  			fields.InstanceStatusChangedAt(),
   168  			// plan
   169  			fields.AppliancePlanID(),
   170  			// switch
   171  			fields.ApplianceSwitchID(),
   172  			// remark
   173  			fields.RemarkDBConf(),
   174  			fields.RemarkDefaultRoute(),
   175  			fields.RemarkNetworkMaskLen(),
   176  			fields.RemarkServerIPAddress(),
   177  			fields.RemarkZoneID(),
   178  			// interfaces
   179  			fields.Interfaces(),
   180  		},
   181  	}
   182  
   183  	databaseCreateParam = &dsl.Model{
   184  		Name:      names.CreateParameterName(databaseAPIName),
   185  		NakedType: databaseNakedType,
   186  		ConstFields: []*dsl.ConstFieldDesc{
   187  			{
   188  				Name:  "Class",
   189  				Type:  meta.TypeString,
   190  				Value: `"database"`,
   191  			},
   192  		},
   193  		Fields: []*dsl.FieldDesc{
   194  			fields.AppliancePlanID(),
   195  			fields.ApplianceSwitchID(),
   196  			fields.ApplianceIPAddresses(),
   197  			fields.RemarkNetworkMaskLen(),
   198  			fields.RemarkDefaultRoute(),
   199  			fields.RemarkDBConf(),
   200  			fields.RemarkSourceAppliance(),
   201  
   202  			fields.DatabaseSettingsCommon(),
   203  			fields.DatabaseSettingsBackup(),
   204  			fields.DatabaseSettingsReplication(),
   205  
   206  			fields.Name(),
   207  			fields.Description(),
   208  			fields.Tags(),
   209  			fields.IconID(),
   210  		},
   211  	}
   212  
   213  	databaseUpdateParam = &dsl.Model{
   214  		Name:      names.UpdateParameterName(databaseAPIName),
   215  		NakedType: databaseNakedType,
   216  		Fields: []*dsl.FieldDesc{
   217  			// common fields
   218  			fields.Name(),
   219  			fields.Description(),
   220  			fields.Tags(),
   221  			fields.IconID(),
   222  
   223  			// settings
   224  			fields.DatabaseSettingsCommon(),
   225  			fields.DatabaseSettingsBackup(),
   226  			fields.DatabaseSettingsReplication(),
   227  			// settings hash
   228  			fields.SettingsHash(),
   229  		},
   230  	}
   231  
   232  	databaseUpdateSettingsParam = &dsl.Model{
   233  		Name:      names.UpdateSettingsParameterName(databaseAPIName),
   234  		NakedType: databaseNakedType,
   235  		Fields: []*dsl.FieldDesc{
   236  			// settings
   237  			fields.DatabaseSettingsCommon(),
   238  			fields.DatabaseSettingsBackup(),
   239  			fields.DatabaseSettingsReplication(),
   240  			// settings hash
   241  			fields.SettingsHash(),
   242  		},
   243  	}
   244  
   245  	databaseStatusView = &dsl.Model{
   246  		Name:      "DatabaseStatus",
   247  		NakedType: databaseStatusNakedType,
   248  		Fields: []*dsl.FieldDesc{
   249  			{
   250  				Name: "Status",
   251  				Type: meta.TypeInstanceStatus,
   252  				Tags: &dsl.FieldTags{
   253  					MapConv: "SettingsResponse.Status",
   254  				},
   255  			},
   256  			{
   257  				Name: "MariaDBStatus",
   258  				Type: meta.TypeString,
   259  				Tags: &dsl.FieldTags{
   260  					MapConv: "SettingsResponse.DBConf.MariaDB.Status",
   261  				},
   262  			},
   263  			{
   264  				Name: "PostgresStatus",
   265  				Type: meta.TypeString,
   266  				Tags: &dsl.FieldTags{
   267  					MapConv: "SettingsResponse.DBConf.Postgres.Status",
   268  				},
   269  			},
   270  			{
   271  				Name: "IsFatal",
   272  				Type: meta.TypeFlag,
   273  				Tags: &dsl.FieldTags{
   274  					MapConv: "SettingsResponse.IsFatal",
   275  				},
   276  			},
   277  			{
   278  				Name: "Version",
   279  				Type: databaseStatusVersionView,
   280  				Tags: &dsl.FieldTags{
   281  					MapConv: "SettingsResponse.DBConf.Version,recursive",
   282  				},
   283  			},
   284  			{
   285  				Name: "Logs",
   286  				Type: databaseStatusLogView,
   287  				Tags: &dsl.FieldTags{
   288  					MapConv: "SettingsResponse.DBConf.[]Log,recursive",
   289  				},
   290  			},
   291  			{
   292  				Name: "Backups",
   293  				Type: databaseStatusBackupHistoryView,
   294  				Tags: &dsl.FieldTags{
   295  					MapConv: "SettingsResponse.DBConf.Backup.[]History,recursive",
   296  				},
   297  			},
   298  		},
   299  	}
   300  
   301  	databaseStatusVersionView = &dsl.Model{
   302  		Name:      "DatabaseVersionInfo",
   303  		NakedType: meta.Static(naked.DatabaseStatusVersion{}),
   304  		Fields: []*dsl.FieldDesc{
   305  			fields.Def("LastModified", meta.TypeString),
   306  			fields.Def("CommitHash", meta.TypeString),
   307  			fields.Def("Status", meta.TypeString),
   308  			fields.Def("Tag", meta.TypeString),
   309  			fields.Def("Expire", meta.TypeString),
   310  		},
   311  	}
   312  
   313  	databaseStatusLogView = &dsl.Model{
   314  		Name:      "DatabaseLog",
   315  		NakedType: meta.Static(naked.DatabaseLog{}),
   316  		IsArray:   true,
   317  		Fields: []*dsl.FieldDesc{
   318  			fields.Def("Name", meta.TypeString),
   319  			fields.Def("Data", meta.TypeString),
   320  			fields.Def("Size", meta.TypeStringNumber),
   321  		},
   322  	}
   323  	databaseStatusBackupHistoryView = &dsl.Model{
   324  		Name:      "DatabaseBackupHistory",
   325  		NakedType: meta.Static(naked.DatabaseBackupHistory{}),
   326  		IsArray:   true,
   327  		Fields: []*dsl.FieldDesc{
   328  			fields.Def("CreatedAt", meta.TypeTime),
   329  			fields.Def("Availability", meta.TypeString),
   330  			fields.Def("RecoveredAt", meta.TypeTime),
   331  			fields.Def("Size", meta.TypeInt64),
   332  		},
   333  	}
   334  
   335  	databaseParameterView = &dsl.Model{
   336  		Name:      "DatabaseParameter",
   337  		NakedType: databaseParameterNakedType,
   338  		Fields: []*dsl.FieldDesc{
   339  			{
   340  				Name: "Settings",
   341  				Type: meta.Static(map[string]interface{}{}),
   342  				Tags: &dsl.FieldTags{
   343  					MapConv: "Parameter.Attr",
   344  				},
   345  			},
   346  			{
   347  				Name: "MetaInfo",
   348  				Type: databaseParameterMeta,
   349  				Tags: &dsl.FieldTags{
   350  					MapConv: "Remark.[]Form,recursive",
   351  				},
   352  			},
   353  		},
   354  	}
   355  
   356  	databaseParameterMeta = &dsl.Model{
   357  		Name:      "DatabaseParameterMeta",
   358  		NakedType: meta.Static(naked.DatabaseParameterFormMeta{}),
   359  		IsArray:   true,
   360  		Fields: []*dsl.FieldDesc{
   361  			{
   362  				Name: "Type",
   363  				Type: meta.TypeString,
   364  				Tags: mapConvTag("Options.Type"),
   365  			},
   366  			fields.Def("Name", meta.TypeString),
   367  			fields.Def("Label", meta.TypeString),
   368  			{
   369  				Name: "Text",
   370  				Type: meta.TypeString,
   371  				Tags: mapConvTag("Options.Text"),
   372  			},
   373  			{
   374  				Name: "Example",
   375  				Type: meta.TypeString,
   376  				Tags: mapConvTag("Options.Example"),
   377  			},
   378  			{
   379  				Name: "Min",
   380  				Type: meta.TypeFloat64,
   381  				Tags: mapConvTag("Options.Min"),
   382  			},
   383  			{
   384  				Name: "Max",
   385  				Type: meta.TypeFloat64,
   386  				Tags: mapConvTag("Options.Max"),
   387  			},
   388  			{
   389  				Name: "MaxLen",
   390  				Type: meta.TypeInt,
   391  				Tags: mapConvTag("Options.MaxLen"),
   392  			},
   393  			{
   394  				Name: "Reboot",
   395  				Type: meta.TypeString,
   396  				Tags: mapConvTag("Options.Reboot"),
   397  			},
   398  		},
   399  	}
   400  )