github.com/sacloud/libsacloud/v2@v2.32.3/internal/define/server.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  	"github.com/sacloud/libsacloud/v2/sacloud/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.ServerPlanCommitment(),
   244  			fields.ServerPlanGeneration(),
   245  			// zone
   246  			fields.Zone(),
   247  			// instance
   248  			fields.InstanceHostName(),
   249  			fields.InstanceHostInfoURL(),
   250  			fields.InstanceStatus(),
   251  			fields.InstanceBeforeStatus(),
   252  			fields.InstanceStatusChangedAt(),
   253  			fields.InstanceWarnings(),
   254  			fields.InstanceWarningsValue(),
   255  
   256  			// disks
   257  			{
   258  				Name: "Disks",
   259  				Type: serverConnectedDiskView,
   260  				Tags: &dsl.FieldTags{
   261  					JSON:    ",omitempty",
   262  					MapConv: ",recursive",
   263  				},
   264  			},
   265  			fields.Interfaces(),
   266  
   267  			fields.CDROMID(),
   268  
   269  			fields.PrivateHostID(),
   270  			fields.PrivateHostName(),
   271  
   272  			fields.BundleInfo(),
   273  
   274  			fields.IconID(),
   275  			fields.CreatedAt(),
   276  			fields.ModifiedAt(),
   277  		},
   278  	}
   279  
   280  	serverConnectedDiskView = &dsl.Model{
   281  		Name:      "ServerConnectedDisk",
   282  		NakedType: meta.Static(naked.Disk{}),
   283  		IsArray:   true,
   284  		Fields: []*dsl.FieldDesc{
   285  			fields.ID(),
   286  			fields.Name(),
   287  			fields.Availability(),
   288  			fields.DiskConnection(),
   289  			fields.DiskConnectionOrder(),
   290  			fields.DiskReinstallCount(),
   291  			fields.SizeMB(),
   292  			fields.DiskPlanID(),
   293  			{
   294  				Name: "Storage",
   295  				Type: serverConnectedStorage,
   296  				Tags: &dsl.FieldTags{
   297  					MapConv: ",omitempty,recursive",
   298  					JSON:    ",omitempty",
   299  				},
   300  			},
   301  		},
   302  	}
   303  
   304  	serverConnectedStorage = &dsl.Model{
   305  		Name:      "Storage",
   306  		NakedType: meta.Static(naked.Storage{}),
   307  		Fields: []*dsl.FieldDesc{
   308  			fields.ID(),
   309  			{
   310  				Name: "Class",
   311  				Type: meta.TypeString,
   312  				Tags: &dsl.FieldTags{
   313  					MapConv: ",omitempty",
   314  					JSON:    ",omitempty",
   315  				},
   316  			},
   317  			{
   318  				Name: "Generation",
   319  				Type: meta.TypeInt,
   320  				Tags: &dsl.FieldTags{
   321  					MapConv: ",omitempty",
   322  					JSON:    ",omitempty",
   323  				},
   324  			},
   325  		},
   326  	}
   327  
   328  	serverCreateParam = &dsl.Model{
   329  		Name:      names.CreateParameterName(serverAPIName),
   330  		NakedType: serverNakedType,
   331  		Fields: []*dsl.FieldDesc{
   332  			// server plan
   333  			fields.ServerPlanCPU(),
   334  			fields.ServerPlanMemoryMB(),
   335  			fields.ServerPlanGPU(),
   336  			fields.ServerPlanCommitment(),
   337  			fields.ServerPlanGeneration(),
   338  			fields.ServerConnectedSwitch(),
   339  			fields.InterfaceDriver(),
   340  			fields.Name(),
   341  			fields.Description(),
   342  			fields.Tags(),
   343  			fields.IconID(),
   344  			{
   345  				Name: "WaitDiskMigration",
   346  				Type: meta.TypeFlag,
   347  				Tags: &dsl.FieldTags{
   348  					MapConv: ",omitempty",
   349  					JSON:    ",omitempty",
   350  				},
   351  			},
   352  			fields.PrivateHostID(),
   353  		},
   354  	}
   355  
   356  	serverUpdateParam = &dsl.Model{
   357  		Name:      names.UpdateParameterName(serverAPIName),
   358  		NakedType: serverNakedType,
   359  		Fields: []*dsl.FieldDesc{
   360  			fields.Name(),
   361  			fields.Description(),
   362  			fields.Tags(),
   363  			fields.IconID(),
   364  			fields.PrivateHostID(),
   365  			fields.InterfaceDriver(),
   366  		},
   367  	}
   368  
   369  	serverDeleteParam = &dsl.Model{
   370  		Name: "ServerDeleteWithDisksRequest",
   371  		Fields: []*dsl.FieldDesc{
   372  			fields.Def("IDs", meta.Static([]types.ID{}), &dsl.FieldTags{
   373  				MapConv: "WithDisk",
   374  			}),
   375  		},
   376  		NakedType: meta.Static(naked.DeleteServerWithDiskParameter{}),
   377  	}
   378  
   379  	serverChangePlanParam = &dsl.Model{
   380  		Name: "ServerChangePlanRequest",
   381  		Fields: []*dsl.FieldDesc{
   382  			fields.CPU(),
   383  			fields.MemoryMB(),
   384  			fields.GPU(),
   385  			fields.Generation(),
   386  			fields.Commitment(),
   387  		},
   388  		NakedType: meta.Static(naked.ServerPlan{}),
   389  	}
   390  
   391  	serverSendKeyParam = &dsl.Model{
   392  		Name: "SendKeyRequest",
   393  		Fields: []*dsl.FieldDesc{
   394  			fields.Def("Key", meta.TypeString),
   395  			fields.Def("Keys", meta.TypeStringSlice),
   396  		},
   397  	}
   398  
   399  	serverVNCProxyView = &dsl.Model{
   400  		Name:      "VNCProxyInfo",
   401  		NakedType: meta.Static(naked.VNCProxyInfo{}),
   402  		Fields: []*dsl.FieldDesc{
   403  			fields.Def("Status", meta.TypeString),
   404  			fields.Def("Host", meta.TypeString),
   405  			fields.Def("IOServerHost", meta.TypeString),
   406  			fields.Def("Port", meta.TypeStringNumber),
   407  			fields.Def("Password", meta.TypeString),
   408  			fields.Def("VNCFile", meta.TypeString),
   409  		},
   410  	}
   411  )