github.com/sacloud/iaas-api-go@v1.12.0/internal/define/load_balancer.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  	"github.com/sacloud/iaas-api-go/internal/define/names"
    19  	"github.com/sacloud/iaas-api-go/internal/define/ops"
    20  	"github.com/sacloud/iaas-api-go/internal/dsl"
    21  	"github.com/sacloud/iaas-api-go/internal/dsl/meta"
    22  	"github.com/sacloud/iaas-api-go/naked"
    23  )
    24  
    25  const (
    26  	loadBalancerAPIName     = "LoadBalancer"
    27  	loadBalancerAPIPathName = "appliance"
    28  )
    29  
    30  var loadBalancerAPI = &dsl.Resource{
    31  	Name:       loadBalancerAPIName,
    32  	PathName:   loadBalancerAPIPathName,
    33  	PathSuffix: dsl.CloudAPISuffix,
    34  	Operations: dsl.Operations{
    35  		// find
    36  		ops.FindAppliance(loadBalancerAPIName, loadBalancerNakedType, findParameter, loadBalancerView),
    37  
    38  		// create
    39  		ops.CreateAppliance(loadBalancerAPIName, loadBalancerNakedType, loadBalancerCreateParam, loadBalancerView),
    40  
    41  		// read
    42  		ops.ReadAppliance(loadBalancerAPIName, loadBalancerNakedType, loadBalancerView),
    43  
    44  		// update
    45  		ops.UpdateAppliance(loadBalancerAPIName, loadBalancerNakedType, loadBalancerUpdateParam, loadBalancerView),
    46  		// updateSettings
    47  		ops.UpdateApplianceSettings(loadBalancerAPIName, loadBalancerUpdateSettingsNakedType, loadBalancerUpdateSettingsParam, loadBalancerView),
    48  
    49  		// delete
    50  		ops.Delete(loadBalancerAPIName),
    51  
    52  		// config
    53  		ops.Config(loadBalancerAPIName),
    54  
    55  		// power management(boot/shutdown/reset)
    56  		ops.Boot(loadBalancerAPIName),
    57  		ops.Shutdown(loadBalancerAPIName),
    58  		ops.Reset(loadBalancerAPIName),
    59  
    60  		// monitor
    61  		ops.MonitorChild(loadBalancerAPIName, "CPU", "cpu",
    62  			monitorParameter, monitors.cpuTimeModel()),
    63  		ops.MonitorChild(loadBalancerAPIName, "Interface", "interface",
    64  			monitorParameter, monitors.interfaceModel()),
    65  
    66  		// status
    67  		ops.Status(loadBalancerAPIName, meta.Static(naked.LoadBalancerStatus{}), loadBalancerStatus),
    68  	},
    69  }
    70  
    71  var (
    72  	loadBalancerNakedType               = meta.Static(naked.LoadBalancer{})
    73  	loadBalancerUpdateSettingsNakedType = meta.Static(naked.LoadBalancerSettingsUpdate{})
    74  
    75  	loadBalancerView = &dsl.Model{
    76  		Name:      loadBalancerAPIName,
    77  		NakedType: loadBalancerNakedType,
    78  		Fields: []*dsl.FieldDesc{
    79  			fields.ID(),
    80  			fields.Name(),
    81  			fields.Description(),
    82  			fields.Tags(),
    83  			fields.Availability(),
    84  			fields.Class(),
    85  			fields.IconID(),
    86  			fields.CreatedAt(),
    87  			fields.ModifiedAt(),
    88  			// instance
    89  			fields.InstanceHostName(),
    90  			fields.InstanceHostInfoURL(),
    91  			fields.InstanceStatus(),
    92  			fields.InstanceStatusChangedAt(),
    93  			// interfaces
    94  			// fields.Interfaces(),
    95  			// plan
    96  			fields.AppliancePlanID(),
    97  			// switch
    98  			fields.ApplianceSwitchID(),
    99  			// remark
   100  			fields.RemarkDefaultRoute(),
   101  			fields.RemarkNetworkMaskLen(),
   102  			fields.RemarkServerIPAddress(),
   103  			fields.RemarkZoneID(),
   104  			fields.RemarkVRID(),
   105  			// settings
   106  			fields.LoadBalancerVIP(),
   107  			fields.SettingsHash(),
   108  			// interfaces
   109  			fields.Interfaces(),
   110  		},
   111  	}
   112  
   113  	loadBalancerCreateParam = &dsl.Model{
   114  		Name:      names.CreateParameterName(loadBalancerAPIName),
   115  		NakedType: loadBalancerNakedType,
   116  		ConstFields: []*dsl.ConstFieldDesc{
   117  			{
   118  				Name:  "Class",
   119  				Type:  meta.TypeString,
   120  				Value: `"loadbalancer"`,
   121  			},
   122  		},
   123  		Fields: []*dsl.FieldDesc{
   124  			fields.ApplianceSwitchID(),
   125  			fields.AppliancePlanID(),
   126  			fields.RemarkVRID(),
   127  			fields.ApplianceIPAddresses(),
   128  			fields.RemarkNetworkMaskLen(),
   129  			fields.RemarkDefaultRoute(),
   130  			fields.Name(),
   131  			fields.Description(),
   132  			fields.Tags(),
   133  			fields.IconID(),
   134  			fields.LoadBalancerVIP(),
   135  		},
   136  	}
   137  
   138  	loadBalancerUpdateParam = &dsl.Model{
   139  		Name:      names.UpdateParameterName(loadBalancerAPIName),
   140  		NakedType: loadBalancerNakedType,
   141  		Fields: []*dsl.FieldDesc{
   142  			// common fields
   143  			fields.Name(),
   144  			fields.Description(),
   145  			fields.Tags(),
   146  			fields.IconID(),
   147  
   148  			// settings
   149  			fields.LoadBalancerVIP(),
   150  			// settings hash
   151  			fields.SettingsHash(),
   152  		},
   153  	}
   154  
   155  	loadBalancerUpdateSettingsParam = &dsl.Model{
   156  		Name:      names.UpdateSettingsParameterName(loadBalancerAPIName),
   157  		NakedType: loadBalancerNakedType,
   158  		Fields: []*dsl.FieldDesc{
   159  			// settings
   160  			fields.LoadBalancerVIP(),
   161  			// settings hash
   162  			fields.SettingsHash(),
   163  		},
   164  	}
   165  
   166  	loadBalancerStatus = &dsl.Model{
   167  		Name: "LoadBalancerStatus",
   168  		Fields: []*dsl.FieldDesc{
   169  			{
   170  				Name: "VirtualIPAddress",
   171  				Type: meta.TypeString,
   172  			},
   173  			{
   174  				Name: "Port",
   175  				Type: meta.TypeStringNumber,
   176  			},
   177  			{
   178  				Name: "CPS",
   179  				Type: meta.TypeStringNumber,
   180  			},
   181  			{
   182  				Name: "Servers",
   183  				Type: &dsl.Model{
   184  					Name:    "LoadBalancerServerStatus",
   185  					IsArray: true,
   186  					Fields: []*dsl.FieldDesc{
   187  						fields.Def("ActiveConn", meta.TypeStringNumber),
   188  						fields.Def("Status", meta.TypeInstanceStatus),
   189  						fields.Def("IPAddress", meta.TypeString),
   190  						fields.Def("Port", meta.TypeStringNumber),
   191  						fields.Def("CPS", meta.TypeStringNumber),
   192  					},
   193  				},
   194  				Tags: &dsl.FieldTags{
   195  					MapConv: ",recursive",
   196  				},
   197  			},
   198  		},
   199  		NakedType: meta.Static(naked.LoadBalancerStatus{}),
   200  	}
   201  )