mirror of
https://github.com/go-micro/go-micro.git
synced 2025-05-19 21:23:04 +02:00
5d5aee1f08
set the go version to 1.16 in pr.yml and tests.yml, so as to be consistent with the version in go.mod.
105 lines
2.7 KiB
Go
105 lines
2.7 KiB
Go
package client
|
|
|
|
import (
|
|
"crypto/x509"
|
|
"encoding/pem"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
"text/template"
|
|
)
|
|
|
|
// renderTemplateFile renders template for a given resource into writer w
|
|
func renderTemplate(resource string, w io.Writer, data interface{}) error {
|
|
t := template.Must(template.New("kubernetes").Parse(templates[resource]))
|
|
|
|
if err := t.Execute(w, data); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// COPIED FROM
|
|
// https://github.com/kubernetes/kubernetes/blob/7a725418af4661067b56506faabc2d44c6d7703a/pkg/util/crypto/crypto.go
|
|
|
|
// CertPoolFromFile returns an x509.CertPool containing the certificates in the given PEM-encoded file.
|
|
// Returns an error if the file could not be read, a certificate could not be parsed, or if the file does not contain any certificates
|
|
func CertPoolFromFile(filename string) (*x509.CertPool, error) {
|
|
certs, err := certificatesFromFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pool := x509.NewCertPool()
|
|
for _, cert := range certs {
|
|
pool.AddCert(cert)
|
|
}
|
|
return pool, nil
|
|
}
|
|
|
|
// certificatesFromFile returns the x509.Certificates contained in the given PEM-encoded file.
|
|
// Returns an error if the file could not be read, a certificate could not be parsed, or if the file does not contain any certificates
|
|
func certificatesFromFile(file string) ([]*x509.Certificate, error) {
|
|
if len(file) == 0 {
|
|
return nil, errors.New("error reading certificates from an empty filename")
|
|
}
|
|
pemBlock, err := os.ReadFile(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
certs, err := CertsFromPEM(pemBlock)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading %s: %s", file, err)
|
|
}
|
|
return certs, nil
|
|
}
|
|
|
|
// CertsFromPEM returns the x509.Certificates contained in the given PEM-encoded byte array
|
|
// Returns an error if a certificate could not be parsed, or if the data does not contain any certificates
|
|
func CertsFromPEM(pemCerts []byte) ([]*x509.Certificate, error) {
|
|
ok := false
|
|
certs := []*x509.Certificate{}
|
|
for len(pemCerts) > 0 {
|
|
var block *pem.Block
|
|
block, pemCerts = pem.Decode(pemCerts)
|
|
if block == nil {
|
|
break
|
|
}
|
|
// Only use PEM "CERTIFICATE" blocks without extra headers
|
|
if block.Type != "CERTIFICATE" || len(block.Headers) != 0 {
|
|
continue
|
|
}
|
|
|
|
cert, err := x509.ParseCertificate(block.Bytes)
|
|
if err != nil {
|
|
return certs, err
|
|
}
|
|
|
|
certs = append(certs, cert)
|
|
ok = true
|
|
}
|
|
|
|
if !ok {
|
|
return certs, errors.New("could not read any certificates")
|
|
}
|
|
return certs, nil
|
|
}
|
|
|
|
// Format is used to format a string value into a k8s valid name
|
|
func Format(v string) string {
|
|
// to lower case
|
|
v = strings.ToLower(v)
|
|
// / to dashes
|
|
v = strings.ReplaceAll(v, "/", "-")
|
|
// dots to dashes
|
|
v = strings.ReplaceAll(v, ".", "-")
|
|
// limit to 253 chars
|
|
if len(v) > 253 {
|
|
v = v[:253]
|
|
}
|
|
// return new name
|
|
return v
|
|
}
|