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