github.com/sacloud/iaas-api-go@v1.12.0/internal/define/certificate_authority.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  	certificateAuthorityAPIName     = "CertificateAuthority"
    30  	certificateAuthorityAPIPathName = "commonserviceitem"
    31  )
    32  
    33  var certificateAuthorityAPI = &dsl.Resource{
    34  	Name:       certificateAuthorityAPIName,
    35  	PathName:   certificateAuthorityAPIPathName,
    36  	PathSuffix: dsl.CloudAPISuffix,
    37  	IsGlobal:   true,
    38  	Operations: dsl.Operations{
    39  		// find
    40  		ops.FindCommonServiceItem(certificateAuthorityAPIName, certificateAuthorityNakedType, findParameter, certificateAuthorityView),
    41  
    42  		// create
    43  		ops.CreateCommonServiceItem(certificateAuthorityAPIName, certificateAuthorityNakedType, certificateAuthorityCreateParam, certificateAuthorityView),
    44  
    45  		// read
    46  		ops.ReadCommonServiceItem(certificateAuthorityAPIName, certificateAuthorityNakedType, certificateAuthorityView),
    47  
    48  		// update
    49  		ops.UpdateCommonServiceItem(certificateAuthorityAPIName, certificateAuthorityNakedType, certificateAuthorityUpdateParam, certificateAuthorityView),
    50  
    51  		// delete
    52  		ops.Delete(certificateAuthorityAPIName),
    53  
    54  		// ca detail
    55  		{
    56  			ResourceName: certificateAuthorityAPIName,
    57  			Name:         "Detail",
    58  			Method:       http.MethodGet,
    59  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority"),
    60  			Arguments: dsl.Arguments{
    61  				dsl.ArgumentID,
    62  			},
    63  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    64  				Name: "CertificateAuthority",
    65  				Type: meta.Static(naked.CertificateAuthorityDetail{}),
    66  			}),
    67  			Results: dsl.Results{
    68  				{
    69  					SourceField: "CertificateAuthority",
    70  					DestField:   "CertificateAuthority",
    71  					IsPlural:    false,
    72  					Model:       certificateAuthorityDetailModel,
    73  				},
    74  			},
    75  		},
    76  
    77  		/*
    78  		 * Client Certificates
    79  		 */
    80  
    81  		// create/add
    82  		{
    83  			ResourceName: certificateAuthorityAPIName,
    84  			Name:         "AddClient",
    85  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients"),
    86  			Method:       http.MethodPost,
    87  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
    88  				Type: meta.Static(naked.CertificateAuthorityAddClientParameter{}),
    89  				Name: "CertificateAuthority",
    90  			}),
    91  			Arguments: dsl.Arguments{
    92  				dsl.ArgumentID,
    93  				dsl.MappableArgument("param", certificateAuthorityAddClientParam, "CertificateAuthority.Status"),
    94  			},
    95  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    96  				Type: meta.Static(naked.CertificateAuthorityAddClientOrServerResult{}),
    97  				Name: "CertificateAuthority",
    98  			}),
    99  			Results: dsl.Results{
   100  				{
   101  					SourceField: "CertificateAuthority",
   102  					DestField:   "CertificateAuthority",
   103  					IsPlural:    false,
   104  					Model:       certificateAuthorityAddClientOrServerResult,
   105  				},
   106  			},
   107  		},
   108  		// list
   109  		{
   110  			ResourceName: certificateAuthorityAPIName,
   111  			Name:         "ListClients",
   112  			Method:       http.MethodGet,
   113  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients"),
   114  			Arguments: dsl.Arguments{
   115  				dsl.ArgumentID,
   116  			},
   117  			ResponseEnvelope: dsl.ResponseEnvelopePlural(&dsl.EnvelopePayloadDesc{
   118  				Name: "CertificateAuthority",
   119  				Type: meta.Static(naked.CertificateAuthorityClientDetail{}),
   120  			}),
   121  			Results: dsl.Results{
   122  				{
   123  					SourceField: "CertificateAuthority",
   124  					DestField:   "CertificateAuthority",
   125  					IsPlural:    true,
   126  					Model:       certificateAuthorityClientModel,
   127  				},
   128  			},
   129  			UseWrappedResult: true,
   130  		},
   131  		// read
   132  		{
   133  			ResourceName: certificateAuthorityAPIName,
   134  			Name:         "ReadClient",
   135  			Method:       http.MethodGet,
   136  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients/{{.clientID}}"),
   137  			Arguments: dsl.Arguments{
   138  				dsl.ArgumentID,
   139  				{
   140  					Name: "clientID",
   141  					Type: meta.TypeString,
   142  				},
   143  			},
   144  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   145  				Name: "CertificateAuthority",
   146  				Type: meta.Static(naked.CertificateAuthorityClientDetail{}),
   147  			}),
   148  			Results: dsl.Results{
   149  				{
   150  					SourceField: "CertificateAuthority",
   151  					DestField:   "CertificateAuthority",
   152  					Model:       certificateAuthorityClientModel,
   153  				},
   154  			},
   155  		},
   156  
   157  		// revoke
   158  		{
   159  			ResourceName: certificateAuthorityAPIName,
   160  			Name:         "RevokeClient",
   161  			Method:       http.MethodPut,
   162  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients/{{.clientID}}/revoke"),
   163  			Arguments: dsl.Arguments{
   164  				dsl.ArgumentID,
   165  				{
   166  					Name: "clientID",
   167  					Type: meta.TypeString,
   168  				},
   169  			},
   170  		},
   171  		// hold
   172  		{
   173  			ResourceName: certificateAuthorityAPIName,
   174  			Name:         "HoldClient",
   175  			Method:       http.MethodPut,
   176  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients/{{.clientID}}/hold"),
   177  			Arguments: dsl.Arguments{
   178  				dsl.ArgumentID,
   179  				{
   180  					Name: "clientID",
   181  					Type: meta.TypeString,
   182  				},
   183  			},
   184  		},
   185  
   186  		// resume
   187  		{
   188  			ResourceName: certificateAuthorityAPIName,
   189  			Name:         "ResumeClient",
   190  			Method:       http.MethodPut,
   191  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients/{{.clientID}}/resume"),
   192  			Arguments: dsl.Arguments{
   193  				dsl.ArgumentID,
   194  				{
   195  					Name: "clientID",
   196  					Type: meta.TypeString,
   197  				},
   198  			},
   199  		},
   200  
   201  		// deny
   202  		{
   203  			ResourceName: certificateAuthorityAPIName,
   204  			Name:         "DenyClient",
   205  			Method:       http.MethodPut,
   206  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/clients/{{.clientID}}/deny"),
   207  			Arguments: dsl.Arguments{
   208  				dsl.ArgumentID,
   209  				{
   210  					Name: "clientID",
   211  					Type: meta.TypeString,
   212  				},
   213  			},
   214  		},
   215  
   216  		/*
   217  		 * Sercver Certificates
   218  		 */
   219  		// create/add
   220  		{
   221  			ResourceName: certificateAuthorityAPIName,
   222  			Name:         "AddServer",
   223  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/servers"),
   224  			Method:       http.MethodPost,
   225  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   226  				Type: meta.Static(naked.CertificateAuthorityAddServerParameter{}),
   227  				Name: "CertificateAuthority",
   228  			}),
   229  			Arguments: dsl.Arguments{
   230  				dsl.ArgumentID,
   231  				dsl.MappableArgument("param", certificateAuthorityAddServerParam, "CertificateAuthority.Status"),
   232  			},
   233  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   234  				Type: meta.Static(naked.CertificateAuthorityAddClientOrServerResult{}),
   235  				Name: "CertificateAuthority",
   236  			}),
   237  			Results: dsl.Results{
   238  				{
   239  					SourceField: "CertificateAuthority",
   240  					DestField:   "CertificateAuthority",
   241  					IsPlural:    false,
   242  					Model:       certificateAuthorityAddClientOrServerResult,
   243  				},
   244  			},
   245  		},
   246  		// list
   247  		{
   248  			ResourceName: certificateAuthorityAPIName,
   249  			Name:         "ListServers",
   250  			Method:       http.MethodGet,
   251  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/servers"),
   252  			Arguments: dsl.Arguments{
   253  				dsl.ArgumentID,
   254  			},
   255  			ResponseEnvelope: dsl.ResponseEnvelopePlural(&dsl.EnvelopePayloadDesc{
   256  				Name: "CertificateAuthority",
   257  				Type: meta.Static(naked.CertificateAuthorityServerDetail{}),
   258  			}),
   259  			Results: dsl.Results{
   260  				{
   261  					SourceField: "CertificateAuthority",
   262  					DestField:   "CertificateAuthority",
   263  					IsPlural:    true,
   264  					Model:       certificateAuthorityServerModel,
   265  				},
   266  			},
   267  			UseWrappedResult: true,
   268  		},
   269  		// read server certs
   270  		{
   271  			ResourceName: certificateAuthorityAPIName,
   272  			Name:         "ReadServer",
   273  			Method:       http.MethodGet,
   274  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/servers/{{.serverID}}"),
   275  			Arguments: dsl.Arguments{
   276  				dsl.ArgumentID,
   277  				{
   278  					Name: "serverID",
   279  					Type: meta.TypeString,
   280  				},
   281  			},
   282  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   283  				Name: "CertificateAuthority",
   284  				Type: meta.Static(naked.CertificateAuthorityServerDetail{}),
   285  			}),
   286  			Results: dsl.Results{
   287  				{
   288  					SourceField: "CertificateAuthority",
   289  					DestField:   "CertificateAuthority",
   290  					Model:       certificateAuthorityServerModel,
   291  				},
   292  			},
   293  		},
   294  		// revoke
   295  		{
   296  			ResourceName: certificateAuthorityAPIName,
   297  			Name:         "RevokeServer",
   298  			Method:       http.MethodPut,
   299  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/servers/{{.serverID}}/revoke"),
   300  			Arguments: dsl.Arguments{
   301  				dsl.ArgumentID,
   302  				{
   303  					Name: "serverID",
   304  					Type: meta.TypeString,
   305  				},
   306  			},
   307  		},
   308  		// hold
   309  		{
   310  			ResourceName: certificateAuthorityAPIName,
   311  			Name:         "HoldServer",
   312  			Method:       http.MethodPut,
   313  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/servers/{{.serverID}}/hold"),
   314  			Arguments: dsl.Arguments{
   315  				dsl.ArgumentID,
   316  				{
   317  					Name: "serverID",
   318  					Type: meta.TypeString,
   319  				},
   320  			},
   321  		},
   322  		// resume
   323  		{
   324  			ResourceName: certificateAuthorityAPIName,
   325  			Name:         "ResumeServer",
   326  			Method:       http.MethodPut,
   327  			PathFormat:   dsl.IDAndSuffixPathFormat("certificateauthority/servers/{{.serverID}}/resume"),
   328  			Arguments: dsl.Arguments{
   329  				dsl.ArgumentID,
   330  				{
   331  					Name: "serverID",
   332  					Type: meta.TypeString,
   333  				},
   334  			},
   335  		},
   336  	},
   337  }
   338  
   339  var (
   340  	certificateAuthorityNakedType = meta.Static(naked.CertificateAuthority{})
   341  
   342  	certificateAuthorityView = &dsl.Model{
   343  		Name:      certificateAuthorityAPIName,
   344  		NakedType: certificateAuthorityNakedType,
   345  		Fields: []*dsl.FieldDesc{
   346  			fields.ID(),
   347  			fields.Name(),
   348  			fields.Description(),
   349  			fields.Tags(),
   350  			fields.Availability(),
   351  			fields.IconID(),
   352  			fields.CreatedAt(),
   353  			fields.ModifiedAt(),
   354  
   355  			// status
   356  			fields.CAStatusCountry(),
   357  			fields.CAStatusOrganization(),
   358  			fields.CAStatusOrganizationUnit(),
   359  			fields.CAStatusCommonName(),
   360  			fields.CAStatusNotAfter(),
   361  			fields.CAStatusSubject(),
   362  		},
   363  	}
   364  
   365  	certificateAuthorityCreateParam = &dsl.Model{
   366  		Name:      names.CreateParameterName(certificateAuthorityAPIName),
   367  		NakedType: certificateAuthorityNakedType,
   368  		ConstFields: []*dsl.ConstFieldDesc{
   369  			{
   370  				Name: "Class",
   371  				Type: meta.TypeString,
   372  				Tags: &dsl.FieldTags{
   373  					MapConv: "Provider.Class",
   374  				},
   375  				Value: `"certificateauthority"`,
   376  			},
   377  		},
   378  		Fields: []*dsl.FieldDesc{
   379  			// common fields
   380  			fields.Name(),
   381  			fields.Description(),
   382  			fields.Tags(),
   383  			fields.IconID(),
   384  
   385  			// status
   386  			fields.CAStatusCountry(),
   387  			fields.CAStatusOrganization(),
   388  			fields.CAStatusOrganizationUnit(),
   389  			fields.CAStatusCommonName(),
   390  			fields.CAStatusNotAfter(),
   391  		},
   392  	}
   393  
   394  	certificateAuthorityUpdateParam = &dsl.Model{
   395  		Name:      names.UpdateParameterName(certificateAuthorityAPIName),
   396  		NakedType: certificateAuthorityNakedType,
   397  		Fields: []*dsl.FieldDesc{
   398  			// common fields
   399  			fields.Name(),
   400  			fields.Description(),
   401  			fields.Tags(),
   402  			fields.IconID(),
   403  		},
   404  	}
   405  
   406  	certificateAuthorityCertificateData = &dsl.Model{
   407  		Name:      "CertificateData",
   408  		NakedType: meta.Static(naked.CertificateData{}),
   409  		Fields: []*dsl.FieldDesc{
   410  			fields.Def("CertificatePEM", meta.TypeString),
   411  			fields.Def("Subject", meta.TypeString),
   412  			fields.Def("SerialNumber", meta.TypeString),
   413  			fields.Def("NotBefore", meta.TypeTime),
   414  			fields.Def("NotAfter", meta.TypeTime),
   415  		},
   416  	}
   417  	certificateAuthorityDetailModel = &dsl.Model{
   418  		Name:      "CertificateAuthorityDetail",
   419  		NakedType: meta.Static(naked.CertificateAuthorityDetail{}),
   420  		Fields: []*dsl.FieldDesc{
   421  			fields.Def("Subject", meta.TypeString),
   422  			fields.Def("CertificateData", certificateAuthorityCertificateData, &dsl.FieldTags{MapConv: ",recursive"}),
   423  		},
   424  	}
   425  
   426  	certificateAuthorityAddClientParam = &dsl.Model{
   427  		Name:      "CertificateAuthorityAddClientParam",
   428  		NakedType: meta.Static(naked.CertificateAuthorityAddClientParameterBody{}),
   429  		Fields: []*dsl.FieldDesc{
   430  			fields.Def("Country", meta.TypeString),
   431  			fields.Def("Organization", meta.TypeString),
   432  			fields.Def("OrganizationUnit", meta.TypeStringSlice),
   433  			fields.Def("CommonName", meta.TypeString),
   434  			fields.Def("NotAfter", meta.TypeTime),
   435  			fields.Def("IssuanceMethod", meta.Static(types.ECertificateAuthorityIssuanceMethod(""))),
   436  
   437  			fields.Def("EMail", meta.TypeString),
   438  			fields.Def("CertificateSigningRequest", meta.TypeString),
   439  			fields.Def("PublicKey", meta.TypeString),
   440  		},
   441  	}
   442  
   443  	certificateAuthorityClientModel = &dsl.Model{
   444  		Name:      "CertificateAuthorityClient",
   445  		NakedType: meta.Static(naked.CertificateAuthorityClientDetail{}),
   446  		Fields: []*dsl.FieldDesc{
   447  			fields.Def("ID", meta.TypeString),
   448  			fields.Def("Subject", meta.TypeString),
   449  			fields.Def("EMail", meta.TypeString),
   450  			fields.Def("IssuanceMethod", meta.Static(types.ECertificateAuthorityIssuanceMethod(""))),
   451  			fields.Def("IssueState", meta.TypeString),
   452  			fields.Def("URL", meta.TypeString),
   453  			fields.Def("CertificateData", certificateAuthorityCertificateData, &dsl.FieldTags{MapConv: ",recursive"}),
   454  		},
   455  	}
   456  
   457  	certificateAuthorityAddServerParam = &dsl.Model{
   458  		Name:      "CertificateAuthorityAddServerParam",
   459  		NakedType: meta.Static(naked.CertificateAuthorityAddClientParameterBody{}),
   460  		Fields: []*dsl.FieldDesc{
   461  			fields.Def("Country", meta.TypeString),
   462  			fields.Def("Organization", meta.TypeString),
   463  			fields.Def("OrganizationUnit", meta.TypeStringSlice),
   464  			fields.Def("CommonName", meta.TypeString),
   465  			fields.Def("NotAfter", meta.TypeTime),
   466  			fields.Def("SANs", meta.TypeStringSlice),
   467  
   468  			fields.Def("CertificateSigningRequest", meta.TypeString),
   469  			fields.Def("PublicKey", meta.TypeString),
   470  		},
   471  	}
   472  	certificateAuthorityServerModel = &dsl.Model{
   473  		Name:      "CertificateAuthorityServer",
   474  		NakedType: meta.Static(naked.CertificateAuthorityServerDetail{}),
   475  		Fields: []*dsl.FieldDesc{
   476  			fields.Def("ID", meta.TypeString),
   477  			fields.Def("Subject", meta.TypeString),
   478  			fields.Def("SANs", meta.TypeStringSlice),
   479  			fields.Def("EMail", meta.TypeString),
   480  			fields.Def("IssueState", meta.TypeString),
   481  			fields.Def("CertificateData", certificateAuthorityCertificateData, &dsl.FieldTags{MapConv: ",recursive"}),
   482  		},
   483  	}
   484  
   485  	certificateAuthorityAddClientOrServerResult = &dsl.Model{
   486  		Name:      "CertificateAuthorityAddClientOrServerResult",
   487  		NakedType: meta.Static(naked.CertificateAuthorityAddClientOrServerResult{}),
   488  		Fields: []*dsl.FieldDesc{
   489  			fields.Def("ID", meta.TypeString),
   490  		},
   491  	}
   492  )