github.com/sacloud/libsacloud/v2@v2.32.3/internal/define/proxylb.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  	proxyLBAPIName     = "ProxyLB"
    29  	proxyLBAPIPathName = "commonserviceitem"
    30  )
    31  
    32  var proxyLBAPI = &dsl.Resource{
    33  	Name:       proxyLBAPIName,
    34  	PathName:   proxyLBAPIPathName,
    35  	PathSuffix: dsl.CloudAPISuffix,
    36  	IsGlobal:   true,
    37  	Operations: dsl.Operations{
    38  		// find
    39  		ops.FindCommonServiceItem(proxyLBAPIName, proxyLBNakedType, findParameter, proxyLBView),
    40  
    41  		// create
    42  		ops.CreateCommonServiceItem(proxyLBAPIName, proxyLBNakedType, proxyLBCreateParam, proxyLBView),
    43  
    44  		// read
    45  		ops.ReadCommonServiceItem(proxyLBAPIName, proxyLBNakedType, proxyLBView),
    46  
    47  		// update
    48  		ops.UpdateCommonServiceItem(proxyLBAPIName, proxyLBNakedType, proxyLBUpdateParam, proxyLBView),
    49  		// updateSettings
    50  		ops.UpdateCommonServiceItemSettings(proxyLBAPIName, proxyLBUpdateSettingsNakedType, proxyLBUpdateSettingsParam, proxyLBView),
    51  
    52  		// delete
    53  		ops.Delete(proxyLBAPIName),
    54  
    55  		// change plan
    56  		{
    57  			ResourceName: proxyLBAPIName,
    58  			Name:         "ChangePlan",
    59  			PathFormat:   dsl.IDAndSuffixPathFormat("plan"),
    60  			Method:       http.MethodPut,
    61  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
    62  				Type: proxyLBChangePlanNakedType,
    63  				Name: "CommonServiceItem",
    64  			}),
    65  			Arguments: dsl.Arguments{
    66  				dsl.ArgumentID,
    67  				dsl.MappableArgument("param", proxyLBChangePlanParam, "CommonServiceItem"),
    68  			},
    69  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    70  				Type: proxyLBNakedType,
    71  				Name: "CommonServiceItem",
    72  			}),
    73  			Results: dsl.Results{
    74  				{
    75  					SourceField: "CommonServiceItem",
    76  					DestField:   proxyLBView.Name,
    77  					IsPlural:    false,
    78  					Model:       proxyLBView,
    79  				},
    80  			},
    81  		},
    82  
    83  		// get certificates
    84  		{
    85  			ResourceName: proxyLBAPIName,
    86  			Name:         "GetCertificates",
    87  			PathFormat:   dsl.IDAndSuffixPathFormat("proxylb/sslcertificate"),
    88  			Method:       http.MethodGet,
    89  			Arguments: dsl.Arguments{
    90  				dsl.ArgumentID,
    91  			},
    92  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    93  				Type: proxyLBCertificatesNakedType,
    94  				Name: proxyLBAPIName,
    95  			}),
    96  			Results: dsl.Results{
    97  				{
    98  					SourceField: proxyLBAPIName,
    99  					DestField:   proxyLBCertificateView.Name,
   100  					IsPlural:    false,
   101  					Model:       proxyLBCertificateView,
   102  				},
   103  			},
   104  		},
   105  
   106  		// set certificates
   107  		{
   108  			ResourceName: proxyLBAPIName,
   109  			Name:         "SetCertificates",
   110  			PathFormat:   dsl.IDAndSuffixPathFormat("proxylb/sslcertificate"),
   111  			Method:       http.MethodPut,
   112  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   113  				Type: proxyLBCertificatesNakedType,
   114  				Name: proxyLBAPIName,
   115  			}),
   116  			Arguments: dsl.Arguments{
   117  				dsl.ArgumentID,
   118  				dsl.MappableArgument("param", proxyLBCertificateSetParam, proxyLBAPIName),
   119  			},
   120  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   121  				Type: proxyLBCertificatesNakedType,
   122  				Name: proxyLBAPIName,
   123  			}),
   124  			Results: dsl.Results{
   125  				{
   126  					SourceField: proxyLBAPIName,
   127  					DestField:   proxyLBCertificateView.Name,
   128  					IsPlural:    false,
   129  					Model:       proxyLBCertificateView,
   130  				},
   131  			},
   132  		},
   133  
   134  		// delete certificates
   135  		{
   136  			ResourceName: proxyLBAPIName,
   137  			Name:         "DeleteCertificates",
   138  			PathFormat:   dsl.IDAndSuffixPathFormat("proxylb/sslcertificate"),
   139  			Method:       http.MethodDelete,
   140  			Arguments: dsl.Arguments{
   141  				dsl.ArgumentID,
   142  			},
   143  		},
   144  
   145  		// renew Let's Encrypt certificates
   146  		ops.WithIDAction(proxyLBAPIName, "RenewLetsEncryptCert", http.MethodPut, "proxylb/letsencryptrenew"),
   147  
   148  		// Health
   149  		ops.HealthStatus(proxyLBAPIName, meta.Static(naked.ProxyLBHealth{}), proxyLBHealth),
   150  
   151  		// Monitor
   152  		ops.MonitorChild(proxyLBAPIName, "Connection", "activity/proxylb",
   153  			monitorParameter, monitors.connectionModel()),
   154  	},
   155  }
   156  
   157  var (
   158  	proxyLBNakedType               = meta.Static(naked.ProxyLB{})
   159  	proxyLBUpdateSettingsNakedType = meta.Static(naked.ProxyLBSettingsUpdate{})
   160  	proxyLBChangePlanNakedType     = meta.Static(naked.ProxyLBPlanChange{})
   161  	proxyLBCertificatesNakedType   = meta.Static(naked.ProxyLBCertificates{})
   162  
   163  	proxyLBView = &dsl.Model{
   164  		Name:      proxyLBAPIName,
   165  		NakedType: proxyLBNakedType,
   166  		Fields: []*dsl.FieldDesc{
   167  			fields.ID(),
   168  			fields.Name(),
   169  			fields.Description(),
   170  			fields.Tags(),
   171  			fields.Availability(),
   172  			fields.IconID(),
   173  			fields.CreatedAt(),
   174  			fields.ModifiedAt(),
   175  
   176  			fields.ProxyLBPlan(),
   177  
   178  			// settings
   179  			fields.ProxyLBHealthCheck(),
   180  			fields.ProxyLBSorryServer(),
   181  			fields.ProxyLBBindPorts(),
   182  			fields.ProxyLBServers(),
   183  			fields.ProxyLBRules(),
   184  			fields.ProxyLBLetsEncrypt(),
   185  			fields.ProxyLBStickySession(),
   186  			fields.ProxyLBGzip(),
   187  			fields.ProxyLBProxyProtocol(),
   188  			fields.ProxyLBSyslog(),
   189  			fields.ProxyLBTimeout(),
   190  			fields.SettingsHash(),
   191  
   192  			// status
   193  			fields.ProxyLBUseVIPFailover(),
   194  			fields.ProxyLBRegion(),
   195  			fields.ProxyLBProxyNetworks(),
   196  			fields.ProxyLBFQDN(),
   197  			fields.ProxyLBVIP(),
   198  		},
   199  	}
   200  
   201  	proxyLBCreateParam = &dsl.Model{
   202  		Name:      names.CreateParameterName(proxyLBAPIName),
   203  		NakedType: proxyLBNakedType,
   204  		ConstFields: []*dsl.ConstFieldDesc{
   205  			{
   206  				Name: "Class",
   207  				Type: meta.TypeString,
   208  				Tags: &dsl.FieldTags{
   209  					MapConv: "Provider.Class",
   210  				},
   211  				Value: `"proxylb"`,
   212  			},
   213  		},
   214  		Fields: []*dsl.FieldDesc{
   215  			// required
   216  			fields.ProxyLBPlan(),
   217  
   218  			// settings
   219  			fields.ProxyLBHealthCheck(),
   220  			fields.ProxyLBSorryServer(),
   221  			fields.ProxyLBBindPorts(),
   222  			fields.ProxyLBServers(),
   223  			fields.ProxyLBRules(),
   224  			fields.ProxyLBLetsEncrypt(),
   225  			fields.ProxyLBStickySession(),
   226  			fields.ProxyLBTimeout(),
   227  			fields.ProxyLBGzip(),
   228  			fields.ProxyLBProxyProtocol(),
   229  			fields.ProxyLBSyslog(),
   230  			// status
   231  			fields.ProxyLBUseVIPFailover(),
   232  			fields.ProxyLBRegion(),
   233  
   234  			// common fields
   235  			fields.Name(),
   236  			fields.Description(),
   237  			fields.Tags(),
   238  			fields.IconID(),
   239  		},
   240  	}
   241  
   242  	proxyLBUpdateParam = &dsl.Model{
   243  		Name:      names.UpdateParameterName(proxyLBAPIName),
   244  		NakedType: proxyLBNakedType,
   245  		Fields: []*dsl.FieldDesc{
   246  
   247  			// settings
   248  			fields.ProxyLBHealthCheck(),
   249  			fields.ProxyLBSorryServer(),
   250  			fields.ProxyLBBindPorts(),
   251  			fields.ProxyLBServers(),
   252  			fields.ProxyLBRules(),
   253  			fields.ProxyLBLetsEncrypt(),
   254  			fields.ProxyLBStickySession(),
   255  			fields.ProxyLBTimeout(),
   256  			fields.ProxyLBGzip(),
   257  			fields.ProxyLBProxyProtocol(),
   258  			fields.ProxyLBSyslog(),
   259  			// settings hash
   260  			fields.SettingsHash(),
   261  
   262  			// common fields
   263  			fields.Name(),
   264  			fields.Description(),
   265  			fields.Tags(),
   266  			fields.IconID(),
   267  		},
   268  	}
   269  
   270  	proxyLBUpdateSettingsParam = &dsl.Model{
   271  		Name:      names.UpdateSettingsParameterName(proxyLBAPIName),
   272  		NakedType: proxyLBNakedType,
   273  		Fields: []*dsl.FieldDesc{
   274  			// settings
   275  			fields.ProxyLBHealthCheck(),
   276  			fields.ProxyLBSorryServer(),
   277  			fields.ProxyLBBindPorts(),
   278  			fields.ProxyLBServers(),
   279  			fields.ProxyLBRules(),
   280  			fields.ProxyLBLetsEncrypt(),
   281  			fields.ProxyLBStickySession(),
   282  			fields.ProxyLBTimeout(),
   283  			fields.ProxyLBGzip(),
   284  			fields.ProxyLBProxyProtocol(),
   285  			fields.ProxyLBSyslog(),
   286  			// settings hash
   287  			fields.SettingsHash(),
   288  		},
   289  	}
   290  
   291  	proxyLBChangePlanParam = &dsl.Model{
   292  		Name:      proxyLBAPIName + "ChangePlanRequest",
   293  		NakedType: proxyLBNakedType,
   294  		Fields: []*dsl.FieldDesc{
   295  			fields.Def("ServiceClass", meta.TypeString),
   296  		},
   297  	}
   298  
   299  	proxyLBCertificateView = &dsl.Model{
   300  		Name:      proxyLBAPIName + "Certificates",
   301  		NakedType: meta.Static(naked.ProxyLBCertificates{}),
   302  		Fields: []*dsl.FieldDesc{
   303  			{
   304  				Name: "PrimaryCert",
   305  				Type: &dsl.Model{
   306  					Name: proxyLBAPIName + "PrimaryCert",
   307  					Fields: []*dsl.FieldDesc{
   308  						fields.Def("ServerCertificate", meta.TypeString),
   309  						fields.Def("IntermediateCertificate", meta.TypeString),
   310  						fields.Def("PrivateKey", meta.TypeString),
   311  						fields.Def("CertificateEndDate", meta.TypeTime),
   312  						fields.Def("CertificateCommonName", meta.TypeString),
   313  						fields.Def("CertificateAltNames", meta.TypeString),
   314  					},
   315  				},
   316  			},
   317  			{
   318  				Name: "AdditionalCerts",
   319  				Type: &dsl.Model{
   320  					Name:    proxyLBAPIName + "AdditionalCert",
   321  					IsArray: true,
   322  					Fields: []*dsl.FieldDesc{
   323  						fields.Def("ServerCertificate", meta.TypeString),
   324  						fields.Def("IntermediateCertificate", meta.TypeString),
   325  						fields.Def("PrivateKey", meta.TypeString),
   326  						fields.Def("CertificateEndDate", meta.TypeTime),
   327  						fields.Def("CertificateCommonName", meta.TypeString),
   328  						fields.Def("CertificateAltNames", meta.TypeString),
   329  					},
   330  				},
   331  				Tags: &dsl.FieldTags{
   332  					MapConv: "[]AdditionalCerts, recursive",
   333  				},
   334  			},
   335  		},
   336  	}
   337  
   338  	proxyLBCertificateSetParam = &dsl.Model{
   339  		Name:      proxyLBAPIName + "SetCertificatesRequest",
   340  		NakedType: meta.Static(naked.ProxyLBCertificates{}),
   341  		Fields: []*dsl.FieldDesc{
   342  			proxyLBPrimaryCertsField,
   343  			proxyLBAdditionalCerts,
   344  		},
   345  	}
   346  
   347  	proxyLBPrimaryCertsField = &dsl.FieldDesc{
   348  		Name: "PrimaryCerts",
   349  		Type: &dsl.Model{
   350  			Name: proxyLBAPIName + "PrimaryCert",
   351  			Fields: []*dsl.FieldDesc{
   352  				fields.Def("ServerCertificate", meta.TypeString),
   353  				fields.Def("IntermediateCertificate", meta.TypeString),
   354  				fields.Def("PrivateKey", meta.TypeString),
   355  			},
   356  		},
   357  		Tags: &dsl.FieldTags{
   358  			MapConv: "PrimaryCert",
   359  		},
   360  	}
   361  
   362  	proxyLBAdditionalCerts = &dsl.FieldDesc{
   363  		Name: "AdditionalCerts",
   364  		Type: &dsl.Model{
   365  			Name:    proxyLBAPIName + "AdditionalCert",
   366  			IsArray: true,
   367  			Fields: []*dsl.FieldDesc{
   368  				fields.Def("ServerCertificate", meta.TypeString),
   369  				fields.Def("IntermediateCertificate", meta.TypeString),
   370  				fields.Def("PrivateKey", meta.TypeString),
   371  			},
   372  		},
   373  		Tags: &dsl.FieldTags{
   374  			MapConv: "[]AdditionalCerts, recursive",
   375  		},
   376  	}
   377  
   378  	proxyLBHealth = &dsl.Model{
   379  		Name: "ProxyLBHealth",
   380  		Fields: []*dsl.FieldDesc{
   381  			fields.Def("ActiveConn", meta.TypeInt),
   382  			fields.Def("CPS", meta.TypeFloat64),
   383  			fields.Def("CurrentVIP", meta.TypeString),
   384  			{
   385  				Name: "Servers",
   386  				Type: &dsl.Model{
   387  					Name:    "LoadBalancerServerStatus",
   388  					IsArray: true,
   389  					Fields: []*dsl.FieldDesc{
   390  						fields.Def("ActiveConn", meta.TypeInt),
   391  						fields.Def("Status", meta.TypeInstanceStatus),
   392  						fields.Def("IPAddress", meta.TypeString),
   393  						fields.Def("Port", meta.TypeStringNumber),
   394  						fields.Def("CPS", meta.TypeFloat64),
   395  					},
   396  				},
   397  				Tags: &dsl.FieldTags{
   398  					MapConv: "[]Servers,recursive",
   399  				},
   400  			},
   401  		},
   402  		NakedType: meta.Static(naked.ProxyLBHealth{}),
   403  	}
   404  )