planetscale 0.3.1 → 0.3.3

data/vendor/github.com/planetscale/planetscale-go/planetscale/branches.go

@@ -1,252 +0,0 @@
-package planetscale
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/pkg/errors"
-)
-
-// DatabaseBranch represents a database branch.
-type DatabaseBranch struct {
-	Name         string    `json:"name"`
-	ParentBranch string    `json:"parent_branch"`
-	Region       Region    `json:"region"`
-	CreatedAt    time.Time `json:"created_at"`
-	UpdatedAt    time.Time `json:"updated_at"`
-	Status       string    `json:"status,omitempty"`
-}
-
-type databaseBranchesResponse struct {
-	Branches []*DatabaseBranch `json:"data"`
-}
-
-// CreateDatabaseBranchRequest encapsulates the request for creating a new
-// database branch
-type CreateDatabaseBranchRequest struct {
-	Organization string `json:"-"`
-	Database     string `json:"-"`
-	Region       string `json:"region,omitempty"`
-	Name         string `json:"name"`
-	ParentBranch string `json:"parent_branch"`
-}
-
-// ListDatabaseBranchesRequest encapsulates the request for listing the branches
-// of a database.
-type ListDatabaseBranchesRequest struct {
-	Organization string
-	Database     string
-}
-
-// GetDatabaseBranchRequest encapsulates the request for getting a single
-// database branch for a database.
-type GetDatabaseBranchRequest struct {
-	Organization string
-	Database     string
-	Branch       string
-}
-
-// DeleteDatabaseRequest encapsulates the request for deleting a database branch
-// from a database.
-type DeleteDatabaseBranchRequest struct {
-	Organization string
-	Database     string
-	Branch       string
-}
-
-// GetDatabaseBranchStatusRequest encapsulates the request for getting the status
-// of a specific database branch.
-type GetDatabaseBranchStatusRequest struct {
-	Organization string
-	Database     string
-	Branch       string
-}
-
-// DiffBranchRequest encapsulates a request for getting the diff for a branch.
-type DiffBranchRequest struct {
-	Organization string `json:"-"`
-	Database     string `json:"-"`
-	Branch       string `json:"-"`
-}
-
-// BranchSchemaRequest encapsulates a request for getting a branch's schema.
-type BranchSchemaRequest struct {
-	Organization string `json:"-"`
-	Database     string `json:"-"`
-	Branch       string `json:"-"`
-}
-
-// RefreshSchemaRequest reflects the request needed to refresh a schema
-// snapshot on a database branch.
-type RefreshSchemaRequest struct {
-	Organization string `json:"-"`
-	Database     string `json:"-"`
-	Branch       string `json:"-"`
-}
-
-// DatabaseBranchesService is an interface for communicating with the PlanetScale
-// Database Branch API endpoint.
-type DatabaseBranchesService interface {
-	Create(context.Context, *CreateDatabaseBranchRequest) (*DatabaseBranch, error)
-	List(context.Context, *ListDatabaseBranchesRequest) ([]*DatabaseBranch, error)
-	Get(context.Context, *GetDatabaseBranchRequest) (*DatabaseBranch, error)
-	Delete(context.Context, *DeleteDatabaseBranchRequest) error
-	GetStatus(context.Context, *GetDatabaseBranchStatusRequest) (*DatabaseBranchStatus, error)
-	Diff(context.Context, *DiffBranchRequest) ([]*Diff, error)
-	Schema(context.Context, *BranchSchemaRequest) ([]*Diff, error)
-	RefreshSchema(context.Context, *RefreshSchemaRequest) error
-}
-
-type databaseBranchesService struct {
-	client *Client
-}
-
-// DatabaseBranchStatus represents the status of a PlanetScale database branch.
-type DatabaseBranchStatus struct {
-	Ready bool `json:"ready"`
-}
-
-var _ DatabaseBranchesService = &databaseBranchesService{}
-
-func NewDatabaseBranchesService(client *Client) *databaseBranchesService {
-	return &databaseBranchesService{
-		client: client,
-	}
-}
-
-func (d *databaseBranchesService) Diff(ctx context.Context, diffReq *DiffBranchRequest) ([]*Diff, error) {
-	path := fmt.Sprintf("%s/diff", databaseBranchAPIPath(diffReq.Organization, diffReq.Database, diffReq.Branch))
-	req, err := d.client.newRequest(http.MethodGet, path, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating http request")
-	}
-
-	diffs := &diffResponse{}
-	if err := d.client.do(ctx, req, &diffs); err != nil {
-		return nil, err
-	}
-
-	return diffs.Diffs, nil
-}
-
-// schemaResponse returns the schemas
-type schemaResponse struct {
-	Schemas []*Diff `json:"data"`
-}
-
-func (d *databaseBranchesService) Schema(ctx context.Context, schemaReq *BranchSchemaRequest) ([]*Diff, error) {
-	path := fmt.Sprintf("%s/schema", databaseBranchAPIPath(schemaReq.Organization, schemaReq.Database, schemaReq.Branch))
-	req, err := d.client.newRequest(http.MethodGet, path, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating http request")
-	}
-
-	schemas := &schemaResponse{}
-	if err := d.client.do(ctx, req, &schemas); err != nil {
-		return nil, err
-	}
-
-	return schemas.Schemas, nil
-}
-
-// Create creates a new branch for an organization's database.
-func (d *databaseBranchesService) Create(ctx context.Context, createReq *CreateDatabaseBranchRequest) (*DatabaseBranch, error) {
-	path := databaseBranchesAPIPath(createReq.Organization, createReq.Database)
-
-	req, err := d.client.newRequest(http.MethodPost, path, createReq)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating request for branch database")
-	}
-
-	dbBranch := &DatabaseBranch{}
-	if err := d.client.do(ctx, req, &dbBranch); err != nil {
-		return nil, err
-	}
-
-	return dbBranch, nil
-}
-
-// Get returns a database branch for an organization's database.
-func (d *databaseBranchesService) Get(ctx context.Context, getReq *GetDatabaseBranchRequest) (*DatabaseBranch, error) {
-	path := fmt.Sprintf("%s/%s", databaseBranchesAPIPath(getReq.Organization, getReq.Database), getReq.Branch)
-	req, err := d.client.newRequest(http.MethodGet, path, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating http request")
-	}
-
-	dbBranch := &DatabaseBranch{}
-	if err := d.client.do(ctx, req, &dbBranch); err != nil {
-		return nil, err
-	}
-
-	return dbBranch, nil
-}
-
-// List returns all of the branches for an organization's
-// database.
-func (d *databaseBranchesService) List(ctx context.Context, listReq *ListDatabaseBranchesRequest) ([]*DatabaseBranch, error) {
-	req, err := d.client.newRequest(http.MethodGet, databaseBranchesAPIPath(listReq.Organization, listReq.Database), nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating http request")
-	}
-
-	dbBranches := &databaseBranchesResponse{}
-	if err := d.client.do(ctx, req, &dbBranches); err != nil {
-		return nil, err
-	}
-
-	return dbBranches.Branches, nil
-}
-
-// Delete deletes a database branch from an organization's database.
-func (d *databaseBranchesService) Delete(ctx context.Context, deleteReq *DeleteDatabaseBranchRequest) error {
-	path := fmt.Sprintf("%s/%s", databaseBranchesAPIPath(deleteReq.Organization, deleteReq.Database), deleteReq.Branch)
-	req, err := d.client.newRequest(http.MethodDelete, path, nil)
-	if err != nil {
-		return errors.Wrap(err, "error creating request for delete branch")
-	}
-
-	err = d.client.do(ctx, req, nil)
-	return err
-}
-
-// Status returns the status of a specific database branch
-func (d *databaseBranchesService) GetStatus(ctx context.Context, statusReq *GetDatabaseBranchStatusRequest) (*DatabaseBranchStatus, error) {
-	path := fmt.Sprintf("%s/%s/status", databaseBranchesAPIPath(statusReq.Organization, statusReq.Database), statusReq.Branch)
-	req, err := d.client.newRequest(http.MethodGet, path, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating request for branch status")
-	}
-
-	status := &DatabaseBranchStatus{}
-	if err := d.client.do(ctx, req, &status); err != nil {
-		return nil, err
-	}
-
-	return status, nil
-}
-
-// RefreshSchema refreshes the schema for a
-func (d *databaseBranchesService) RefreshSchema(ctx context.Context, refreshReq *RefreshSchemaRequest) error {
-	path := fmt.Sprintf("%s/%s/refresh-schema", databaseBranchesAPIPath(refreshReq.Organization, refreshReq.Database), refreshReq.Branch)
-	req, err := d.client.newRequest(http.MethodPost, path, nil)
-	if err != nil {
-		return errors.Wrap(err, "error creating http request")
-	}
-
-	if err := d.client.do(ctx, req, nil); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func databaseBranchesAPIPath(org, db string) string {
-	return fmt.Sprintf("%s/%s/branches", databasesAPIPath(org), db)
-}
-
-func databaseBranchAPIPath(org, db, branch string) string {
-	return fmt.Sprintf("%s/%s", databaseBranchesAPIPath(org, db), branch)
-}

data/vendor/github.com/planetscale/planetscale-go/planetscale/certs.go

@@ -1,166 +0,0 @@
-package planetscale
-
-import (
-	"bytes"
-	"context"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"fmt"
-	"net/http"
-)
-
-type CreateCertificateRequest struct {
-	Organization string
-	DatabaseName string
-	Branch       string
-
-	// PrivateKey is used to generate the Certificate Sign Request (CSR).
-	PrivateKey crypto.PrivateKey
-}
-
-type CertificatesService interface {
-	Create(context.Context, *CreateCertificateRequest) (*Cert, error)
-}
-
-type Cert struct {
-	ClientCert tls.Certificate
-	CACerts    []*x509.Certificate
-	RemoteAddr string
-	Ports      RemotePorts
-}
-
-type RemotePorts struct {
-	Proxy int
-	MySQL int
-}
-
-type certificatesService struct {
-	client *Client
-}
-
-var _ CertificatesService = &certificatesService{}
-
-func NewCertsService(client *Client) *certificatesService {
-	return &certificatesService{
-		client: client,
-	}
-}
-
-func (c *certificatesService) Create(ctx context.Context, r *CreateCertificateRequest) (*Cert, error) {
-	cn := fmt.Sprintf("%s/%s/%s", r.Organization, r.DatabaseName, r.Branch)
-	subj := pkix.Name{
-		CommonName: cn,
-	}
-
-	switch priv := r.PrivateKey.(type) {
-	case *rsa.PrivateKey:
-	case *ecdsa.PrivateKey:
-	default:
-		return nil, fmt.Errorf("unsupported key type: %T, only supports ECDSA and RSA private keys", priv)
-	}
-
-	template := x509.CertificateRequest{
-		Version: 1,
-		Subject: subj,
-	}
-
-	csrBytes, err := x509.CreateCertificateRequest(rand.Reader, &template, r.PrivateKey)
-	if err != nil {
-		return nil, fmt.Errorf("unable to create csr: %s", err)
-	}
-
-	var buf bytes.Buffer
-	err = pem.Encode(&buf, &pem.Block{Type: "CERTIFICATE REQUEST", Bytes: csrBytes})
-	if err != nil {
-		return nil, fmt.Errorf("unable to encode the CSR to PEM: %s", err)
-	}
-
-	var certReq = struct {
-		CSR string `json:"csr"`
-	}{
-		CSR: buf.String(),
-	}
-
-	req, err := c.client.newRequest(
-		http.MethodPost,
-		fmt.Sprintf("%s/%s/branches/%s/create-certificate",
-			databasesAPIPath(r.Organization),
-			r.DatabaseName,
-			r.Branch,
-		),
-		certReq,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("error creating request for create certificates: %s", err)
-	}
-
-	var cr struct {
-		Certificate      string         `json:"certificate"`
-		CertificateChain string         `json:"certificate_chain"`
-		RemoteAddr       string         `json:"remote_addr"`
-		Ports            map[string]int `json:"ports"`
-	}
-
-	err = c.client.do(ctx, req, &cr)
-	if err != nil {
-		return nil, err
-	}
-
-	caCerts, err := parseCerts(cr.CertificateChain)
-	if err != nil {
-		return nil, fmt.Errorf("parsing certificate chain failed: %s", err)
-	}
-
-	privateKeyBytes, err := x509.MarshalPKCS8PrivateKey(r.PrivateKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal private key: %s", err)
-	}
-
-	privateKey := pem.EncodeToMemory(
-		&pem.Block{
-			Type:  "PRIVATE KEY",
-			Bytes: privateKeyBytes,
-		},
-	)
-
-	clientCert, err := tls.X509KeyPair([]byte(cr.Certificate), privateKey)
-	if err != nil {
-		return nil, fmt.Errorf("parsing client certificate failed: %s", err)
-	}
-
-	return &Cert{
-		ClientCert: clientCert,
-		CACerts:    caCerts,
-		RemoteAddr: cr.RemoteAddr,
-		Ports: RemotePorts{
-			Proxy: cr.Ports["proxy"],
-			MySQL: cr.Ports["mysql-tls"],
-		},
-	}, nil
-}
-
-func parseCerts(pemCert string) ([]*x509.Certificate, error) {
-	perCertBlock := []byte(pemCert)
-	var certs []*x509.Certificate
-
-	for {
-		var certBlock *pem.Block
-		certBlock, perCertBlock = pem.Decode(perCertBlock)
-		if certBlock == nil {
-			break
-		}
-		cert, err := x509.ParseCertificate(certBlock.Bytes)
-		if err != nil {
-			return nil, err
-		}
-
-		certs = append(certs, cert)
-	}
-	return certs, nil
-}