func (c *Config) Connect() (*pgx.Conn, error) {
if c.SSHConnConfig.Host != "" {
client, err := NewSSHClient(&c.SSHConnConfig)
if err != nil {
return nil, err
}
c.ConnConfig.Dial = client.Dial
}
// If sslmode was set in config file or cli argument, set it in the
// environment so we can use pgx.ParseEnvLibpq to use pgx's built-in
// functionality.
switch c.SslMode {
case "disable", "allow", "prefer", "require", "verify-ca", "verify-full":
if err := os.Setenv("PGHOST", c.ConnConfig.Host); err != nil {
return nil, err
}
if err := os.Setenv("PGSSLMODE", c.SslMode); err != nil {
return nil, err
}
if cc, err := pgx.ParseEnvLibpq(); err == nil {
c.ConnConfig.TLSConfig = cc.TLSConfig
c.ConnConfig.UseFallbackTLS = cc.UseFallbackTLS
c.ConnConfig.FallbackTLSConfig = cc.FallbackTLSConfig
} else {
return nil, err
}
}
return pgx.Connect(c.ConnConfig)
}
// Connect connects to the database using env vars.
// After connect, it creates tables if missing.
func (p *DB) Connect() (err error) {
cfg, err := pgx.ParseEnvLibpq()
if err != nil {
return
}
pool, err := pgx.NewConnPool(pgx.ConnPoolConfig{
ConnConfig: cfg,
MaxConnections: 25,
})
if err != nil {
return
}
c, err := pgx_stdlib.OpenFromConnPool(pool)
if err != nil {
return
}
p.conn, err = gorm.Open("postgres", c)
if err != nil {
return
}
d := p.conn.AutoMigrate(&secrets.Secret{}, &secrets.Key{})
return d.Error
}
func extractConfig() (config pgx.ConnPoolConfig, err error) {
config.ConnConfig, err = pgx.ParseEnvLibpq()
if err != nil {
return config, err
}
if config.Host == "" {
config.Host = "localhost"
}
if config.User == "" {
config.User = os.Getenv("USER")
}
if config.Database == "" {
config.Database = "go_db_bench"
}
config.TLSConfig = nil
config.UseFallbackTLS = false
config.MaxConnections = 10
return config, nil
}
func createConnPool() (*pgx.ConnPool, error) {
var config pgx.ConnPoolConfig
var err error
config.ConnConfig, err = pgx.ParseEnvLibpq()
if err != nil {
return nil, err
}
if config.Host == "" {
config.Host = "localhost"
}
if config.User == "" {
config.User = os.Getenv("USER")
}
if config.Database == "" {
config.Database = "pgxdata"
}
config.TLSConfig = nil
config.UseFallbackTLS = false
config.MaxConnections = 10
return pgx.NewConnPool(config)
}
func getConfig() pgx.ConnPoolConfig {
var err interface{}
var connPoolConfig pgx.ConnPoolConfig
connPoolConfig.ConnConfig, err = pgx.ParseEnvLibpq()
if err != nil {
log.Fatalf("Postgresql connection information missing from the environment: %v", err)
}
connPoolConfig.MaxConnections = 10
return connPoolConfig
}
func NewPgxPool(url string) (*pgx.ConnPool, error) {
dbcfg := pgx.ConnPoolConfig{
MaxConnections: maxConnectionsFlag.Value(),
}
var err error
if url == "" {
dbcfg.ConnConfig, err = pgx.ParseEnvLibpq()
} else if strings.HasPrefix(url, "postgresql://") {
dbcfg.ConnConfig, err = pgx.ParseURI(url)
} else {
dbcfg.ConnConfig, err = pgx.ParseDSN(url)
}
if err != nil {
return nil, err
}
return pgx.NewConnPool(dbcfg)
}
func LoadConfig() (*Config, error) {
config := &Config{VersionTable: "schema_version"}
if connConfig, err := pgx.ParseEnvLibpq(); err == nil {
config.ConnConfig = connConfig
} else {
return nil, err
}
// Set default config path only if it exists
if cliOptions.configPath == "" {
if _, err := os.Stat("./tern.conf"); err == nil {
cliOptions.configPath = "./tern.conf"
}
}
if cliOptions.configPath != "" {
err := appendConfigFromFile(config, cliOptions.configPath)
if err != nil {
return nil, err
}
}
appendConfigFromCLIArgs(config)
if config.SSHConnConfig.User == "" {
user, err := user.Current()
if err != nil {
return nil, err
}
config.SSHConnConfig.User = user.Username
}
if config.SSHConnConfig.Port == "" {
config.SSHConnConfig.Port = "ssh"
}
return config, nil
}
func generateCmd(cmd *cobra.Command, args []string) {
if len(args) != 0 {
fmt.Fprintln(os.Stderr, "generate does not take any arguments")
os.Exit(1)
}
var c Config
var err error
c.Database, err = pgx.ParseEnvLibpq()
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
_, err = toml.DecodeFile("config.toml", &c)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
conn, err := pgx.Connect(c.Database)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
err = inspectDatabase(conn, c.Tables)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
templates := loadTemplates()
supportData := initData{
PkgName: c.Package,
Version: VERSION,
BoxTypes: []boxType{
{Name: "Bool", ValueType: "bool", FormatCode: "pgx.BinaryFormatCode"},
{Name: "Int16", ValueType: "int16", FormatCode: "pgx.BinaryFormatCode"},
{Name: "Int32", ValueType: "int32", FormatCode: "pgx.BinaryFormatCode"},
{Name: "Int64", ValueType: "int64", FormatCode: "pgx.BinaryFormatCode"},
{Name: "String", ValueType: "string", FormatCode: "pgx.TextFormatCode"},
{Name: "Time", ValueType: "time.Time", FormatCode: "pgx.BinaryFormatCode"},
{Name: "IPNet", ValueType: "net.IPNet", FormatCode: "pgx.BinaryFormatCode"},
},
IntBoxTypes: []intBoxType{
{Name: "Int16", BitSize: 16},
{Name: "Int32", BitSize: 32},
{Name: "Int64", BitSize: 64},
},
}
supportFiles := []struct {
path string
tmpl *template.Template
}{
{"pgxdata_attribute.go", templates.Lookup("attribute")},
{"pgxdata_db.go", templates.Lookup("db")},
}
for _, f := range supportFiles {
err := writeSupportFile(f.path, f.tmpl, supportData)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
for _, t := range c.Tables {
file, err := os.Create("pgxdata_" + goCaseToFileCase(t.StructName) + ".go")
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
err = writeTableCrud(file, templates, c.Package, t)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
file.Close()
}
}
func TestParseEnvLibpq(t *testing.T) {
pgEnvvars := []string{"PGHOST", "PGPORT", "PGDATABASE", "PGUSER", "PGPASSWORD", "PGAPPNAME"}
savedEnv := make(map[string]string)
for _, n := range pgEnvvars {
savedEnv[n] = os.Getenv(n)
}
defer func() {
for k, v := range savedEnv {
err := os.Setenv(k, v)
if err != nil {
t.Fatalf("Unable to restore environment: %v", err)
}
}
}()
tests := []struct {
name string
envvars map[string]string
config pgx.ConnConfig
}{
{
name: "No environment",
envvars: map[string]string{},
config: pgx.ConnConfig{
TLSConfig: &tls.Config{InsecureSkipVerify: true},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
name: "Normal PG vars",
envvars: map[string]string{
"PGHOST": "123.123.123.123",
"PGPORT": "7777",
"PGDATABASE": "foo",
"PGUSER": "******",
"PGPASSWORD": "******",
},
config: pgx.ConnConfig{
Host: "123.123.123.123",
Port: 7777,
Database: "foo",
User: "******",
Password: "******",
TLSConfig: &tls.Config{InsecureSkipVerify: true},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
name: "application_name",
envvars: map[string]string{
"PGAPPNAME": "pgxtest",
},
config: pgx.ConnConfig{
TLSConfig: &tls.Config{InsecureSkipVerify: true},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{"application_name": "pgxtest"},
},
},
{
name: "sslmode=disable",
envvars: map[string]string{
"PGSSLMODE": "disable",
},
config: pgx.ConnConfig{
TLSConfig: nil,
UseFallbackTLS: false,
RuntimeParams: map[string]string{},
},
},
{
name: "sslmode=allow",
envvars: map[string]string{
"PGSSLMODE": "allow",
},
config: pgx.ConnConfig{
TLSConfig: nil,
UseFallbackTLS: true,
FallbackTLSConfig: &tls.Config{InsecureSkipVerify: true},
RuntimeParams: map[string]string{},
},
},
{
name: "sslmode=prefer",
envvars: map[string]string{
"PGSSLMODE": "prefer",
},
config: pgx.ConnConfig{
TLSConfig: &tls.Config{InsecureSkipVerify: true},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
name: "sslmode=require",
envvars: map[string]string{
"PGSSLMODE": "require",
},
config: pgx.ConnConfig{
TLSConfig: &tls.Config{},
UseFallbackTLS: false,
RuntimeParams: map[string]string{},
},
},
{
name: "sslmode=verify-ca",
envvars: map[string]string{
"PGSSLMODE": "verify-ca",
},
config: pgx.ConnConfig{
TLSConfig: &tls.Config{},
UseFallbackTLS: false,
RuntimeParams: map[string]string{},
},
},
{
name: "sslmode=verify-full",
envvars: map[string]string{
"PGSSLMODE": "verify-full",
},
config: pgx.ConnConfig{
TLSConfig: &tls.Config{},
UseFallbackTLS: false,
RuntimeParams: map[string]string{},
},
},
{
name: "sslmode=verify-full with host",
envvars: map[string]string{
"PGHOST": "pgx.example",
"PGSSLMODE": "verify-full",
},
config: pgx.ConnConfig{
Host: "pgx.example",
TLSConfig: &tls.Config{
ServerName: "pgx.example",
},
UseFallbackTLS: false,
RuntimeParams: map[string]string{},
},
},
}
for _, tt := range tests {
for _, n := range pgEnvvars {
err := os.Unsetenv(n)
if err != nil {
t.Fatalf("%s: Unable to clear environment: %v", tt.name, err)
}
}
for k, v := range tt.envvars {
err := os.Setenv(k, v)
if err != nil {
t.Fatalf("%s: Unable to set environment: %v", tt.name, err)
}
}
config, err := pgx.ParseEnvLibpq()
if err != nil {
t.Errorf("%s: Unexpected error from pgx.ParseLibpq() => %v", tt.name, err)
continue
}
if config.Host != tt.config.Host {
t.Errorf("%s: expected Host to be %v got %v", tt.name, tt.config.Host, config.Host)
}
if config.Port != tt.config.Port {
t.Errorf("%s: expected Port to be %v got %v", tt.name, tt.config.Port, config.Port)
}
if config.Port != tt.config.Port {
t.Errorf("%s: expected Port to be %v got %v", tt.name, tt.config.Port, config.Port)
}
if config.User != tt.config.User {
t.Errorf("%s: expected User to be %v got %v", tt.name, tt.config.User, config.User)
}
if config.Password != tt.config.Password {
t.Errorf("%s: expected Password to be %v got %v", tt.name, tt.config.Password, config.Password)
}
if !reflect.DeepEqual(config.RuntimeParams, tt.config.RuntimeParams) {
t.Errorf("%s: expected RuntimeParams to be %#v got %#v", tt.name, tt.config.RuntimeParams, config.RuntimeParams)
}
tlsTests := []struct {
name string
expected *tls.Config
actual *tls.Config
}{
{
name: "TLSConfig",
expected: tt.config.TLSConfig,
actual: config.TLSConfig,
},
{
name: "FallbackTLSConfig",
expected: tt.config.FallbackTLSConfig,
actual: config.FallbackTLSConfig,
},
}
for _, tlsTest := range tlsTests {
name := tlsTest.name
expected := tlsTest.expected
actual := tlsTest.actual
if expected == nil && actual != nil {
t.Errorf("%s / %s: expected nil, but it was set", tt.name, name)
} else if expected != nil && actual == nil {
t.Errorf("%s / %s: expected to be set, but got nil", tt.name, name)
} else if expected != nil && actual != nil {
if actual.InsecureSkipVerify != expected.InsecureSkipVerify {
t.Errorf("%s / %s: expected InsecureSkipVerify to be %v got %v", tt.name, name, expected.InsecureSkipVerify, actual.InsecureSkipVerify)
}
if actual.ServerName != expected.ServerName {
t.Errorf("%s / %s: expected ServerName to be %v got %v", tt.name, name, expected.ServerName, actual.ServerName)
}
}
}
if config.UseFallbackTLS != tt.config.UseFallbackTLS {
t.Errorf("%s: expected UseFallbackTLS to be %v got %v", tt.name, tt.config.UseFallbackTLS, config.UseFallbackTLS)
}
}
}