24236186926

Committed 10 Apr 2026 09:25AM UTC coverage: 89.169% (-0.09%) from 89.257%

Build # 24236186926

Build Type

push

gh-ci

Committed by

SimoneLazzaris

Commit Message

fix workflows

Coverage Stats

38207 of 42848 relevant lines covered (89.17%)

151869.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.55

/pkg/pgsql/server/server.go

/*
Copyright 2025 Codenotary Inc. All rights reserved.

SPDX-License-Identifier: BUSL-1.1
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://mariadb.com/bsl11/

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package server

import (
        "context"
        "crypto/tls"
        "errors"
        "fmt"
        "net"
        "os"
        "sync"

        "github.com/codenotary/immudb/embedded/logger"
        "github.com/codenotary/immudb/pkg/database"
        "golang.org/x/net/netutil"
)

type pgsrv struct {
        m                  sync.RWMutex
        running            bool
        maxConnections     int
        tlsConfig          *tls.Config
        logger             logger.Logger
        logRequestMetadata bool
        host               string
        port               int
        immudbPort         int
        dbList             database.DatabaseList
        listener           net.Listener
}

type PGSQLServer interface {
        Initialize() error
        Serve() error
        Stop() error
        GetPort() int
}

func New(setters ...Option) *pgsrv {
        // Default Options
        srv := &pgsrv{
                running:        true,
                maxConnections: 1000,
                tlsConfig:      &tls.Config{},
                logger:         logger.NewSimpleLogger("pgsqlSrv", os.Stderr),
                host:           "0.0.0.0",
                immudbPort:     3322,
                port:           5432,
        }

        for _, setter := range setters {
                setter(srv)
        }

        return srv
}

// Initialize initialize listener. If provided port is zero os auto assign a free one.
func (s *pgsrv) Initialize() (err error) {
        s.listener, err = net.Listen("tcp", fmt.Sprintf("%s:%d", s.host, s.port))
        if err != nil {
                return err
        }
        return nil
}

func (s *pgsrv) Serve() (err error) {
        s.m.Lock()
        if s.listener == nil {
                return errors.New("no listener found for pgsql server")
        }
        s.listener = netutil.LimitListener(s.listener, s.maxConnections)

        if s.tlsConfig == nil || len(s.tlsConfig.Certificates) == 0 {
                s.logger.Warningf("pgsql server is running WITHOUT TLS. " +
                        "Client passwords will be transmitted in cleartext. " +
                        "Configure TLS or disable the pgsql server (--pgsql-server=false) in production.")
        }

        s.m.Unlock()

        for {
                s.m.Lock()
                if !s.running {
                        s.m.Unlock()
                        return nil
                }
                s.m.Unlock()

                conn, err := s.listener.Accept()
                if err != nil {
                        s.logger.Errorf("%v", err)
                } else {
                        go s.handleRequest(context.Background(), conn)
                }
        }
}

func (s *pgsrv) newSession(conn net.Conn) Session {
        return newSession(conn, s.host, s.immudbPort, s.logger, s.tlsConfig, s.logRequestMetadata, s.dbList)
}

func (s *pgsrv) Stop() (err error) {
        s.m.Lock()
        defer s.m.Unlock()

        s.running = false

        if s.listener != nil {
                return s.listener.Close()
        }

        return nil
}

func (s *pgsrv) GetPort() int {
        s.m.Lock()
        defer s.m.Unlock()

        if s.listener != nil {
                return s.listener.Addr().(*net.TCPAddr).Port
        }

        return 0
}

1	/*
2	Copyright 2025 Codenotary Inc. All rights reserved.
3
4	SPDX-License-Identifier: BUSL-1.1
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	https://mariadb.com/bsl11/
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package server
18
19	import (
20	"context"
21	"crypto/tls"
22	"errors"
23	"fmt"
24	"net"
25	"os"
26	"sync"
27
28	"github.com/codenotary/immudb/embedded/logger"
29	"github.com/codenotary/immudb/pkg/database"
30	"golang.org/x/net/netutil"
31	)
32
33	type pgsrv struct {
34	m sync.RWMutex
35	running bool
36	maxConnections int
37	tlsConfig *tls.Config
38	logger logger.Logger
39	logRequestMetadata bool
40	host string
41	port int
42	immudbPort int
43	dbList database.DatabaseList
44	listener net.Listener
45	}
46
47	type PGSQLServer interface {
48	Initialize() error
49	Serve() error
50	Stop() error
51	GetPort() int
52	}
53
54	func New(setters ...Option) *pgsrv {	27✔
55	// Default Options	27✔
56	srv := &pgsrv{	27✔
57	running: true,	27✔
58	maxConnections: 1000,	27✔
59	tlsConfig: &tls.Config{},	27✔
60	logger: logger.NewSimpleLogger("pgsqlSrv", os.Stderr),	27✔
61	host: "0.0.0.0",	27✔
62	immudbPort: 3322,	27✔
63	port: 5432,	27✔
64	}	27✔
65		27✔
66	for _, setter := range setters {	216✔
67	setter(srv)	189✔
68	}	189✔
69
70	return srv	27✔
71	}
72
73	// Initialize initialize listener. If provided port is zero os auto assign a free one.
74	func (s *pgsrv) Initialize() (err error) {	28✔
75	s.listener, err = net.Listen("tcp", fmt.Sprintf("%s:%d", s.host, s.port))	28✔
76	if err != nil {	29✔
77	return err	1✔
78	}	1✔
79	return nil	27✔
80	}
81
82	func (s *pgsrv) Serve() (err error) {	28✔
83	s.m.Lock()	28✔
84	if s.listener == nil {	29✔
85	return errors.New("no listener found for pgsql server")	1✔
86	}	1✔
87	s.listener = netutil.LimitListener(s.listener, s.maxConnections)	27✔
88		27✔
89	if s.tlsConfig == nil \|\| len(s.tlsConfig.Certificates) == 0 {	53✔
90	s.logger.Warningf("pgsql server is running WITHOUT TLS. " +	26✔
91	"Client passwords will be transmitted in cleartext. " +	26✔
92	"Configure TLS or disable the pgsql server (--pgsql-server=false) in production.")	26✔
93	}	26✔
94
95	s.m.Unlock()	27✔
96		27✔
97	for {	81✔
98	s.m.Lock()	54✔
99	if !s.running {	54✔
100	s.m.Unlock()	×
101	return nil	×
102	}	×
103	s.m.Unlock()	54✔
104		54✔
105	conn, err := s.listener.Accept()	54✔
106	if err != nil {	54✔
107	s.logger.Errorf("%v", err)	×
108	} else {	27✔
109	go s.handleRequest(context.Background(), conn)	27✔
110	}	27✔
111	}
112	}
113
114	func (s *pgsrv) newSession(conn net.Conn) Session {	27✔
115	return newSession(conn, s.host, s.immudbPort, s.logger, s.tlsConfig, s.logRequestMetadata, s.dbList)	27✔
116	}	27✔
117
118	func (s *pgsrv) Stop() (err error) {	1✔
119	s.m.Lock()	1✔
120	defer s.m.Unlock()	1✔
121		1✔
122	s.running = false	1✔
123		1✔
124	if s.listener != nil {	1✔
125	return s.listener.Close()	×
126	}	×
127
128	return nil	1✔
129	}
130
131	func (s *pgsrv) GetPort() int {	28✔
132	s.m.Lock()	28✔
133	defer s.m.Unlock()	28✔
134		28✔
135	if s.listener != nil {	55✔
136	return s.listener.Addr().(*net.TCPAddr).Port	27✔
137	}	27✔
138
139	return 0	1✔
140	}

codenotary / immudb / 24236186926

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous