planetscale 0.2.0 → 0.3.3

data/vendor/github.com/pkg/errors/stack.go

@@ -1,177 +0,0 @@
-package errors
-
-import (
-	"fmt"
-	"io"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-// Frame represents a program counter inside a stack frame.
-// For historical reasons if Frame is interpreted as a uintptr
-// its value represents the program counter + 1.
-type Frame uintptr
-
-// pc returns the program counter for this frame;
-// multiple frames may have the same PC value.
-func (f Frame) pc() uintptr { return uintptr(f) - 1 }
-
-// file returns the full path to the file that contains the
-// function for this Frame's pc.
-func (f Frame) file() string {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return "unknown"
-	}
-	file, _ := fn.FileLine(f.pc())
-	return file
-}
-
-// line returns the line number of source code of the
-// function for this Frame's pc.
-func (f Frame) line() int {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return 0
-	}
-	_, line := fn.FileLine(f.pc())
-	return line
-}
-
-// name returns the name of this function, if known.
-func (f Frame) name() string {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return "unknown"
-	}
-	return fn.Name()
-}
-
-// Format formats the frame according to the fmt.Formatter interface.
-//
-//    %s    source file
-//    %d    source line
-//    %n    function name
-//    %v    equivalent to %s:%d
-//
-// Format accepts flags that alter the printing of some verbs, as follows:
-//
-//    %+s   function name and path of source file relative to the compile time
-//          GOPATH separated by \n\t (<funcname>\n\t<path>)
-//    %+v   equivalent to %+s:%d
-func (f Frame) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 's':
-		switch {
-		case s.Flag('+'):
-			io.WriteString(s, f.name())
-			io.WriteString(s, "\n\t")
-			io.WriteString(s, f.file())
-		default:
-			io.WriteString(s, path.Base(f.file()))
-		}
-	case 'd':
-		io.WriteString(s, strconv.Itoa(f.line()))
-	case 'n':
-		io.WriteString(s, funcname(f.name()))
-	case 'v':
-		f.Format(s, 's')
-		io.WriteString(s, ":")
-		f.Format(s, 'd')
-	}
-}
-
-// MarshalText formats a stacktrace Frame as a text string. The output is the
-// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
-func (f Frame) MarshalText() ([]byte, error) {
-	name := f.name()
-	if name == "unknown" {
-		return []byte(name), nil
-	}
-	return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
-}
-
-// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
-type StackTrace []Frame
-
-// Format formats the stack of Frames according to the fmt.Formatter interface.
-//
-//    %s	lists source files for each Frame in the stack
-//    %v	lists the source file and line number for each Frame in the stack
-//
-// Format accepts flags that alter the printing of some verbs, as follows:
-//
-//    %+v   Prints filename, function, and line number for each Frame in the stack.
-func (st StackTrace) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		switch {
-		case s.Flag('+'):
-			for _, f := range st {
-				io.WriteString(s, "\n")
-				f.Format(s, verb)
-			}
-		case s.Flag('#'):
-			fmt.Fprintf(s, "%#v", []Frame(st))
-		default:
-			st.formatSlice(s, verb)
-		}
-	case 's':
-		st.formatSlice(s, verb)
-	}
-}
-
-// formatSlice will format this StackTrace into the given buffer as a slice of
-// Frame, only valid when called with '%s' or '%v'.
-func (st StackTrace) formatSlice(s fmt.State, verb rune) {
-	io.WriteString(s, "[")
-	for i, f := range st {
-		if i > 0 {
-			io.WriteString(s, " ")
-		}
-		f.Format(s, verb)
-	}
-	io.WriteString(s, "]")
-}
-
-// stack represents a stack of program counters.
-type stack []uintptr
-
-func (s *stack) Format(st fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		switch {
-		case st.Flag('+'):
-			for _, pc := range *s {
-				f := Frame(pc)
-				fmt.Fprintf(st, "\n%+v", f)
-			}
-		}
-	}
-}
-
-func (s *stack) StackTrace() StackTrace {
-	f := make([]Frame, len(*s))
-	for i := 0; i < len(f); i++ {
-		f[i] = Frame((*s)[i])
-	}
-	return f
-}
-
-func callers() *stack {
-	const depth = 32
-	var pcs [depth]uintptr
-	n := runtime.Callers(3, pcs[:])
-	var st stack = pcs[0:n]
-	return &st
-}
-
-// funcname removes the path prefix component of a function's name reported by func.Name().
-func funcname(name string) string {
-	i := strings.LastIndex(name, "/")
-	name = name[i+1:]
-	i = strings.Index(name, ".")
-	return name[i+1:]
-}

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

@@ -1,139 +0,0 @@
-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

@@ -1,258 +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"`
-	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

@@ -1,142 +0,0 @@
-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)
-}