func OpenDatabaseConnection(config configuration.DatabaseConfiguration) (pool *pgx.ConnPool, err error) {
connectionUri := fmt.Sprintf("postgres://%s:%s@%s:%s/%s?sslmode=%s",
config.User,
config.Password,
config.Host,
config.Port,
config.Database,
config.SSLMode)
connectionConfig, err := pgx.ParseURI(connectionUri)
if err != nil {
return pool, err
}
maxConnections := 50
poolConfig := pgx.ConnPoolConfig{connectionConfig, maxConnections, nil}
pool, err = pgx.NewConnPool(poolConfig)
if err != nil {
return pool, err
}
Database = pool
return pool, err
}
func TestParseURI(t *testing.T) {
t.Parallel()
tests := []struct {
url string
connParams pgx.ConnConfig
}{
{
url: "postgres://*****:*****@localhost:5432/mydb",
connParams: pgx.ConnConfig{
User: "******",
Password: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
},
},
{
url: "postgresql://*****:*****@localhost:5432/mydb",
connParams: pgx.ConnConfig{
User: "******",
Password: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
},
},
{
url: "postgres://jack@localhost:5432/mydb",
connParams: pgx.ConnConfig{
User: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
},
},
{
url: "postgres://jack@localhost/mydb",
connParams: pgx.ConnConfig{
User: "******",
Host: "localhost",
Database: "mydb",
},
},
}
for i, tt := range tests {
connParams, err := pgx.ParseURI(tt.url)
if err != nil {
t.Errorf("%d. Unexpected error from pgx.ParseURL(%q) => %v", i, tt.url, err)
continue
}
if connParams != tt.connParams {
t.Errorf("%d. expected %#v got %#v", i, tt.connParams, connParams)
}
}
}
func getPgxPool(dbURL string) (*pgx.ConnPool, error) {
pgxcfg, err := pgx.ParseURI(dbURL)
if err != nil {
return nil, err
}
pgxpool, err := pgx.NewConnPool(pgx.ConnPoolConfig{
ConnConfig: pgxcfg,
AfterConnect: prepQue,
})
if err != nil {
return nil, err
}
return pgxpool, nil
}
// NewQueClient create que client
func NewQueClient(dbURI string) (*que.Client, error) {
pgxcfg, err := pgx.ParseURI(dbURI)
if err != nil {
log.Fatal(err)
}
var qc *que.Client
pgxpool, err := pgx.NewConnPool(pgx.ConnPoolConfig{
ConnConfig: pgxcfg,
AfterConnect: que.PrepareStatements,
})
if err != nil {
log.Fatal(err)
return qc, err
}
log.Println("create que client")
qc = que.NewClient(pgxpool)
return qc, nil
}
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 (d *Driver) Open(name string) (driver.Conn, error) {
if d.Pool != nil {
conn, err := d.Pool.Acquire()
if err != nil {
return nil, err
}
return &Conn{conn: conn, pool: d.Pool}, nil
}
connConfig, err := pgx.ParseURI(name)
if err != nil {
return nil, err
}
conn, err := pgx.Connect(connConfig)
if err != nil {
return nil, err
}
c := &Conn{conn: conn}
return c, nil
}
func main() {
memcachedURL := getEnv("MEMCACHEDCLOUD_SERVERS", "localhost:11211")
var err error
cn, err = mc.Dial("tcp", memcachedURL)
if err != nil {
log.Fatalf("Memcached connection error: %s", err)
}
memcachedUsername := os.Getenv("MEMCACHEDCLOUD_USERNAME")
memcachedPassword := os.Getenv("MEMCACHEDCLOUD_PASSWORD")
if memcachedUsername != "" && memcachedPassword != "" {
if err := cn.Auth(memcachedUsername, memcachedPassword); err != nil {
log.Fatalf("Memcached auth error: %s", err)
}
}
pgxcfg, err := pgx.ParseURI(os.Getenv("DATABASE_URL"))
if err != nil {
log.Fatalf("Parse URI error: %s", err)
}
pool, err = pgx.NewConnPool(pgx.ConnPoolConfig{
ConnConfig: pgxcfg,
MaxConnections: 20,
AfterConnect: func(conn *pgx.Conn) error {
_, err := conn.Prepare("getPackage", `SELECT name, url FROM packages WHERE name = $1`)
return err
},
})
if err != nil {
log.Fatalf("Connection error: %s", err)
}
defer pool.Close()
binary, err := exec.LookPath("node")
if err != nil {
log.Fatalf("Could not lookup node path: %s", err)
}
cmd := exec.Command(binary, "--expose_gc", "index.js")
env := os.Environ()
env = append([]string{"PORT=3001"}, env...)
cmd.Env = env
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Start(); err != nil {
log.Fatalf("Could not start node: %s", err)
}
go func() {
if err := cmd.Wait(); err != nil {
log.Fatalf("Node process failed: %s", err)
}
}()
proxy = goproxy.NewProxyHttpServer()
proxy.Verbose = false
proxy.NonproxyHandler = http.HandlerFunc(nonProxy)
proxy.OnRequest(pathIs("/packages")).DoFunc(listPackages)
proxy.OnRequest(urlHasPrefix("/packages/")).DoFunc(getPackage)
port := getEnv("PORT", "3000")
log.Println("Starting web server at port", port)
log.Fatal(http.ListenAndServe(":"+port, proxy))
}
func TestParseURI(t *testing.T) {
t.Parallel()
tests := []struct {
url string
connParams pgx.ConnConfig
}{
{
url: "postgres://*****:*****@localhost:5432/mydb?sslmode=prefer",
connParams: pgx.ConnConfig{
User: "******",
Password: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
TLSConfig: &tls.Config{
InsecureSkipVerify: true,
},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
url: "postgres://*****:*****@localhost:5432/mydb?sslmode=disable",
connParams: pgx.ConnConfig{
User: "******",
Password: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
TLSConfig: nil,
UseFallbackTLS: false,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
url: "postgres://*****:*****@localhost:5432/mydb",
connParams: pgx.ConnConfig{
User: "******",
Password: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
TLSConfig: &tls.Config{
InsecureSkipVerify: true,
},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
url: "postgresql://*****:*****@localhost:5432/mydb",
connParams: pgx.ConnConfig{
User: "******",
Password: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
TLSConfig: &tls.Config{
InsecureSkipVerify: true,
},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
url: "postgres://jack@localhost:5432/mydb",
connParams: pgx.ConnConfig{
User: "******",
Host: "localhost",
Port: 5432,
Database: "mydb",
TLSConfig: &tls.Config{
InsecureSkipVerify: true,
},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
url: "postgres://jack@localhost/mydb",
connParams: pgx.ConnConfig{
User: "******",
Host: "localhost",
Database: "mydb",
TLSConfig: &tls.Config{
InsecureSkipVerify: true,
},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{},
},
},
{
url: "postgres://jack@localhost/mydb?application_name=pgxtest&search_path=myschema",
connParams: pgx.ConnConfig{
User: "******",
Host: "localhost",
Database: "mydb",
TLSConfig: &tls.Config{
InsecureSkipVerify: true,
},
UseFallbackTLS: true,
FallbackTLSConfig: nil,
RuntimeParams: map[string]string{
"application_name": "pgxtest",
"search_path": "myschema",
},
},
},
}
for i, tt := range tests {
connParams, err := pgx.ParseURI(tt.url)
if err != nil {
t.Errorf("%d. Unexpected error from pgx.ParseURL(%q) => %v", i, tt.url, err)
continue
}
if !reflect.DeepEqual(connParams, tt.connParams) {
t.Errorf("%d. expected %#v got %#v", i, tt.connParams, connParams)
}
}
}
