MSSQL

/*

** Zabbix

** Copyright (C) 2001-2025 Zabbix SIA

**

** Licensed under the Apache License, Version 2.0 (the "License");

** you may not use this file except in compliance with the License.

** You may obtain a copy of the License at

**

**     http://www.apache.org/licenses/LICENSE-2.0

**

** 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 dbconn

​

import (

    "context"

    "database/sql"

    "fmt"

    "net/url"

    "path/filepath"

    "strconv"

    "sync"

    "time"

​

    "golang.zabbix.com/plugin/mssql/plugin/handlers"

    "golang.zabbix.com/plugin/mssql/plugin/params"

    "golang.zabbix.com/sdk/errs"

    "golang.zabbix.com/sdk/log"

    "golang.zabbix.com/sdk/uri"

)

​

var (

    _ handlers.HandlerFunc = (*ConnCollection)(nil).WithConnHandlerFunc(nil)

    _ handlers.HandlerFunc = (*ConnCollection)(nil).PingHandler

)

​

// connConfig is a configuration for a connection to the database.

type connConfig struct {

    URI                    string

    User                   string

    Password               string

    CACertPath             string

    TrustServerCertificate string

    HostNameInCertificate  string

    Encrypt                string

    TLSMinVersion          string

    Database               string

}

​

// ConnCollection is a collection of connections to the database.

// Allows managing multiple connections.

type ConnCollection struct {

    mu           sync.Mutex

    conns        map[connConfig]*sql.DB

    keepAlive    int

    queryTimeout int

    logr         log.Logger

    driverName   string // always sqlserver, allow to change for unit tests.

}

​

// Init initializes a pre-allocated connection collection.

func (c *ConnCollection) Init(keepAlive, queryTimeout int, logr log.Logger) {

    c.conns = make(map[connConfig]*sql.DB)

    c.keepAlive = keepAlive

    c.queryTimeout = queryTimeout

    c.logr = logr

    c.driverName = "sqlserver"

}

​

// WithConnHandlerFunc creates a new function that creates or gets cached DB

// connection for the given metric parameters and calls the given handler

// function with the connection.

func (c *ConnCollection) WithConnHandlerFunc(

    handler handlers.ConnHandlerFunc,

) handlers.HandlerFunc {

    return func(

        metricParams map[string]string, extraParams ...string,

    ) (any, error) {

        ctx, cancel := context.WithTimeout(

            context.Background(),

            time.Duration(c.queryTimeout)*time.Second,

        )

        defer cancel()

​

        conn, err := c.get(ctx, newConnConfig(metricParams))

        if err != nil {