github.com/sacloud/libsacloud/v2@v2.32.3/internal/define/webaccel.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/dsl"
    22  	"github.com/sacloud/libsacloud/v2/internal/dsl/meta"
    23  	"github.com/sacloud/libsacloud/v2/sacloud/naked"
    24  	"github.com/sacloud/libsacloud/v2/sacloud/types"
    25  )
    26  
    27  const (
    28  	webAccelAPIName = "WebAccel"
    29  )
    30  
    31  var webaccelAPI = &dsl.Resource{
    32  	Name:       webAccelAPIName,
    33  	PathName:   "", // その他のリソースとURLパターンが異なるため各オペレーションでPathFormatを指定する
    34  	PathSuffix: dsl.WebAccelAPISuffix,
    35  	IsGlobal:   true,
    36  	Operations: dsl.Operations{
    37  		// list
    38  		{
    39  			ResourceName:     webAccelAPIName,
    40  			Name:             "List",
    41  			PathFormat:       "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/site",
    42  			Method:           http.MethodGet,
    43  			UseWrappedResult: true,
    44  			ResponseEnvelope: dsl.ResponseEnvelopePlural(&dsl.EnvelopePayloadDesc{
    45  				Type: webAccelSiteNakedType,
    46  				Name: "Sites",
    47  			}),
    48  			Results: dsl.Results{
    49  				{
    50  					SourceField: "Sites",
    51  					DestField:   names.ResourceFieldName(webAccelSiteView.Name, dsl.PayloadForms.Plural),
    52  					IsPlural:    true,
    53  					Model:       webAccelSiteView,
    54  				},
    55  			},
    56  		},
    57  		// read
    58  		{
    59  			ResourceName: webAccelAPIName,
    60  			Name:         "Read",
    61  			PathFormat:   "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/site/{{.id}}",
    62  			Method:       http.MethodGet,
    63  			Arguments: dsl.Arguments{
    64  				dsl.ArgumentID,
    65  			},
    66  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    67  				Type: webAccelSiteNakedType,
    68  				Name: "Site",
    69  			}),
    70  			Results: dsl.Results{
    71  				{
    72  					SourceField: "Site",
    73  					DestField:   names.ResourceFieldName(webAccelSiteView.Name, dsl.PayloadForms.Singular),
    74  					IsPlural:    false,
    75  					Model:       webAccelSiteView,
    76  				},
    77  			},
    78  		},
    79  		// read certificate
    80  		{
    81  			ResourceName: webAccelAPIName,
    82  			Name:         "ReadCertificate",
    83  			PathFormat:   "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/site/{{.id}}/certificate",
    84  			Method:       http.MethodGet,
    85  			Arguments: dsl.Arguments{
    86  				dsl.ArgumentID,
    87  			},
    88  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    89  				Type: webAccelCertsNakedType,
    90  				Name: "Certificate",
    91  			}),
    92  			Results: dsl.Results{
    93  				{
    94  					SourceField: "Certificate",
    95  					DestField:   "Certificate",
    96  					IsPlural:    false,
    97  					Model:       webAccelCertsView,
    98  				},
    99  			},
   100  		},
   101  		// create certificate
   102  		{
   103  			ResourceName: webAccelAPIName,
   104  			Name:         "CreateCertificate",
   105  			PathFormat:   "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/site/{{.id}}/certificate",
   106  			Method:       http.MethodPost,
   107  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   108  				Type: webAccelCertNakedType,
   109  				Name: "Certificate",
   110  			}),
   111  			Arguments: dsl.Arguments{
   112  				dsl.ArgumentID,
   113  				dsl.MappableArgument("param", webAccelCertParam, "Certificate"),
   114  			},
   115  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   116  				Type: webAccelCertsNakedType,
   117  				Name: "Certificate",
   118  			}),
   119  			Results: dsl.Results{
   120  				{
   121  					SourceField: "Certificate",
   122  					DestField:   "Certificate",
   123  					IsPlural:    false,
   124  					Model:       webAccelCertsView,
   125  				},
   126  			},
   127  		},
   128  		// update certificate
   129  		{
   130  			ResourceName: webAccelAPIName,
   131  			Name:         "UpdateCertificate",
   132  			PathFormat:   "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/site/{{.id}}/certificate",
   133  			Method:       http.MethodPut,
   134  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   135  				Type: webAccelCertNakedType,
   136  				Name: "Certificate",
   137  			}),
   138  			Arguments: dsl.Arguments{
   139  				dsl.ArgumentID,
   140  				dsl.MappableArgument("param", webAccelCertParam, "Certificate"),
   141  			},
   142  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   143  				Type: webAccelCertsNakedType,
   144  				Name: "Certificate",
   145  			}),
   146  			Results: dsl.Results{
   147  				{
   148  					SourceField: "Certificate",
   149  					DestField:   "Certificate",
   150  					IsPlural:    false,
   151  					Model:       webAccelCertsView,
   152  				},
   153  			},
   154  		},
   155  		// delete certificate
   156  		{
   157  			ResourceName: webAccelAPIName,
   158  			Name:         "DeleteCertificate",
   159  			PathFormat:   "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/site/{{.id}}/certificate",
   160  			Method:       http.MethodDelete,
   161  			Arguments: dsl.Arguments{
   162  				dsl.ArgumentID,
   163  			},
   164  		},
   165  		// delete all cache
   166  		{
   167  			ResourceName: webAccelAPIName,
   168  			Name:         "DeleteAllCache",
   169  			PathFormat:   "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/deleteallcache",
   170  			Method:       http.MethodPost,
   171  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   172  				Type: webAccelSiteNakedType,
   173  				Name: "Site",
   174  			}),
   175  			Arguments: dsl.Arguments{
   176  				dsl.MappableArgument("param", webAccelDeleteAllCacheParam, "Site"),
   177  			},
   178  		},
   179  
   180  		// delete cache
   181  		{
   182  			ResourceName:    webAccelAPIName,
   183  			Name:            "DeleteCache",
   184  			PathFormat:      "{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/deletecache",
   185  			Method:          http.MethodPost,
   186  			RequestEnvelope: dsl.RequestEnvelopeFromModel(webAccelDeleteCacheParam),
   187  			Arguments: dsl.Arguments{
   188  				dsl.PassthroughModelArgument("param", webAccelDeleteCacheParam),
   189  			},
   190  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   191  				Type: meta.Static([]*naked.WebAccelDeleteCacheResult{}),
   192  				Name: "Results",
   193  			}),
   194  			Results: dsl.Results{
   195  				{
   196  					SourceField: "Results",
   197  					DestField:   "Results",
   198  					IsPlural:    true,
   199  					Model:       webAccelDeleteCacheResult,
   200  				},
   201  			},
   202  		},
   203  	},
   204  }
   205  
   206  var (
   207  	webAccelSiteNakedType  = meta.Static(naked.WebAccelSite{})
   208  	webAccelCertNakedType  = meta.Static(naked.WebAccelCert{})
   209  	webAccelCertsNakedType = meta.Static(naked.WebAccelCerts{})
   210  
   211  	webAccelSiteView = &dsl.Model{
   212  		Name:      webAccelAPIName,
   213  		NakedType: webAccelSiteNakedType,
   214  		Fields: []*dsl.FieldDesc{
   215  			fields.ID(),
   216  			fields.Name(),
   217  			fields.Def("DomainType", meta.Static(types.EWebAccelDomainType(""))),
   218  			fields.Def("Domain", meta.TypeString),
   219  			fields.Def("Subdomain", meta.TypeString),
   220  			fields.Def("ASCIIDomain", meta.TypeString),
   221  			fields.Def("Origin", meta.TypeString),
   222  			fields.Def("HostHeader", meta.TypeString),
   223  			fields.Def("Status", meta.Static(types.EWebAccelStatus(""))),
   224  			fields.Def("HasCertificate", meta.TypeFlag),
   225  			fields.Def("HasOldCertificate", meta.TypeFlag),
   226  			fields.Def("GibSentInLastWeek", meta.TypeInt64),
   227  			fields.Def("CertValidNotBefore", meta.TypeInt64),
   228  			fields.Def("CertValidNotAfter", meta.TypeInt64),
   229  			fields.CreatedAt(),
   230  		},
   231  	}
   232  
   233  	webAccelCertsView = &dsl.Model{
   234  		Name:      webAccelAPIName + "Certs",
   235  		NakedType: webAccelCertsNakedType,
   236  		Fields: []*dsl.FieldDesc{
   237  			{
   238  				Name: "Current",
   239  				Type: &dsl.Model{
   240  					Name:      webAccelAPIName + "CurrentCert",
   241  					NakedType: meta.Static(naked.WebAccelCert{}),
   242  					IsArray:   false,
   243  					Fields:    webAccelCertViewFields,
   244  				},
   245  			},
   246  			{
   247  				Name: "Old",
   248  				Type: &dsl.Model{
   249  					Name:      webAccelAPIName + "OldCerts",
   250  					NakedType: meta.Static(naked.WebAccelCert{}),
   251  					IsArray:   true,
   252  					Fields:    webAccelCertViewFields,
   253  				},
   254  			},
   255  		},
   256  	}
   257  
   258  	webAccelCertViewFields = []*dsl.FieldDesc{
   259  		fields.ID(),
   260  		fields.Def("SiteID", meta.TypeID),
   261  		fields.Def("CertificateChain", meta.TypeString),
   262  		fields.Def("Key", meta.TypeString),
   263  		fields.Def("CreatedAt", meta.TypeTime),
   264  		fields.Def("UpdatedAt", meta.TypeTime),
   265  		fields.Def("SerialNumber", meta.TypeString),
   266  		fields.Def("NotBefore", meta.TypeInt64),
   267  		fields.Def("NotAfter", meta.TypeInt64),
   268  		{
   269  			Name: "Issuer",
   270  			Type: &dsl.Model{
   271  				Name: "WebAccelCertIssuer",
   272  				Fields: []*dsl.FieldDesc{
   273  					fields.Def("Country", meta.TypeString),
   274  					fields.Def("Organization", meta.TypeString),
   275  					fields.Def("OrganizationalUnit", meta.TypeString),
   276  					fields.Def("CommonName", meta.TypeString),
   277  				},
   278  			},
   279  			Tags: &dsl.FieldTags{
   280  				MapConv: ",recursive",
   281  			},
   282  		},
   283  		{
   284  			Name: "Subject",
   285  			Type: &dsl.Model{
   286  				Name: "WebAccelCertSubject",
   287  				Fields: []*dsl.FieldDesc{
   288  					fields.Def("Country", meta.TypeString),
   289  					fields.Def("Organization", meta.TypeString),
   290  					fields.Def("OrganizationalUnit", meta.TypeString),
   291  					fields.Def("Locality", meta.TypeString),
   292  					fields.Def("Province", meta.TypeString),
   293  					fields.Def("StreetAddress", meta.TypeString),
   294  					fields.Def("PostalCode", meta.TypeString),
   295  					fields.Def("SerialNumber", meta.TypeString),
   296  					fields.Def("CommonName", meta.TypeString),
   297  				},
   298  			},
   299  			Tags: &dsl.FieldTags{
   300  				MapConv: ",recursive",
   301  			},
   302  		},
   303  		fields.Def("DNSNames", meta.TypeStringSlice),
   304  		fields.Def("SHA256Fingerprint", meta.TypeString),
   305  	}
   306  
   307  	webAccelCertParam = &dsl.Model{
   308  		Name:      webAccelAPIName + "CertRequest",
   309  		NakedType: webAccelCertNakedType,
   310  		Fields: []*dsl.FieldDesc{
   311  			fields.Def("CertificateChain", meta.TypeString),
   312  			fields.Def("Key", meta.TypeString),
   313  		},
   314  	}
   315  
   316  	webAccelDeleteAllCacheParam = &dsl.Model{
   317  		Name:      names.RequestParameterName(webAccelAPIName, "DeleteAllCache"),
   318  		NakedType: webAccelSiteNakedType,
   319  		Fields: []*dsl.FieldDesc{
   320  			fields.Def("Domain", meta.TypeString),
   321  		},
   322  	}
   323  
   324  	webAccelDeleteCacheParam = &dsl.Model{
   325  		Name:      names.RequestParameterName(webAccelAPIName, "DeleteCache"),
   326  		NakedType: webAccelSiteNakedType,
   327  		Fields: []*dsl.FieldDesc{
   328  			fields.Def("URL", meta.TypeStringSlice),
   329  		},
   330  	}
   331  
   332  	webAccelDeleteCacheResult = &dsl.Model{
   333  		Name:      webAccelAPIName + "DeleteCacheResult",
   334  		NakedType: meta.Static(naked.WebAccelDeleteCacheResult{}),
   335  		IsArray:   true,
   336  		Fields: []*dsl.FieldDesc{
   337  			fields.Def("URL", meta.TypeString),
   338  			fields.Def("Status", meta.TypeInt),
   339  			fields.Def("Result", meta.TypeString),
   340  		},
   341  	}
   342  )