github.com/sacloud/iaas-api-go@v1.12.0/internal/define/server.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  	"github.com/sacloud/iaas-api-go/types"
    26  )
    27  
    28  const (
    29  	serverAPIName     = "Server"
    30  	serverAPIPathName = "server"
    31  )
    32  
    33  var serverAPI = &dsl.Resource{
    34  	Name:       serverAPIName,
    35  	PathName:   serverAPIPathName,
    36  	PathSuffix: dsl.CloudAPISuffix,
    37  	Operations: dsl.Operations{
    38  		// find
    39  		ops.Find(serverAPIName, serverNakedType, findParameter, serverView),
    40  
    41  		// create
    42  		ops.Create(serverAPIName, serverNakedType, serverCreateParam, serverView),
    43  
    44  		// read
    45  		ops.Read(serverAPIName, serverNakedType, serverView),
    46  
    47  		// update
    48  		ops.Update(serverAPIName, serverNakedType, serverUpdateParam, serverView),
    49  
    50  		// delete
    51  		ops.Delete(serverAPIName),
    52  
    53  		// delete with disks
    54  		{
    55  			ResourceName: serverAPIName,
    56  			Name:         "DeleteWithDisks",
    57  			PathFormat:   dsl.DefaultPathFormatWithID,
    58  			Method:       http.MethodDelete,
    59  			RequestEnvelope: dsl.RequestEnvelope(
    60  				&dsl.EnvelopePayloadDesc{
    61  					Type: meta.Static([]types.ID{}),
    62  					Name: "WithDisk",
    63  				},
    64  			),
    65  			Arguments: dsl.Arguments{
    66  				dsl.ArgumentID,
    67  				dsl.PassthroughModelArgument("disks", serverDeleteParam),
    68  			},
    69  		},
    70  
    71  		// change plan
    72  		{
    73  			ResourceName:    serverAPIName,
    74  			Name:            "ChangePlan",
    75  			PathFormat:      dsl.IDAndSuffixPathFormat("plan"),
    76  			Method:          http.MethodPut,
    77  			RequestEnvelope: dsl.RequestEnvelopeFromModel(serverChangePlanParam),
    78  			Arguments: dsl.Arguments{
    79  				dsl.ArgumentID,
    80  				dsl.PassthroughModelArgument("plan", serverChangePlanParam),
    81  			},
    82  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    83  				Name: serverAPIName,
    84  				Type: meta.Static(naked.Server{}),
    85  			}),
    86  			Results: dsl.Results{
    87  				{
    88  					SourceField: names.ResourceFieldName(serverAPIName, dsl.PayloadForms.Singular),
    89  					DestField:   names.ResourceFieldName(serverAPIName, dsl.PayloadForms.Singular),
    90  					IsPlural:    false,
    91  					Model:       serverView,
    92  				},
    93  			},
    94  		},
    95  
    96  		// insert cdrom
    97  		{
    98  			ResourceName: serverAPIName,
    99  			Name:         "InsertCDROM",
   100  			PathFormat:   dsl.IDAndSuffixPathFormat("cdrom"),
   101  			Method:       http.MethodPut,
   102  			RequestEnvelope: dsl.RequestEnvelope(
   103  				&dsl.EnvelopePayloadDesc{
   104  					Type: meta.Static(naked.CDROM{}),
   105  					Name: "CDROM",
   106  				},
   107  			),
   108  			Arguments: dsl.Arguments{
   109  				dsl.ArgumentID,
   110  				{
   111  					Name: "insertParam",
   112  					Type: &dsl.Model{
   113  						Name: "InsertCDROMRequest",
   114  						Fields: []*dsl.FieldDesc{
   115  							fields.ID(),
   116  						},
   117  						NakedType: meta.Static(naked.CDROM{}),
   118  					},
   119  					MapConvTag: "CDROM",
   120  				},
   121  			},
   122  		},
   123  
   124  		// eject cdrom
   125  		{
   126  			ResourceName: serverAPIName,
   127  			Name:         "EjectCDROM",
   128  			PathFormat:   dsl.IDAndSuffixPathFormat("cdrom"),
   129  			Method:       http.MethodDelete,
   130  			RequestEnvelope: dsl.RequestEnvelope(
   131  				&dsl.EnvelopePayloadDesc{
   132  					Type: meta.Static(naked.CDROM{}),
   133  					Name: "CDROM",
   134  				},
   135  			),
   136  			Arguments: dsl.Arguments{
   137  				dsl.ArgumentID,
   138  				{
   139  					Name: "ejectParam",
   140  					Type: &dsl.Model{
   141  						Name: "EjectCDROMRequest",
   142  						Fields: []*dsl.FieldDesc{
   143  							fields.ID(),
   144  						},
   145  						NakedType: meta.Static(naked.CDROM{}),
   146  					},
   147  					MapConvTag: "CDROM",
   148  				},
   149  			},
   150  		},
   151  
   152  		// power management(boot/shutdown/reset)
   153  		ops.Boot(serverAPIName),
   154  		ops.Shutdown(serverAPIName),
   155  		ops.Reset(serverAPIName),
   156  
   157  		// cloud-init(Bootにパラメータを追加したもの)
   158  		{
   159  			ResourceName: serverAPIName,
   160  			Name:         "BootWithVariables",
   161  			PathFormat:   dsl.IDAndSuffixPathFormat("power"),
   162  			Method:       http.MethodPut,
   163  			LockLevel:    dsl.LockLevelGlobal,
   164  			RequestEnvelope: dsl.RequestEnvelope(
   165  				&dsl.EnvelopePayloadDesc{
   166  					Type: meta.Static(naked.ServerBootVariables{}),
   167  					Name: "UserBootVariables",
   168  				},
   169  			),
   170  			Arguments: dsl.Arguments{
   171  				dsl.ArgumentID,
   172  				dsl.MappableArgument("param", models.serverBootVariables(), "UserBootVariables"),
   173  			},
   174  		},
   175  
   176  		// send key
   177  		{
   178  			ResourceName: serverAPIName,
   179  			Name:         "SendKey",
   180  			PathFormat:   dsl.IDAndSuffixPathFormat("keyboard"),
   181  			Method:       http.MethodPut,
   182  			Arguments: dsl.Arguments{
   183  				dsl.ArgumentID,
   184  				dsl.PassthroughModelArgument("keyboardParam", serverSendKeyParam),
   185  			},
   186  			RequestEnvelope: dsl.RequestEnvelopeFromModel(serverSendKeyParam),
   187  		},
   188  
   189  		// send NMI
   190  		ops.WithIDAction(serverAPIName, "SendNMI", http.MethodPut, "qemu/nmi"),
   191  
   192  		// get vnc proxy
   193  		{
   194  			ResourceName: serverAPIName,
   195  			Name:         "GetVNCProxy",
   196  			PathFormat:   dsl.IDAndSuffixPathFormat("vnc/proxy"),
   197  			Method:       http.MethodGet,
   198  			Arguments: dsl.Arguments{
   199  				dsl.ArgumentID,
   200  			},
   201  			ResponseEnvelope: dsl.ResponseEnvelope(
   202  				&dsl.EnvelopePayloadDesc{
   203  					Name: "VNCProxyInfo",
   204  					Type: meta.Static(naked.VNCProxyInfo{}),
   205  				},
   206  			),
   207  			Results: dsl.Results{
   208  				{
   209  					SourceField: "VNCProxyInfo",
   210  					DestField:   serverVNCProxyView.Name,
   211  					IsPlural:    false,
   212  					Model:       serverVNCProxyView,
   213  				},
   214  			},
   215  		},
   216  
   217  		// monitor
   218  		ops.Monitor(serverAPIName, monitorParameter, monitors.cpuTimeModel()),
   219  		ops.MonitorChild(serverAPIName, "CPU", "", monitorParameter, monitors.cpuTimeModel()),
   220  	},
   221  }
   222  
   223  var (
   224  	serverNakedType = meta.Static(naked.Server{})
   225  
   226  	serverView = &dsl.Model{
   227  		Name:      serverAPIName,
   228  		NakedType: serverNakedType,
   229  		Fields: []*dsl.FieldDesc{
   230  			fields.ID(),
   231  			fields.Name(),
   232  			fields.Description(),
   233  			fields.Tags(),
   234  			fields.Availability(),
   235  			fields.HostName(),
   236  			fields.InterfaceDriver(),
   237  			// server plan
   238  			fields.ServerPlanID(),
   239  			fields.ServerPlanName(),
   240  			fields.ServerPlanCPU(),
   241  			fields.ServerPlanMemoryMB(),
   242  			fields.ServerPlanGPU(),
   243  			fields.ServerPlanCPUModel(),
   244  			fields.ServerPlanCommitment(),
   245  			fields.ServerPlanGeneration(),
   246  			// zone
   247  			fields.Zone(),
   248  			// instance
   249  			fields.InstanceHostName(),
   250  			fields.InstanceHostInfoURL(),
   251  			fields.InstanceStatus(),
   252  			fields.InstanceBeforeStatus(),
   253  			fields.InstanceStatusChangedAt(),
   254  			fields.InstanceWarnings(),
   255  			fields.InstanceWarningsValue(),
   256  
   257  			// disks
   258  			{
   259  				Name: "Disks",
   260  				Type: serverConnectedDiskView,
   261  				Tags: &dsl.FieldTags{
   262  					JSON:    ",omitempty",
   263  					MapConv: ",recursive",
   264  				},
   265  			},
   266  			fields.Interfaces(),
   267  
   268  			fields.CDROMID(),
   269  
   270  			fields.PrivateHostID(),
   271  			fields.PrivateHostName(),
   272  
   273  			fields.BundleInfo(),
   274  
   275  			fields.IconID(),
   276  			fields.CreatedAt(),
   277  			fields.ModifiedAt(),
   278  		},
   279  	}
   280  
   281  	serverConnectedDiskView = &dsl.Model{
   282  		Name:      "ServerConnectedDisk",
   283  		NakedType: meta.Static(naked.Disk{}),
   284  		IsArray:   true,
   285  		Fields: []*dsl.FieldDesc{
   286  			fields.ID(),
   287  			fields.Name(),
   288  			fields.Availability(),
   289  			fields.DiskConnection(),
   290  			fields.DiskConnectionOrder(),
   291  			fields.DiskEncryptionAlgorithm(),
   292  			fields.DiskReinstallCount(),
   293  			fields.SizeMB(),
   294  			fields.DiskPlanID(),
   295  			{
   296  				Name: "Storage",
   297  				Type: serverConnectedStorage,
   298  				Tags: &dsl.FieldTags{
   299  					MapConv: ",omitempty,recursive",
   300  					JSON:    ",omitempty",
   301  				},
   302  			},
   303  		},
   304  	}
   305  
   306  	serverConnectedStorage = &dsl.Model{
   307  		Name:      "Storage",
   308  		NakedType: meta.Static(naked.Storage{}),
   309  		Fields: []*dsl.FieldDesc{
   310  			fields.ID(),
   311  			{
   312  				Name: "Class",
   313  				Type: meta.TypeString,
   314  				Tags: &dsl.FieldTags{
   315  					MapConv: ",omitempty",
   316  					JSON:    ",omitempty",
   317  				},
   318  			},
   319  			{
   320  				Name: "Generation",
   321  				Type: meta.TypeInt,
   322  				Tags: &dsl.FieldTags{
   323  					MapConv: ",omitempty",
   324  					JSON:    ",omitempty",
   325  				},
   326  			},
   327  		},
   328  	}
   329  
   330  	serverCreateParam = &dsl.Model{
   331  		Name:      names.CreateParameterName(serverAPIName),
   332  		NakedType: serverNakedType,
   333  		Fields: []*dsl.FieldDesc{
   334  			// server plan
   335  			fields.ServerPlanCPU(),
   336  			fields.ServerPlanMemoryMB(),
   337  			fields.ServerPlanGPU(),
   338  			fields.ServerPlanCPUModel(),
   339  			fields.ServerPlanCommitment(),
   340  			fields.ServerPlanGeneration(),
   341  			fields.ServerConnectedSwitch(),
   342  			fields.InterfaceDriver(),
   343  			fields.Name(),
   344  			fields.Description(),
   345  			fields.Tags(),
   346  			fields.IconID(),
   347  			{
   348  				Name: "WaitDiskMigration",
   349  				Type: meta.TypeFlag,
   350  				Tags: &dsl.FieldTags{
   351  					MapConv: ",omitempty",
   352  					JSON:    ",omitempty",
   353  				},
   354  			},
   355  			fields.PrivateHostID(),
   356  		},
   357  	}
   358  
   359  	serverUpdateParam = &dsl.Model{
   360  		Name:      names.UpdateParameterName(serverAPIName),
   361  		NakedType: serverNakedType,
   362  		Fields: []*dsl.FieldDesc{
   363  			fields.Name(),
   364  			fields.Description(),
   365  			fields.Tags(),
   366  			fields.IconID(),
   367  			fields.PrivateHostID(),
   368  			fields.InterfaceDriver(),
   369  		},
   370  	}
   371  
   372  	serverDeleteParam = &dsl.Model{
   373  		Name: "ServerDeleteWithDisksRequest",
   374  		Fields: []*dsl.FieldDesc{
   375  			fields.Def("IDs", meta.Static([]types.ID{}), &dsl.FieldTags{
   376  				MapConv: "WithDisk",
   377  			}),
   378  		},
   379  		NakedType: meta.Static(naked.DeleteServerWithDiskParameter{}),
   380  	}
   381  
   382  	serverChangePlanParam = &dsl.Model{
   383  		Name: "ServerChangePlanRequest",
   384  		Fields: []*dsl.FieldDesc{
   385  			fields.CPU(),
   386  			fields.MemoryMB(),
   387  			fields.GPU(),
   388  			fields.CPUModel(),
   389  			fields.Generation(),
   390  			fields.Commitment(),
   391  		},
   392  		NakedType: meta.Static(naked.ServerPlan{}),
   393  	}
   394  
   395  	serverSendKeyParam = &dsl.Model{
   396  		Name: "SendKeyRequest",
   397  		Fields: []*dsl.FieldDesc{
   398  			fields.Def("Key", meta.TypeString),
   399  			fields.Def("Keys", meta.TypeStringSlice),
   400  		},
   401  	}
   402  
   403  	serverVNCProxyView = &dsl.Model{
   404  		Name:      "VNCProxyInfo",
   405  		NakedType: meta.Static(naked.VNCProxyInfo{}),
   406  		Fields: []*dsl.FieldDesc{
   407  			fields.Def("Status", meta.TypeString),
   408  			fields.Def("Host", meta.TypeString),
   409  			fields.Def("IOServerHost", meta.TypeString),
   410  			fields.Def("Port", meta.TypeStringNumber),
   411  			fields.Def("Password", meta.TypeString),
   412  			fields.Def("VNCFile", meta.TypeString),
   413  		},
   414  	}
   415  )