github.com/sacloud/iaas-api-go@v1.12.0/internal/define/vpc_router.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  	vpcRouterAPIName     = "VPCRouter"
    30  	vpcRouterAPIPathName = "appliance"
    31  )
    32  
    33  var vpcRouterAPI = &dsl.Resource{
    34  	Name:       vpcRouterAPIName,
    35  	PathName:   vpcRouterAPIPathName,
    36  	PathSuffix: dsl.CloudAPISuffix,
    37  	Operations: dsl.Operations{
    38  		// find
    39  		ops.FindAppliance(vpcRouterAPIName, vpcRouterNakedType, findParameter, vpcRouterView),
    40  
    41  		// create
    42  		ops.CreateAppliance(vpcRouterAPIName, vpcRouterNakedType, vpcRouterCreateParam, vpcRouterView),
    43  
    44  		// read
    45  		ops.ReadAppliance(vpcRouterAPIName, vpcRouterNakedType, vpcRouterView),
    46  
    47  		// update
    48  		ops.UpdateAppliance(vpcRouterAPIName, vpcRouterNakedType, vpcRouterUpdateParam, vpcRouterView),
    49  		// updateSettings
    50  		ops.UpdateApplianceSettings(vpcRouterAPIName, vpcRouterUpdateSettingsNakedType, vpcRouterUpdateSettingsParam, vpcRouterView),
    51  
    52  		// delete
    53  		ops.Delete(vpcRouterAPIName),
    54  
    55  		// config
    56  		ops.Config(vpcRouterAPIName),
    57  
    58  		// power management(boot/shutdown/reset)
    59  		ops.Boot(vpcRouterAPIName),
    60  		ops.Shutdown(vpcRouterAPIName),
    61  		ops.Reset(vpcRouterAPIName),
    62  
    63  		// connect to switch
    64  		ops.WithIDAction(
    65  			vpcRouterAPIName, "ConnectToSwitch", http.MethodPut, "interface/{{.nicIndex}}/to/switch/{{.switchID}}",
    66  			&dsl.Argument{
    67  				Name: "nicIndex",
    68  				Type: meta.TypeInt,
    69  			},
    70  			&dsl.Argument{
    71  				Name: "switchID",
    72  				Type: meta.TypeID,
    73  			},
    74  		),
    75  
    76  		// disconnect from switch
    77  		ops.WithIDAction(
    78  			vpcRouterAPIName, "DisconnectFromSwitch", http.MethodDelete, "interface/{{.nicIndex}}/to/switch",
    79  			&dsl.Argument{
    80  				Name: "nicIndex",
    81  				Type: meta.TypeInt,
    82  			},
    83  		),
    84  
    85  		// monitor
    86  		ops.MonitorChild(vpcRouterAPIName, "CPU", "cpu",
    87  			monitorParameter, monitors.cpuTimeModel()),
    88  		ops.MonitorChildBy(vpcRouterAPIName, "Interface", "interface",
    89  			monitorParameter, monitors.interfaceModel()),
    90  
    91  		// status
    92  		{
    93  			ResourceName: vpcRouterAPIName,
    94  			Name:         "Status",
    95  			Arguments: dsl.Arguments{
    96  				dsl.ArgumentID,
    97  			},
    98  			PathFormat: dsl.IDAndSuffixPathFormat("status"),
    99  			Method:     http.MethodGet,
   100  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   101  				Type: meta.Static(naked.VPCRouterStatus{}),
   102  				Name: "Router",
   103  			}),
   104  			Results: dsl.Results{
   105  				{
   106  					SourceField: "Router",
   107  					DestField:   vpcRouterStatusView.Name,
   108  					Model:       vpcRouterStatusView,
   109  				},
   110  			},
   111  		},
   112  
   113  		// Logs
   114  		{
   115  			ResourceName: vpcRouterAPIName,
   116  			Name:         "Logs",
   117  			Arguments: dsl.Arguments{
   118  				dsl.ArgumentID,
   119  			},
   120  			PathFormat: dsl.IDAndSuffixPathFormat("download/log/VPNLogs"),
   121  			Method:     http.MethodGet,
   122  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   123  				Type: meta.Static(naked.VPCRouterLog{}),
   124  				Name: vpcRouterAPIName,
   125  			}),
   126  			Results: dsl.Results{
   127  				{
   128  					SourceField: vpcRouterAPIName,
   129  					DestField:   vpcRouterLogView.Name,
   130  					Model:       vpcRouterLogView,
   131  				},
   132  			},
   133  		},
   134  
   135  		// Ping
   136  		{
   137  			ResourceName: vpcRouterAPIName,
   138  			Name:         "Ping",
   139  			Arguments: dsl.Arguments{
   140  				dsl.ArgumentID,
   141  				&dsl.Argument{
   142  					Name: "destination",
   143  					Type: meta.TypeString,
   144  				},
   145  			},
   146  			PathFormat: dsl.IDAndSuffixPathFormat("vpcrouter/ping/{{.destination}}"),
   147  			Method:     http.MethodPost,
   148  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   149  				Type: meta.Static(naked.VPCRouterPingResult{}),
   150  				Name: vpcRouterAPIName,
   151  			}),
   152  			Results: dsl.Results{
   153  				{
   154  					SourceField: vpcRouterAPIName,
   155  					DestField:   vpcRouterPingResults.Name,
   156  					Model:       vpcRouterPingResults,
   157  				},
   158  			},
   159  		},
   160  	},
   161  }
   162  
   163  var (
   164  	vpcRouterNakedType               = meta.Static(naked.VPCRouter{})
   165  	vpcRouterUpdateSettingsNakedType = meta.Static(naked.VPCRouterSettingsUpdate{})
   166  
   167  	vpcRouterView = &dsl.Model{
   168  		Name:      vpcRouterAPIName,
   169  		NakedType: vpcRouterNakedType,
   170  		Fields: []*dsl.FieldDesc{
   171  			fields.ID(),
   172  			fields.Name(),
   173  			fields.Description(),
   174  			fields.Tags(),
   175  			fields.Availability(),
   176  			fields.Class(),
   177  			fields.IconID(),
   178  			fields.CreatedAt(),
   179  			// plan
   180  			fields.AppliancePlanID(),
   181  			// version
   182  			fields.ApplianceVPCRouterVersion(),
   183  			// settings
   184  			{
   185  				Name: "Settings",
   186  				Type: models.vpcRouterSetting(),
   187  				Tags: &dsl.FieldTags{
   188  					MapConv: ",omitempty,recursive",
   189  				},
   190  			},
   191  			fields.SettingsHash(),
   192  
   193  			// instance
   194  			fields.InstanceHostName(),
   195  			fields.InstanceHostInfoURL(),
   196  			fields.InstanceStatus(),
   197  			fields.InstanceStatusChangedAt(),
   198  			// interfaces
   199  			fields.VPCRouterInterfaces(),
   200  			fields.RemarkZoneID(),
   201  		},
   202  	}
   203  
   204  	vpcRouterCreateParam = &dsl.Model{
   205  		Name:      names.CreateParameterName(vpcRouterAPIName),
   206  		NakedType: vpcRouterNakedType,
   207  		ConstFields: []*dsl.ConstFieldDesc{
   208  			{
   209  				Name:  "Class",
   210  				Type:  meta.TypeString,
   211  				Value: `"vpcrouter"`,
   212  			},
   213  		},
   214  		Fields: []*dsl.FieldDesc{
   215  			fields.Name(),
   216  			fields.Description(),
   217  			fields.Tags(),
   218  			fields.IconID(),
   219  			fields.PlanID(),
   220  
   221  			// nic
   222  			{
   223  				Name: "Switch",
   224  				Type: &dsl.Model{
   225  					Name: "ApplianceConnectedSwitch",
   226  					Fields: []*dsl.FieldDesc{
   227  						fields.ID(),
   228  						fields.Scope(),
   229  					},
   230  					NakedType: meta.Static(naked.ConnectedSwitch{}),
   231  				},
   232  				Tags: &dsl.FieldTags{
   233  					JSON:    ",omitempty",
   234  					MapConv: "Remark.Switch,recursive",
   235  				},
   236  			},
   237  
   238  			// TODO remarkとsettings.Interfaces両方に設定する必要がある。うまい方法が思いつかないため当面は利用者側で両方に設定する方法としておく
   239  			fields.ApplianceIPAddresses(),
   240  
   241  			// version
   242  			fields.ApplianceVPCRouterVersion(),
   243  
   244  			{
   245  				Name: "Settings",
   246  				Type: models.vpcRouterSetting(),
   247  				Tags: &dsl.FieldTags{
   248  					MapConv: ",omitempty,recursive",
   249  				},
   250  			},
   251  		},
   252  	}
   253  
   254  	vpcRouterUpdateParam = &dsl.Model{
   255  		Name:      names.UpdateParameterName(vpcRouterAPIName),
   256  		NakedType: vpcRouterNakedType,
   257  		Fields: []*dsl.FieldDesc{
   258  			fields.Name(),
   259  			fields.Description(),
   260  			fields.Tags(),
   261  			fields.IconID(),
   262  			{
   263  				Name: "Settings",
   264  				Type: models.vpcRouterSetting(),
   265  				Tags: &dsl.FieldTags{
   266  					MapConv: ",omitempty,recursive",
   267  				},
   268  			},
   269  			// settings hash
   270  			fields.SettingsHash(),
   271  		},
   272  	}
   273  
   274  	vpcRouterUpdateSettingsParam = &dsl.Model{
   275  		Name:      names.UpdateSettingsParameterName(vpcRouterAPIName),
   276  		NakedType: vpcRouterNakedType,
   277  		Fields: []*dsl.FieldDesc{
   278  			{
   279  				Name: "Settings",
   280  				Type: models.vpcRouterSetting(),
   281  				Tags: &dsl.FieldTags{
   282  					MapConv: ",omitempty,recursive",
   283  				},
   284  			},
   285  			// settings hash
   286  			fields.SettingsHash(),
   287  		},
   288  	}
   289  	vpcRouterLogView = &dsl.Model{
   290  		Name:      "VPCRouterLog",
   291  		NakedType: meta.Static(naked.VPCRouterLog{}),
   292  		Fields: []*dsl.FieldDesc{
   293  			fields.Def("Log", meta.TypeString),
   294  		},
   295  	}
   296  
   297  	vpcRouterPingResults = &dsl.Model{
   298  		Name:      "VPCRouterPingResults",
   299  		NakedType: meta.Static(naked.VPCRouterPingResult{}),
   300  		Fields: []*dsl.FieldDesc{
   301  			fields.Def("Result", meta.TypeStringSlice),
   302  		},
   303  	}
   304  
   305  	vpcRouterStatusView = &dsl.Model{
   306  		Name:      "VPCRouterStatus",
   307  		NakedType: meta.Static(naked.VPCRouterStatus{}),
   308  		Fields: []*dsl.FieldDesc{
   309  			fields.Def("FirewallReceiveLogs", meta.TypeStringSlice),
   310  			fields.Def("FirewallSendLogs", meta.TypeStringSlice),
   311  			fields.Def("VPNLogs", meta.TypeStringSlice),
   312  			fields.Def("SessionCount", meta.TypeInt),
   313  			fields.Def("PercentageOfMemoryFree", meta.Static([]types.StringNumber{})),
   314  			{
   315  				Name: "WireGuard",
   316  				Type: &dsl.Model{
   317  					Name: "WireGuardStatus",
   318  					Fields: []*dsl.FieldDesc{
   319  						fields.Def("PublicKey", meta.TypeString),
   320  					},
   321  				},
   322  			},
   323  			{
   324  				Name: "DHCPServerLeases",
   325  				Type: &dsl.Model{
   326  					Name:    "VPCRouterDHCPServerLease",
   327  					IsArray: true,
   328  					Fields: []*dsl.FieldDesc{
   329  						fields.Def("IPAddress", meta.TypeString),
   330  						fields.Def("MACAddress", meta.TypeString),
   331  					},
   332  				},
   333  				Tags: &dsl.FieldTags{
   334  					MapConv: "[]DHCPServerLeases,recursive",
   335  				},
   336  			},
   337  			{
   338  				Name: "L2TPIPsecServerSessions",
   339  				Type: &dsl.Model{
   340  					Name:    "VPCRouterL2TPIPsecServerSession",
   341  					IsArray: true,
   342  					Fields: []*dsl.FieldDesc{
   343  						fields.Def("User", meta.TypeString),
   344  						fields.Def("IPAddress", meta.TypeString),
   345  						fields.Def("TimeSec", meta.TypeInt),
   346  					},
   347  				},
   348  				Tags: &dsl.FieldTags{
   349  					MapConv: "[]L2TPIPsecServerSessions,recursive",
   350  				},
   351  			},
   352  			{
   353  				Name: "PPTPServerSessions",
   354  				Type: &dsl.Model{
   355  					Name:    "VPCRouterPPTPServerSession",
   356  					IsArray: true,
   357  					Fields: []*dsl.FieldDesc{
   358  						fields.Def("User", meta.TypeString),
   359  						fields.Def("IPAddress", meta.TypeString),
   360  						fields.Def("TimeSec", meta.TypeInt),
   361  					},
   362  				},
   363  				Tags: &dsl.FieldTags{
   364  					MapConv: "[]PPTPServerSessions,recursive",
   365  				},
   366  			},
   367  			{
   368  				Name: "SiteToSiteIPsecVPNPeers",
   369  				Type: &dsl.Model{
   370  					Name:    "VPCRouterSiteToSiteIPsecVPNPeer",
   371  					IsArray: true,
   372  					Fields: []*dsl.FieldDesc{
   373  						fields.Def("Status", meta.TypeString),
   374  						fields.Def("Peer", meta.TypeString),
   375  					},
   376  				},
   377  				Tags: &dsl.FieldTags{
   378  					MapConv: "[]SiteToSiteIPsecVPNPeers,recursive",
   379  				},
   380  			},
   381  			{
   382  				Name: "SessionAnalysis",
   383  				Type: &dsl.Model{
   384  					Name: "VPCRouterSessionAnalysis",
   385  					Fields: []*dsl.FieldDesc{
   386  						fields.Def("SourceAndDestination", models.vpcRouterSessionAnalyticsValue()),
   387  						fields.Def("DestinationAddress", models.vpcRouterSessionAnalyticsValue()),
   388  						fields.Def("DestinationPort", models.vpcRouterSessionAnalyticsValue()),
   389  						fields.Def("SourceAddress", models.vpcRouterSessionAnalyticsValue()),
   390  					},
   391  				},
   392  			},
   393  		},
   394  	}
   395  )