0
0
package pgunit
import (
"bufio"
"context"
"encoding/binary"
"errors"
"fmt"
"io"
"net"
"path/filepath"
"time"
)
const (
protocolVersion = 196608
DialTimeout = 10 * time.Second
)
type Error struct {
Severity string
Code string
Message string
}
func (e *Error) Error() string {
return fmt.Sprintf("postgres %s %s: %s", e.Severity, e.Code, e.Message)
}
type conn struct {
c net.Conn
r *bufio.Reader
}
func cstring(b []byte) (string, []byte) {
for i, c := range b {
if c == 0 {
return string(b[:i]), b[i+1:]
}
}
return string(b), nil
}
func parseError(p []byte) *Error {
e := &Error{}
for len(p) > 0 && p[0] != 0 {
t := p[0]
var v string
v, p = cstring(p[1:])
switch t {
case 'S':
e.Severity = v
case 'C':
e.Code = v
case 'M':
e.Message = v
}
}
return e
}
func (c *conn) send(t byte, payload []byte) error {
var head []byte
if t != 0 {
head = append(head, t)
}
head = binary.BigEndian.AppendUint32(head, uint32(len(payload)+4))
_, err := c.c.Write(append(head, payload...))
return err
}
func (c *conn) recv() (byte, []byte, error) {
var head [5]byte
if _, err := io.ReadFull(c.r, head[:]); err != nil {
return 0, nil, err
}
n := binary.BigEndian.Uint32(head[1:])
if n < 4 || n > 1<<26 {
return 0, nil, fmt.Errorf("pgunit: a %d-byte message is not postgres", n)
}
p := make([]byte, n-4)
_, err := io.ReadFull(c.r, p)
return head[0], p, err
}
func (c *conn) untilReady() ([][]string, error) {
var rows [][]string
var failed error
for {
t, p, err := c.recv()
if err != nil {
return nil, err
}
switch t {
case 'E':
e := parseError(p)
if e.Severity == "FATAL" || e.Severity == "PANIC" {
return nil, e
}
failed = e
case 'R':
if len(p) < 4 || binary.BigEndian.Uint32(p) != 0 {
return nil, errors.New("pgunit: postgres asked for a password; the socket is trust-only to its account")
}
case 'D':
if len(p) < 2 {
return nil, errors.New("pgunit: a short data row")
}
cols := int(binary.BigEndian.Uint16(p))
p = p[2:]
row := make([]string, 0, cols)
for range cols {
if len(p) < 4 {
return nil, errors.New("pgunit: a short data row")
}
l := int32(binary.BigEndian.Uint32(p))
p = p[4:]
if l < 0 {
row = append(row, "")
continue
}
if int(l) > len(p) {
return nil, errors.New("pgunit: a short data row")
}
row = append(row, string(p[:l]))
p = p[l:]
}
rows = append(rows, row)
case 'Z':
return rows, failed
}
}
}
func dial(ctx context.Context, socketDir, user, db string) (*conn, error) {
if err := CheckSocketDir(socketDir); err != nil {
return nil, err
}
d := net.Dialer{Timeout: DialTimeout}
nc, err := d.DialContext(ctx, "unix", filepath.Join(socketDir, SocketName))
if err != nil {
return nil, err
}
deadline, ok := ctx.Deadline()
if !ok {
deadline = time.Now().Add(DialTimeout)
}
nc.SetDeadline(deadline)
c := &conn{c: nc, r: bufio.NewReader(nc)}
var p []byte
p = binary.BigEndian.AppendUint32(p, protocolVersion)
for _, kv := range [][2]string{{"user", user}, {"database", db}} {
p = append(append(append(append(p, kv[0]...), 0), kv[1]...), 0)
}
p = append(p, 0)
if err := c.send(0, p); err != nil {
nc.Close()
return nil, err
}
if _, err := c.untilReady(); err != nil {
nc.Close()
return nil, err
}
return c, nil
}
func (c *conn) close() {
c.send('X', nil)
c.c.Close()
}
func Query(ctx context.Context, socketDir, user, db, sql string) ([][]string, error) {
c, err := dial(ctx, socketDir, user, db)
if err != nil {
return nil, err
}
defer c.close()
if err := c.send('Q', append([]byte(sql), 0)); err != nil {
return nil, err
}
return c.untilReady()
}
func Ready(ctx context.Context, socketDir, user string) error {
rows, err := Query(ctx, socketDir, user, "postgres", "SELECT 1")
if err != nil {
return err
}
if len(rows) != 1 || len(rows[0]) != 1 || rows[0][0] != "1" {
return fmt.Errorf("pgunit: SELECT 1 answered %v", rows)
}
return nil
}
func ServerVersion(ctx context.Context, socketDir, user string) (string, error) {
rows, err := Query(ctx, socketDir, user, "postgres", "SHOW server_version")
if err != nil {
return "", err
}
if len(rows) != 1 || len(rows[0]) != 1 {
return "", fmt.Errorf("pgunit: SHOW server_version answered %v", rows)
}
return rows[0][0], nil
}
func CreateDatabase(ctx context.Context, socketDir, user, name string) (bool, error) {
if len(name) > 63 || !nameRE.MatchString(name) {
return false, fmt.Errorf("pgunit: database %q: want lower-case letters, digits and underscores", name)
}
rows, err := Query(ctx, socketDir, user, "postgres", "SELECT 1 FROM pg_database WHERE datname = '"+name+"'")
if err != nil {
return false, err
}
if len(rows) > 0 {
return false, nil
}
_, err = Query(ctx, socketDir, user, "postgres", "CREATE DATABASE "+name)
var pe *Error
if errors.As(err, &pe) && (pe.Code == "42P04" || pe.Code == "23505") {
return false, nil
}
return err == nil, err
}