planetscale 0.1.0

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

@@ -0,0 +1,139 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+type Backup struct {
+	Name        string    `json:"name"`
+	State       string    `json:"state"`
+	Size        int64     `json:"size"`
+	CreatedAt   time.Time `json:"created_at"`
+	UpdatedAt   time.Time `json:"updated_at"`
+	StartedAt   time.Time `json:"started_at"`
+	ExpiresAt   time.Time `json:"expires_at"`
+	CompletedAt time.Time `json:"completed_at"`
+}
+
+type backupsResponse struct {
+	Backups []*Backup `json:"data"`
+}
+
+type CreateBackupRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type ListBackupsRequest struct {
+	Organization string
+	Database     string
+	Branch       string
+}
+
+type GetBackupRequest struct {
+	Organization string
+	Database     string
+	Branch       string
+	Backup       string
+}
+
+type DeleteBackupRequest struct {
+	Organization string
+	Database     string
+	Branch       string
+	Backup       string
+}
+
+// BackupsService is an interface for communicating with the PlanetScale
+// backup API endpoint.
+type BackupsService interface {
+	Create(context.Context, *CreateBackupRequest) (*Backup, error)
+	List(context.Context, *ListBackupsRequest) ([]*Backup, error)
+	Get(context.Context, *GetBackupRequest) (*Backup, error)
+	Delete(context.Context, *DeleteBackupRequest) error
+}
+
+type backupsService struct {
+	client *Client
+}
+
+var _ BackupsService = &backupsService{}
+
+func NewBackupsService(client *Client) *backupsService {
+	return &backupsService{
+		client: client,
+	}
+}
+
+// Creates a new backup for a branch.
+func (d *backupsService) Create(ctx context.Context, createReq *CreateBackupRequest) (*Backup, error) {
+	path := backupsAPIPath(createReq.Organization, createReq.Database, createReq.Branch)
+	req, err := d.client.newRequest(http.MethodPost, path, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	backup := &Backup{}
+	if err := d.client.do(ctx, req, &backup); err != nil {
+		return nil, err
+	}
+
+	return backup, nil
+}
+
+// Returns a single backup for a branch.
+func (d *backupsService) Get(ctx context.Context, getReq *GetBackupRequest) (*Backup, error) {
+	path := backupAPIPath(getReq.Organization, getReq.Database, getReq.Branch, getReq.Backup)
+	req, err := d.client.newRequest(http.MethodGet, path, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	backup := &Backup{}
+	if err := d.client.do(ctx, req, &backup); err != nil {
+		return nil, err
+	}
+
+	return backup, nil
+}
+
+// Returns all of the backups for a branch.
+func (d *backupsService) List(ctx context.Context, listReq *ListBackupsRequest) ([]*Backup, error) {
+	req, err := d.client.newRequest(http.MethodGet, backupsAPIPath(listReq.Organization, listReq.Database, listReq.Branch), nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	backups := &backupsResponse{}
+	if err := d.client.do(ctx, req, &backups); err != nil {
+		return nil, err
+	}
+
+	return backups.Backups, nil
+}
+
+// Deletes a branch backup.
+func (d *backupsService) Delete(ctx context.Context, deleteReq *DeleteBackupRequest) error {
+	path := backupAPIPath(deleteReq.Organization, deleteReq.Database, deleteReq.Branch, deleteReq.Backup)
+	req, err := d.client.newRequest(http.MethodDelete, path, nil)
+	if err != nil {
+		return errors.Wrap(err, "error creating http request")
+	}
+
+	err = d.client.do(ctx, req, nil)
+	return err
+}
+
+func backupsAPIPath(org, db, branch string) string {
+	return fmt.Sprintf("%s/backups", databaseBranchAPIPath(org, db, branch))
+}
+
+func backupAPIPath(org, db, branch, backup string) string {
+	return fmt.Sprintf("%s/%s", backupsAPIPath(org, db, branch), backup)
+}

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

@@ -0,0 +1,258 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// DatabaseBranch represents a database branch.
+type DatabaseBranch struct {
+	Name         string    `json:"name"`
+	Notes        string    `json:"notes"`
+	ParentBranch string    `json:"parent_branch"`
+	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:"-"`
+	Branch       *DatabaseBranch
+}
+
+// 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
+}
+
+type DatabaseBranchCredentials struct {
+	GatewayHost string `json:"mysql_gateway_host"`
+	GatewayPort int    `json:"mysql_gateway_port"`
+	User        string `json:"mysql_gateway_user"`
+	Password    string `json:"mysql_gateway_pass"`
+}
+
+// DatabaseBranchStatus represents the status of a PlanetScale database branch.
+type DatabaseBranchStatus struct {
+	Ready       bool                      `json:"ready"`
+	Credentials DatabaseBranchCredentials `json:"credentials"`
+}
+
+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.Branch)
+	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

@@ -0,0 +1,142 @@
+package planetscale
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+type CreateCertificateRequest struct {
+	Organization string
+	DatabaseName string
+	Branch       string
+
+	// PrivateKey is used to sign the Certificate Sign Request (CSR).
+	PrivateKey *rsa.PrivateKey
+}
+
+type CertificatesService interface {
+	Create(context.Context, *CreateCertificateRequest) (*Cert, error)
+}
+
+type Cert struct {
+	ClientCert tls.Certificate
+	CACert     *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,
+	}
+
+	template := x509.CertificateRequest{
+		Version:            1,
+		Subject:            subj,
+		SignatureAlgorithm: x509.SHA256WithRSA,
+	}
+
+	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
+	}
+
+	caCert, err := parseCert(cr.CertificateChain)
+	if err != nil {
+		return nil, fmt.Errorf("parsing certificate chain failed: %s", err)
+	}
+
+	privateKey := pem.EncodeToMemory(
+		&pem.Block{
+			Type:  "RSA PRIVATE KEY",
+			Bytes: x509.MarshalPKCS1PrivateKey(r.PrivateKey),
+		},
+	)
+
+	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,
+		CACert:     caCert,
+		RemoteAddr: cr.RemoteAddr,
+		Ports: RemotePorts{
+			Proxy: cr.Ports["proxy"],
+			MySQL: cr.Ports["mysql-tls"],
+		},
+	}, nil
+}
+
+func parseCert(pemCert string) (*x509.Certificate, error) {
+	bl, _ := pem.Decode([]byte(pemCert))
+	if bl == nil {
+		return nil, errors.New("invalid PEM: " + pemCert)
+	}
+	return x509.ParseCertificate(bl.Bytes)
+}